https://www.extenc.com/modules/metidatatable/lib/datatables.js?v=7717f27557944e175e7628aef560f964

1/*
2 * This combined file was created by the DataTables downloader builder:
3 *   https://datatables.net/download
4 *
5 * To rebuild or modify this file with the latest versions of the included
6 * software please visit:
7 *   https://datatables.net/download/#bs/jszip-2.5.0/dt-1.10.18/b-1.5.4/b-colvis-1.5.4/b-html5-1.5.4/cr-1.5.0/fh-3.1.4/r-2.2.2/rg-1.1.0/sc-1.5.0/sl-1.2.6
8 *
9 * Included libraries:
10 *   JSZip 2.5.0, DataTables 1.10.18, Buttons 1.5.4, Column visibility 1.5.4, HTML5 export 1.5.4, ColReorder 1.5.0, FixedHeader 3.1.4, Responsive 2.2.2, RowGroup 1.1.0, Scroller 1.5.0, Select 1.2.6
11 */
12
13/*!
14
15JSZip - A Javascript class for generating and reading zip files
16<http://stuartk.com/jszip>
17
18(c) 2009-2014 Stuart Knightley <stuart [at] stuartk.com>
19Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/master/LICENSE.markdown.
20
21JSZip uses the library pako released under the MIT license :
22https://github.com/nodeca/pako/blob/master/LICENSE
23*/
24!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){
25'use strict';
26// private property
27var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
28
29
30// public method for encoding
31exports.encode = function(input, utf8) {
32    var output = "";
33    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
34    var i = 0;
35
36    while (i < input.length) {
37
38        chr1 = input.charCodeAt(i++);
39        chr2 = input.charCodeAt(i++);
40        chr3 = input.charCodeAt(i++);
41
42        enc1 = chr1 >> 2;
43        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
44        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
45        enc4 = chr3 & 63;
46
47        if (isNaN(chr2)) {
48            enc3 = enc4 = 64;
49        }
50        else if (isNaN(chr3)) {
51            enc4 = 64;
52        }
53
54        output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
55
56    }
57
58    return output;
59};
60
61// public method for decoding
62exports.decode = function(input, utf8) {
63    var output = "";
64    var chr1, chr2, chr3;
65    var enc1, enc2, enc3, enc4;
66    var i = 0;
67
68    input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
69
70    while (i < input.length) {
71
72        enc1 = _keyStr.indexOf(input.charAt(i++));
73        enc2 = _keyStr.indexOf(input.charAt(i++));
74        enc3 = _keyStr.indexOf(input.charAt(i++));
75        enc4 = _keyStr.indexOf(input.charAt(i++));
76
77        chr1 = (enc1 << 2) | (enc2 >> 4);
78        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
79        chr3 = ((enc3 & 3) << 6) | enc4;
80
81        output = output + String.fromCharCode(chr1);
82
83        if (enc3 != 64) {
84            output = output + String.fromCharCode(chr2);
85        }
86        if (enc4 != 64) {
87            output = output + String.fromCharCode(chr3);
88        }
89
90    }
91
92    return output;
93
94};
95
96},{}],2:[function(_dereq_,module,exports){
97'use strict';
98function CompressedObject() {
99    this.compressedSize = 0;
100    this.uncompressedSize = 0;
101    this.crc32 = 0;
102    this.compressionMethod = null;
103    this.compressedContent = null;
104}
105
106CompressedObject.prototype = {
107    /**
108     * Return the decompressed content in an unspecified format.
109     * The format will depend on the decompressor.
110     * @return {Object} the decompressed content.
111     */
112    getContent: function() {
113        return null; // see implementation
114    },
115    /**
116     * Return the compressed content in an unspecified format.
117     * The format will depend on the compressed conten source.
118     * @return {Object} the compressed content.
119     */
120    getCompressedContent: function() {
121        return null; // see implementation
122    }
123};
124module.exports = CompressedObject;
125
126},{}],3:[function(_dereq_,module,exports){
127'use strict';
128exports.STORE = {
129    magic: "\x00\x00",
130    compress: function(content, compressionOptions) {
131        return content; // no compression
132    },
133    uncompress: function(content) {
134        return content; // no compression
135    },
136    compressInputType: null,
137    uncompressInputType: null
138};
139exports.DEFLATE = _dereq_('./flate');
140
141},{"./flate":8}],4:[function(_dereq_,module,exports){
142'use strict';
143
144var utils = _dereq_('./utils');
145
146var table = [
147    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
148    0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
149    0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
150    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
151    0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
152    0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
153    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
154    0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
155    0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
156    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
157    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
158    0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
159    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
160    0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
161    0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
162    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
163    0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
164    0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
165    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
166    0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
167    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
168    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
169    0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
170    0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
171    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
172    0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
173    0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
174    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
175    0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
176    0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
177    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
178    0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
179    0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
180    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
181    0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
182    0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
183    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
184    0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
185    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
186    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
187    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
188    0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
189    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
190    0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
191    0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
192    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
193    0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
194    0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
195    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
196    0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
197    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
198    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
199    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
200    0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
201    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
202    0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
203    0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
204    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
205    0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
206    0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
207    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
208    0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
209    0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
210    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
211];
212
213/**
214 *
215 *  Javascript crc32
216 *  http://www.webtoolkit.info/
217 *
218 */
219module.exports = function crc32(input, crc) {
220    if (typeof input === "undefined" || !input.length) {
221        return 0;
222    }
223
224    var isArray = utils.getTypeOf(input) !== "string";
225
226    if (typeof(crc) == "undefined") {
227        crc = 0;
228    }
229    var x = 0;
230    var y = 0;
231    var b = 0;
232
233    crc = crc ^ (-1);
234    for (var i = 0, iTop = input.length; i < iTop; i++) {
235        b = isArray ? input[i] : input.charCodeAt(i);
236        y = (crc ^ b) & 0xFF;
237        x = table[y];
238        crc = (crc >>> 8) ^ x;
239    }
240
241    return crc ^ (-1);
242};
243// vim: set shiftwidth=4 softtabstop=4:
244
245},{"./utils":21}],5:[function(_dereq_,module,exports){
246'use strict';
247var utils = _dereq_('./utils');
248
249function DataReader(data) {
250    this.data = null; // type : see implementation
251    this.length = 0;
252    this.index = 0;
253}
254DataReader.prototype = {
255    /**
256     * Check that the offset will not go too far.
257     * @param {string} offset the additional offset to check.
258     * @throws {Error} an Error if the offset is out of bounds.
259     */
260    checkOffset: function(offset) {
261        this.checkIndex(this.index + offset);
262    },
263    /**
264     * Check that the specifed index will not be too far.
265     * @param {string} newIndex the index to check.
266     * @throws {Error} an Error if the index is out of bounds.
267     */
268    checkIndex: function(newIndex) {
269        if (this.length < newIndex || newIndex < 0) {
270            throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
271        }
272    },
273    /**
274     * Change the index.
275     * @param {number} newIndex The new index.
276     * @throws {Error} if the new index is out of the data.
277     */
278    setIndex: function(newIndex) {
279        this.checkIndex(newIndex);
280        this.index = newIndex;
281    },
282    /**
283     * Skip the next n bytes.
284     * @param {number} n the number of bytes to skip.
285     * @throws {Error} if the new index is out of the data.
286     */
287    skip: function(n) {
288        this.setIndex(this.index + n);
289    },
290    /**
291     * Get the byte at the specified index.
292     * @param {number} i the index to use.
293     * @return {number} a byte.
294     */
295    byteAt: function(i) {
296        // see implementations
297    },
298    /**
299     * Get the next number with a given byte size.
300     * @param {number} size the number of bytes to read.
301     * @return {number} the corresponding number.
302     */
303    readInt: function(size) {
304        var result = 0,
305            i;
306        this.checkOffset(size);
307        for (i = this.index + size - 1; i >= this.index; i--) {
308            result = (result << 8) + this.byteAt(i);
309        }
310        this.index += size;
311        return result;
312    },
313    /**
314     * Get the next string with a given byte size.
315     * @param {number} size the number of bytes to read.
316     * @return {string} the corresponding string.
317     */
318    readString: function(size) {
319        return utils.transformTo("string", this.readData(size));
320    },
321    /**
322     * Get raw data without conversion, <size> bytes.
323     * @param {number} size the number of bytes to read.
324     * @return {Object} the raw data, implementation specific.
325     */
326    readData: function(size) {
327        // see implementations
328    },
329    /**
330     * Find the last occurence of a zip signature (4 bytes).
331     * @param {string} sig the signature to find.
332     * @return {number} the index of the last occurence, -1 if not found.
333     */
334    lastIndexOfSignature: function(sig) {
335        // see implementations
336    },
337    /**
338     * Get the next date.
339     * @return {Date} the date.
340     */
341    readDate: function() {
342        var dostime = this.readInt(4);
343        return new Date(
344        ((dostime >> 25) & 0x7f) + 1980, // year
345        ((dostime >> 21) & 0x0f) - 1, // month
346        (dostime >> 16) & 0x1f, // day
347        (dostime >> 11) & 0x1f, // hour
348        (dostime >> 5) & 0x3f, // minute
349        (dostime & 0x1f) << 1); // second
350    }
351};
352module.exports = DataReader;
353
354},{"./utils":21}],6:[function(_dereq_,module,exports){
355'use strict';
356exports.base64 = false;
357exports.binary = false;
358exports.dir = false;
359exports.createFolders = false;
360exports.date = null;
361exports.compression = null;
362exports.compressionOptions = null;
363exports.comment = null;
364exports.unixPermissions = null;
365exports.dosPermissions = null;
366
367},{}],7:[function(_dereq_,module,exports){
368'use strict';
369var utils = _dereq_('./utils');
370
371/**
372 * @deprecated
373 * This function will be removed in a future version without replacement.
374 */
375exports.string2binary = function(str) {
376    return utils.string2binary(str);
377};
378
379/**
380 * @deprecated
381 * This function will be removed in a future version without replacement.
382 */
383exports.string2Uint8Array = function(str) {
384    return utils.transformTo("uint8array", str);
385};
386
387/**
388 * @deprecated
389 * This function will be removed in a future version without replacement.
390 */
391exports.uint8Array2String = function(array) {
392    return utils.transformTo("string", array);
393};
394
395/**
396 * @deprecated
397 * This function will be removed in a future version without replacement.
398 */
399exports.string2Blob = function(str) {
400    var buffer = utils.transformTo("arraybuffer", str);
401    return utils.arrayBuffer2Blob(buffer);
402};
403
404/**
405 * @deprecated
406 * This function will be removed in a future version without replacement.
407 */
408exports.arrayBuffer2Blob = function(buffer) {
409    return utils.arrayBuffer2Blob(buffer);
410};
411
412/**
413 * @deprecated
414 * This function will be removed in a future version without replacement.
415 */
416exports.transformTo = function(outputType, input) {
417    return utils.transformTo(outputType, input);
418};
419
420/**
421 * @deprecated
422 * This function will be removed in a future version without replacement.
423 */
424exports.getTypeOf = function(input) {
425    return utils.getTypeOf(input);
426};
427
428/**
429 * @deprecated
430 * This function will be removed in a future version without replacement.
431 */
432exports.checkSupport = function(type) {
433    return utils.checkSupport(type);
434};
435
436/**
437 * @deprecated
438 * This value will be removed in a future version without replacement.
439 */
440exports.MAX_VALUE_16BITS = utils.MAX_VALUE_16BITS;
441
442/**
443 * @deprecated
444 * This value will be removed in a future version without replacement.
445 */
446exports.MAX_VALUE_32BITS = utils.MAX_VALUE_32BITS;
447
448
449/**
450 * @deprecated
451 * This function will be removed in a future version without replacement.
452 */
453exports.pretty = function(str) {
454    return utils.pretty(str);
455};
456
457/**
458 * @deprecated
459 * This function will be removed in a future version without replacement.
460 */
461exports.findCompression = function(compressionMethod) {
462    return utils.findCompression(compressionMethod);
463};
464
465/**
466 * @deprecated
467 * This function will be removed in a future version without replacement.
468 */
469exports.isRegExp = function (object) {
470    return utils.isRegExp(object);
471};
472
473
474},{"./utils":21}],8:[function(_dereq_,module,exports){
475'use strict';
476var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
477
478var pako = _dereq_("pako");
479exports.uncompressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
480exports.compressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
481
482exports.magic = "\x08\x00";
483exports.compress = function(input, compressionOptions) {
484    return pako.deflateRaw(input, {
485        level : compressionOptions.level || -1 // default compression
486    });
487};
488exports.uncompress =  function(input) {
489    return pako.inflateRaw(input);
490};
491
492},{"pako":24}],9:[function(_dereq_,module,exports){
493'use strict';
494
495var base64 = _dereq_('./base64');
496
497/**
498Usage:
499   zip = new JSZip();
500   zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing");
501   zip.folder("images").file("smile.gif", base64Data, {base64: true});
502   zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")});
503   zip.remove("tempfile");
504
505   base64zip = zip.generate();
506
507**/
508
509/**
510 * Representation a of zip file in js
511 * @constructor
512 * @param {String=|ArrayBuffer=|Uint8Array=} data the data to load, if any (optional).
513 * @param {Object=} options the options for creating this objects (optional).
514 */
515function JSZip(data, options) {
516    // if this constructor is used without `new`, it adds `new` before itself:
517    if(!(this instanceof JSZip)) return new JSZip(data, options);
518

519    // object containing the files :
520    // {
521    //   "folder/" : {...},
522    //   "folder/data.txt" : {...}
523    // }
524    this.files = {};
525
526    this.comment = null;
527
528    // Where we are in the hierarchy
529    this.root = "";
530    if (data) {
531        this.load(data, options);
532    }
533    this.clone = function() {
534        var newObj = new JSZip();
535        for (var i in this) {
536            if (typeof this[i] !== "function") {
537                newObj[i] = this[i];
538            }
539        }
540        return newObj;
541    };
542}
543JSZip.prototype = _dereq_('./object');
544JSZip.prototype.load = _dereq_('./load');
545JSZip.support = _dereq_('./support');
546JSZip.defaults = _dereq_('./defaults');
547
548/**
549 * @deprecated
550 * This namespace will be removed in a future version without replacement.
551 */
552JSZip.utils = _dereq_('./deprecatedPublicUtils');
553
554JSZip.base64 = {
555    /**
556     * @deprecated
557     * This method will be removed in a future version without replacement.
558     */
559    encode : function(input) {
560        return base64.encode(input);
561    },
562    /**
563     * @deprecated
564     * This method will be removed in a future version without replacement.
565     */
566    decode : function(input) {
567        return base64.decode(input);
568    }
569};
570JSZip.compressions = _dereq_('./compressions');
571module.exports = JSZip;
572
573},{"./base64":1,"./compressions":3,"./defaults":6,"./deprecatedPublicUtils":7,"./load":10,"./object":13,"./support":17}],10:[function(_dereq_,module,exports){
574'use strict';
575var base64 = _dereq_('./base64');
576var ZipEntries = _dereq_('./zipEntries');
577module.exports = function(data, options) {
578    var files, zipEntries, i, input;
579    options = options || {};
580    if (options.base64) {
581        data = base64.decode(data);
582    }
583
584    zipEntries = new ZipEntries(data, options);
585    files = zipEntries.files;
586    for (i = 0; i < files.length; i++) {
587        input = files[i];
588        this.file(input.fileName, input.decompressed, {
589            binary: true,
590            optimizedBinaryString: true,
591            date: input.date,
592            dir: input.dir,
593            comment : input.fileComment.length ? input.fileComment : null,
594            unixPermissions : input.unixPermissions,
595            dosPermissions : input.dosPermissions,
596            createFolders: options.createFolders
597        });
598    }
599    if (zipEntries.zipComment.length) {
600        this.comment = zipEntries.zipComment;
601    }
602
603    return this;
604};
605
606},{"./base64":1,"./zipEntries":22}],11:[function(_dereq_,module,exports){
607(function (Buffer){
608'use strict';
609module.exports = function(data, encoding){
610    return new Buffer(data, encoding);
611};
612module.exports.test = function(b){
613    return Buffer.isBuffer(b);
614};
615
616}).call(this,(typeof Buffer !== "undefined" ? Buffer : undefined))
617},{}],12:[function(_dereq_,module,exports){
618'use strict';
619var Uint8ArrayReader = _dereq_('./uint8ArrayReader');
620
621function NodeBufferReader(data) {
622    this.data = data;
623    this.length = this.data.length;
624    this.index = 0;
625}
626NodeBufferReader.prototype = new Uint8ArrayReader();
627
628/**
629 * @see DataReader.readData
630 */
631NodeBufferReader.prototype.readData = function(size) {
632    this.checkOffset(size);
633    var result = this.data.slice(this.index, this.index + size);
634    this.index += size;
635    return result;
636};
637module.exports = NodeBufferReader;
638
639},{"./uint8ArrayReader":18}],13

639:[function(_dereq_,module,exports){
640'use strict';
641var support = _dereq_('./support');
642var utils = _dereq_('./utils');
643var crc32 = _dereq_('./crc32');
644var signature = _dereq_('./signature');
645var defaults = _dereq_('./defaults');
646var base64 = _dereq_('./base64');
647var compressions = _dereq_('./compressions');
648var CompressedObject = _dereq_('./compressedObject');
649var nodeBuffer = _dereq_('./nodeBuffer');
650var utf8 = _dereq_('./utf8');
651var StringWriter = _dereq_('./stringWriter');
652var Uint8ArrayWriter = _dereq_('./uint8ArrayWriter');
653
654/**
655 * Returns the raw data of a ZipObject, decompress the content if necessary.
656 * @param {ZipObject} file the file to use.
657 * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
658 */
659var getRawData = function(file) {
660    if (file._data instanceof CompressedObject) {
661        file._data = file._data.getContent();
662        file.options.binary = true;
663        file.options.base64 = false;
664
665        if (utils.getTypeOf(file._data) === "uint8array") {
666            var copy = file._data;
667            // when reading an arraybuffer, the CompressedObject mechanism will keep it and subarray() a Uint8Array.
668            // if we request a file in the same format, we might get the same Uint8Array or its ArrayBuffer (the original zip file).
669            file._data = new Uint8Array(copy.length);
670            // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
671            if (copy.length !== 0) {
672                file._data.set(copy, 0);
673            }
674        }
675    }
676    return file._data;
677};
678
679/**
680 * Returns the data of a ZipObject in a binary form. If the content is an unicode string, encode it.
681 * @param {ZipObject} file the file to use.
682 * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
683 */
684var getBinaryData = function(file) {
685    var result = getRawData(file),
686        type = utils.getTypeOf(result);
687    if (type === "string") {
688        if (!file.options.binary) {
689            // unicode text !
690            // unicode string => binary string is a painful process, check if we can avoid it.
691            if (support.nodebuffer) {
692                return nodeBuffer(result, "utf-8");
693            }
694        }
695        return file.asBinary();
696    }
697    return result;
698};
699
700/**
701 * Transform this._data into a string.
702 * @param {function} filter a function String -> String, applied if not null on the result.
703 * @return {String} the string representing this._data.
704 */
705var dataToString = function(asUTF8) {
706    var result = getRawData(this);
707    if (result === null || typeof result === "undefined") {
708        return "";
709    }
710    // if the data is a base64 string, we decode it before checking the encoding !
711    if (this.options.base64) {
712        result = base64.decode(result);
713    }
714    if (asUTF8 && this.options.binary) {
715        // JSZip.prototype.utf8decode supports arrays as input
716        // skip to array => string step, utf8decode will do it.
717        result = out.utf8decode(result);
718    }
719    else {
720        // no utf8 transformation, do the array => string step.
721        result = utils.transformTo("string", result);
722    }
723
724    if (!asUTF8 && !this.options.binary) {
725        result = utils.transformTo("string", out.utf8encode(result));
726    }
727    return result;
728};
729/**
730 * A simple object representing a file in the zip file.
731 * @constructor
732 * @param {string} name the name of the file
733 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data
734 * @param {Object} options the options of the file
735 */
736var ZipObject = function(name, data, options) {
737    this.name = name;
738    this.dir = options.dir;
739    this.date = options.date;
740    this.comment = options.comment;
741    this.unixPermissions = options.unixPermissions;
742    this.dosPermissions = options.dosPermissions;
743
744    this._data = data;
745    this.options = options;
746
747    /*
748     * This object contains initial values for dir and date.
749     * With them, we can check if the user changed the deprecated metadata in
750     * `ZipObject#options` or not.
751     */
752    this._initialMetadata = {
753      dir : options.dir,
754      date : options.date
755    };
756};
757
758ZipObject.prototype = {
759    /**
760     * Return the content as UTF8 string.
761     * @return {string} the UTF8 string.
762     */
763    asText: function() {
764        return dataToString.call(this, true);
765    },
766    /**
767     * Returns the binary content.
768     * @return {string} the content as binary.
769     */
770    asBinary: function() {
771        return dataToString.call(this, false);
772    },
773    /**
774     * Returns the content as a nodejs Buffer.
775     * @return {Buffer} the content as a Buffer.
776     */
777    asNodeBuffer: function() {
778        var result = getBinaryData(this);
779        return utils.transformTo("nodebuffer", result);
780    },
781    /**
782     * Returns the content as an Uint8Array.
783     * @return {Uint8Array} the content as an Uint8Array.
784     */
785    asUint8Array: function() {
786        var result = getBinaryData(this);
787        return utils.transformTo("uint8array", result);
788    },
789    /**
790     * Returns the content as an ArrayBuffer.
791     * @return {ArrayBuffer} the content as an ArrayBufer.
792     */
793    asArrayBuffer: function() {
794        return this.asUint8Array().buffer;
795    }
796};
797
798/**
799 * Transform an integer into a string in hexadecimal.
800 * @private
801 * @param {number} dec the number to convert.
802 * @param {number} bytes the number of bytes to generate.
803 * @returns {string} the result.
804 */
805var decToHex = function(dec, bytes) {
806    var hex = "",
807        i;
808    for (i = 0; i < bytes; i++) {
809        hex += String.fromCharCode(dec & 0xff);
810        dec = dec >>> 8;
811    }
812    return hex;
813};
814
815/**
816 * 

816Merge the objects passed as parameters into a new one.
817 * @private
818 * @param {...Object} var_args All objects to merge.
819 * @return {Object} a new object with the data of the others.
820 */
821var extend = function() {
822    var result = {}, i, attr;
823    for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
824        for (attr in arguments[i]) {
825            if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
826                result[attr] = arguments[i][attr];
827            }
828        }
829    }
830    return result;
831};
832
833/**
834 * Transforms the (incomplete) options from the user into the complete
835 * set of options to create a file.
836 * @private
837 * @param {Object} o the options from the user.
838 * @return {Object} the complete set of options.
839 */
840var prepareFileAttrs = function(o) {
841    o = o || {};
842    if (o.base64 === true && (o.binary === null || o.binary === undefined)) {
843        o.binary = true;
844    }
845    o = extend(o, defaults);
846    o.date = o.date || new Date();
847    if (o.compression !== null) o.compression = o.compression.toUpperCase();
848
849    return o;
850};
851
852/**
853 * Add a file in the current folder.
854 * @private
855 * @param {string} name the name of the file
856 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file
857 * @param {Object} o the options of the file
858 * @return {Object} the new file.
859 */
860var fileAdd = function(name, data, o) {
861    // be sure sub folders exist
862    var dataType = utils.getTypeOf(data),
863        parent;
864
865    o = prepareFileAttrs(o);
866
867    if (typeof o.unixPermissions === "string") {
868        o.unixPermissions = parseInt(o.unixPermissions, 8);
869    }
870
871    // UNX_IFDIR  0040000 see zipinfo.c
872    if (o.unixPermissions && (o.unixPermissions & 0x4000)) {
873        o.dir = true;
874    }
875    // Bit 4    Directory
876    if (o.dosPermissions && (o.dosPermissions & 0x0010)) {
877        o.dir = true;
878    }
879
880    if (o.dir) {
881        name = forceTrailingSlash(name);
882    }
883
884    if (o.createFolders && (parent = parentFolder(name))) {
885        folderAdd.call(this, parent, true);
886    }
887
888    if (o.dir || data === null || typeof data === "undefined") {
889        o.base64 = false;
890        o.binary = false;
891        data = null;
892        dataType = null;
893    }
894    else if (dataType === "string") {
895        if (o.binary && !o.base64) {
896            // optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask
897            if (o.optimizedBinaryString !== true) {
898                // this is a string, not in a base64 format.
899                // Be sure that this is a correct "binary string"
900                data = utils.string2binary(data);
901            }
902        }
903    }
904    else { // arraybuffer, uint8array, ...
905        o.base64 = false;
906        o.binary = true;
907
908        if (!dataType && !(data instanceof CompressedObject)) {
909            throw new Error("The data of '" + name + "' is in an unsupported format !");
910        }
911
912        // special case : it's way easier to work with Uint8Array than with ArrayBuffer
913        if (dataType === "arraybuffer") {
914            data = utils.transformTo("uint8array", data);
915        }
916    }
917
918    var object = new ZipObject(name, data, o);
919    this.files[name] = object;
920    return object;
921};
922
923/**
924 * Find the parent folder of the path.
925 * @private
926 * @param {string} path the path to use
927 * @return {string} the parent folder, or ""
928 */
929var parentFolder = function (path) {
930    if (path.slice(-1) == '/') {
931        path = path.substring(0, path.length - 1);
932    }
933    var lastSlash = path.lastIndexOf('/');
934    return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
935};
936
937
938/**
939 * Returns the path with a slash at the end.
940 * @private
941 * @param {String} path the path to check.
942 * @return {String} the path with a trailing slash.
943 */
944var forceTrailingSlash = function(path) {
945    // Check the name ends with a /
946    if (path.slice(-1) != "/") {
947        path += "/"; // IE doesn't like substr(-1)
948    }
949    return path;
950};
951/**
952 * Add a (sub) folder in the current folder.
953 * @private
954 * @param {string} name the folder's name
955 * @param {boolean=} [createFolders] If true, automatically create sub
956 *  folders. Defaults to false.
957 * @return {Object} the new folder.
958 */
959var folderAdd = function(name, createFolders) {
960    createFolders = (typeof createFolders !== 'undefined') ? createFolders : false;
961
962    name = forceTrailingSlash(name);
963
964    // Does this folder already exist?
965    if (!this.files[name]) {
966        fileAdd.call(this, name, null, {
967            dir: true,
968            createFolders: createFolders
969        });
970    }
971    return this.files[name];
972};
973
974/**
975 * Generate a JSZip.CompressedObject for a given zipOject.
976 * @param {ZipObject} file the object to read.
977 * @param {JSZip.compression} compression the compression to use.
978 * @param {Object} compressionOptions the options to use when compressing.
979 * @return {JSZip.CompressedObject} the compressed result.
980 */
981var generateCompressedObjectFrom = function(file, compression, compressionOptions) {
982    var result = new CompressedObject(),
983        content;
984
985    // the data has not been decompressed, we might reuse things !
986    if (file._data instanceof CompressedObject) {
987        result.uncompressedSize = file._data.uncompressedSize;
988        result.crc32 = file._data.crc32;
989
990        if (result.uncompressedSize === 0 || file.dir) {
991            compression = compressions['STORE'];
992            result.compressedContent = "";
993            result.crc32 = 0;
994        }
995        else if (file._data.compressionMethod === compression.magic) {
996            result.compressedContent = file._data.getCompressedContent();
997        }
998        else {
999            content = file._data.getContent();
1000            // need to decompress / recompress
1001            result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content), compressionOptions);
1002        }
1003    }
1004    else {
1005        // have uncompressed data
1006        content = getBinaryData(file);
1007        if (!content || content.length === 0 || file.dir) {
1008            compression = compressions['STORE'];
1009            content = "";
1010        }
1011        result.uncompressedSize = content.length;
1012        result.crc32 = crc32(content);
1013        result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content), compressionOptions);
1014    }
1015
1016    result.compressedSize = result.compressedContent.length;
1017    result.compressionMethod = compression.magic;
1018
1019    return result;
1020};
1021
1022
1023
1024
1025/**
1026 * Generate the UNIX part of the external file attributes.
1027 * @param {Object} unixPermissions the unix permissions or null.
1028 * @param {Boolean} isDir true if the entry is a directory, false otherwise.
1029 * @return {Number} a 32 bit integer.
1030 *
1031 * adapted from http://unix.stackexchange.com/questions/14705/the-zip-formats-external-file-attribute :
1032 *
1033 * TTTTsstrwxrwxrwx0000000000ADVSHR
1034 * ^^^^____________________________ file type, see zipinfo.c (UNX_*)
1035 *     ^^^_________________________ setuid, setgid, sticky
1036 *        ^^^^^^^^^________________ permissions
1037 *                 ^^^^^^^^^^______ not used ?
1038 *                           ^^^^^^ DOS attribute bits : Archive, Directory, Volume label, System file, Hidden, Read only
1039 */
1040var generateUnixExternalFileAttr = function (unixPermissions, isDir) {
1041
1042    var result = unixPermissions;
1043    if (!unixPermissions) {
1044        // I can't use octal values in strict mode, hence the hexa.
1045        //  040775 => 0x41fd
1046        // 0100664 => 0x81b4
1047        result = isDir ? 0x41fd : 0x81b4;
1048    }
1049
1050    return (result & 0xFFFF) << 16;
1051};
1052
1053/**
1054 * Generate the DOS part of the external file attributes.
1055 * @param {Object} dosPermissions the dos permissions or null.
1056 * @param {Boolean} isDir true if the entry is a directory, false otherwise.
1057 * @return {Number} a 32 bit integer.
1058 *
1059 * Bit 0     Read-Only
1060 * Bit 1     Hidden
1061 * Bit 2     System
1062 * Bit 3     Volume Label
1063 * Bit 4     Directory
1064 * Bit 5     Archive
1065 */
1066var generateDosExternalFileAttr = function (dosPermissions, isDir) {
1067
1068    // the dir flag is already set for compatibility
1069
1070    return (dosPermissions || 0)  & 0x3F;
1071};
1072
1073/**
1074 * Generate the various parts used in the construction of the final zip file.
1075 * @param {string} name the file name.
1076 * @param {ZipObject} file the file content.
1077 * @param {JSZip.CompressedObject} compressedObject the compressed object.
1078 * @param {number} offset the current offset from the start of the zip file.
1079 * @param {String} platform let's pretend we are this platform (change platform dependents fields)
1080 * @return {object} the zip parts.
1081 */
1082var generateZipParts = function(name, file, compressedObject, offset, platform) {
1083    var data = compressedObject.compressedContent,
1084        utfEncodedFileName = utils.transformTo("string", utf8.utf8encode(file.name)),
1085        comment = file.comment || "",
1086        utfEncodedComment = utils.transformTo("string", utf8.utf8encode(comment)),
1087        useUTF8ForFileName = utfEncodedFileName.length !== file.name.length,
1088        useUTF8ForComment = utfEncodedComment.length !== comment.length,
1089        o = file.options,
1090        dosTime,
1091        dosDate,
1092        extraFields = "",
1093        unicodePathExtraField = "",
1094        unicodeCommentExtraField = "",
1095        dir, date;
1096
1097
1098    // handle the deprecated options.dir
1099    if (file._initialMetadata.dir !== file.dir) {
1100        dir = file.dir;
1101    } else {
1102        dir = o.dir;
1103    }
1104
1105    // handle the deprecated options.date
1106    if(file._initialMetadata.date !== file.date) {
1107        date = file.date;
1108    } else {
1109        date = o.date;
1110    }
1111
1112    var extFileAttr = 0;
1113    var versionMadeBy = 0;
1114    if (dir) {
1115        // dos or unix, we set the dos dir flag
1116        extFileAttr |= 0x00010;
1117    }
1118    if(platform === "UNIX") {
1119        versionMadeBy = 0x031E; // UNIX, version 3.0
1120        extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir);
1121    } else { // DOS or other, fallback to DOS
1122        versionMadeBy = 0x0014; // DOS, version 2.0
1123        extFileAttr |= generateDosExternalFileAttr(file.dosPermissions, dir);
1124    }
1125
1126    // date
1127    // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html
1128    // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html
1129    // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html
1130
1131    dosTime = date.getHours();
1132    dosTime = dosTime << 6;
1133    dosTime = dosTime | date.getMinutes();
1134    dosTime = dosTime << 5;
1135    dosTime = dosTime | date.getSeconds() / 2;
1136
1137    dosDate = date.getFullYear() - 1980;
1138    dosDate = dosDate << 4;
1139    dosDate = dosDate | (date.getMonth() + 1);
1140    dosDate = dosDate << 5;
1141    dosDate = dosDate | date.getDate();
1142
1143    if (useUTF8ForFileName) {
1144        // set the unicode path extra field. unzip needs at least one extra
1145        // field to correctly handle unicode path, so using the path is as good
1146        // as any other information. This could improve the situation with
1147        // other archive managers too.
1148        // This field is usually used without the utf8 flag, with a non
1149        // unicode path in the header (winrar, winzip). This helps (a bit)
1150        // with the messy Windows' default compressed folders feature but
1151        // breaks on p7zip which doesn't seek the unicode path extra field.
1152        // So for now, UTF-8 everywhere !
1153        unicodePathExtraField =
1154            // Version
1155            decToHex(1, 1) +
1156            // NameCRC32
1157            decToHex(crc32(utfEncodedFileName), 4) +
1158            // UnicodeName
1159            utfEncodedFileName;
1160
1161        extraFields +=
1162            // Info-ZIP Unicode Path Extra Field
1163            "\x75\x70" +
1164            // size
1165            decToHex(unicodePathExtraField.length, 2) +
1166            // content
1167            unicodePathExtraField;
1168    }
1169
1170    if(useUTF8ForComment) {
1171
1172        unicodeCommentExtraField =
1173            // Version
1174            decToHex(1, 1) +
1175            // CommentCRC32
1176            decToHex(this.crc32(utfEncodedComment), 4) +
1177            // UnicodeName
1178            utfEncodedComment;
1179
1180        extraFields +=
1181            // Info-ZIP Unicode Path Extra Field
1182            "\x75\x63" +
1183            // size
1184            decToHex(unicodeCommentExtraField.length, 2) +
1185            // content
1186            unicodeCommentExtraField;
1187    }
1188
1189    var header = "";
1190
1191    // version needed to extract
1192    header += "\x0A\x00";
1193    // general purpose bit flag
1194    // set bit 11 if utf8
1195    header += (useUTF8ForFileName || useUTF8ForComment) ? "\x00\x08" : "\x00\x00";
1196    // compression method
1197    header += compressedObject.compressionMethod;
1198    // last mod file time
1199    header += decToHex(dosTime, 2);
1200    // last mod file date
1201    header += decToHex(dosDate, 2);
1202    // crc-32
1203    header += decToHex(compressedObject.crc32, 4);
1204    // compressed size
1205    header += decToHex(compressedObject.compressedSize, 4);
1206    // uncompressed size
1207    header += decToHex(compressedObject.uncompressedSize, 4);
1208    // file name length
1209    header += decToHex(utfEncodedFileName.length, 2);
1210    // extra field length
1211    header += decToHex(extraFields.length, 2);
1212
1213
1214    var fileRecord = signature.LOCAL_FILE_HEADER + header + utfEncodedFileName + extraFields;
1215
1216    var dirRecord = signature.CENTRAL_FILE_HEADER +
1217    // version made by (00: DOS)
1218    decToHex(versionMadeBy, 2) +
1219    // file header (common to file and central directory)
1220    header +
1221    // file comment length
1222    decToHex(utfEncodedComment.length, 2) +
1223    // disk number start
1224    "\x00\x00" +
1225    // internal file attributes TODO
1226    "\x00\x00" +
1227    // external file attributes
1228    decToHex(extFileAttr, 4) +
1229    // relative offset of local header
1230    decToHex(offset, 4) +
1231    // file name
1232    utfEncodedFileName +
1233    // extra field
1234    extraFields +
1235    // file comment
1236    utfEncodedComment;
1237
1238    return {
1239        fileRecord: fileRecord,
1240        dirRecord: dirRecord,
1241        compressedObject: compressedObject
1242    };
1243};
1244
1245
1246// return the actual prototype of JSZip
1247var out = {
1248    /**
1249     * Read an existing zip and merge the data in the current JSZip object.
1250     * The implementation is in jszip-load.js, don't forget to include it.
1251     * @param {String|ArrayBuffer|Uint8Array|Buffer} stream  The stream to load
1252     * @param {Object} options Options for loading the stream.
1253     *  options.base64 : is the stream in base64 ? default : false
1254     * @return {JSZip} the current JSZip object
1255     */
1256    load: function(stream, options) {
1257        throw new Error("Load method is not defined. Is the file jszip-load.js included ?");
1258    },
1259
1260    /**
1261     * Filter nested files/folders with the specified function.
1262     * @param {Function} search the predicate to use :
1263     * function (relativePath, file) {...}
1264     * It takes 2 arguments : the relative path and the file.
1265     * @return {Array} An array of matching elements.
1266     */
1267    filter: function(search) {
1268        var result = [],
1269            filename, relativePath, file, fileClone;
1270        for (filename in this.files) {
1271            if (!this.files.hasOwnProperty(filename)) {
1272                continue;
1273            }
1274            file = this.files[filename];
1275            // return a new object, don't let the user mess with our internal objects :)
1276            fileClone = new ZipObject(file.name, file._data, extend(file.options));
1277            relativePath = filename.slice(this.root.length, filename.length);
1278            if (filename.slice(0, this.root.length) === this.root && // the file is in the current root
1279            search(relativePath, fileClone)) { // and the file matches the function
1280                result.push(fileClone);
1281            }
1282        }
1283        return result;
1284    },
1285
1286    /**
1287     * Add a file to the zip file, or search a file.
1288     * @param   {string|RegExp} name The name of the file to add (if data is defined),
1289     * the name of the file to find (if no data) or a regex to match files.
1290     * @param   {String|ArrayBuffer|Uint8Array|Buffer} data  The file data, either raw or base64 encoded
1291     * @param   {Object} o     File options
1292     * @return  {JSZip|Object|Array} this JSZip object (when adding a file),
1293     * a file (when searching by string) or an array of files (when searching by regex).
1294     */
1295    file: function(name, data, o) {
1296        if (arguments.length === 1) {
1297            if (utils.isRegExp(name)) {
1298                var regexp = name;
1299                return this.filter(function(relativePath, file) {
1300                    return !file.dir && regexp.test(relativePath);
1301                });
1302            }
1303            else { // text
1304                return this.filter(function(relativePath, file) {
1305                    return !file.dir && relativePath === name;
1306                })[0] || null;
1307            }
1308        }
1309        else { // more than one argument : we have data !
1310            name = this.root + name;
1311            fileAdd.call(this, name, data, o);
1312        }
1313        return this;
1314    },
1315
1316    /**
1317     * Add a directory to the zip file, or search.
1318     * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
1319     * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
1320     */
1321    folder: function(arg) {
1322        if (!arg) {
1323            return this;
1324        }
1325
1326        if (utils.isRegExp(arg)) {
1327            return this.filter(function(relativePath, file) {
1328                return file.dir && arg.test(relativePath);
1329            });
1330        }
1331
1332        // else, name is a new folder
1333        var name = this.root + arg;
1334        var newFolder = folderAdd.call(this, name);
1335
1336        // Allow chaining by returning a new object with this folder as the root
1337        var ret = this.clone();
1338        ret.root = newFolder.name;
1339        return ret;
1340    },
1341
1342    /**
1343     * Delete a file, or a directory and all sub-files, from the zip
1344     * @param {string} name the name of the file to delete
1345     * @return {JSZip} this JSZip object
1346     */
1347    remove: function(name) {
1348        name = this.root + name;
1349        var file = this.files[name];
1350        if (!file) {
1351            // Look for any folders
1352            if (name.slice(-1) != "/") {
1353                name += "/";
1354            }
1355            file = this.files[name];
1356        }
1357
1358        if (file && !file.dir) {
1359            // file
1360            delete this.files[name];
1361        } else {
1362            // maybe a folder, delete recursively
1363            var kids = this.filter(function(relativePath, file) {
1364                return file.name.slice(0, name.length) === name;
1365            });
1366            for (var i = 0; i < kids.length; i++) {
1367                delete this.files[kids[i].name];
1368            }
1369        }
1370
1371        return this;
1372    },
1373
1374    /**
1375     * Generate the complete zip file
1376     * @param {Object} options the options to generate the zip file :
1377     * - base64, (deprecated, use type instead) true to generate base64.
1378     * - compression, "STORE" by default.
1379     * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
1380     * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
1381     */
1382    generate: function(options) {
1383        options = extend(options || {}, {
1384            base64: true,
1385            compression: "STORE",
1386            compressionOptions : null,
1387            type: "base64",
1388            platform: "DOS",
1389            comment: null,
1390            mimeType: 'application/zip'
1391        });
1392
1393        utils.checkSupport(options.type);
1394
1395        // accept nodejs `process.platform`
1396        if(
1397          options.platform === 'darwin' ||
1398          options.platform === 'freebsd' ||
1399          options.platform === 'linux' ||
1400          options.platform === 'sunos'
1401        ) {
1402          options.platform = "UNIX";
1403        }
1404        if (options.platform === 'win32') {
1405          options.platform = "DOS";
1406        }
1407
1408        var zipData = [],
1409            localDirLength = 0,
1410            centralDirLength = 0,
1411            writer, i,
1412            utfEncodedComment = utils.transformTo("string", this.utf8encode(options.comment || this.comment || ""));
1413
1414        // first, generate all the zip parts.
1415        for (var name in this.files) {
1416            if (!this.files.hasOwnProperty(name)) {
1417                continue;
1418            }
1419            var file = this.files[name];
1420
1421            var compressionName = file.options.compression || options.compression.toUpperCase();
1422            var compression = compressions[compressionName];
1423            if (!compression) {
1424                throw new Error(compressionName + " is not a valid compression method !");
1425            }
1426            var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
1427
1428            var compressedObject = generateCompressedObjectFrom.call(this, file, compression, compressionOptions);
1429
1430            var zipPart = generateZipParts.call(this, name, file, compressedObject, localDirLength, options.platform);
1431            localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize;
1432            centralDirLength += zipPart.dirRecord.length;
1433            zipData.push(zipPart);
1434        }
1435
1436        var dirEnd = "";
1437
1438        // end of central dir signature
1439        dirEnd = signature.CENTRAL_DIRECTORY_END +
1440        // number of this disk
1441        "\x00\x00" +
1442        // number of the disk with the start of the central directory
1443        "\x00\x00" +
1444        // total number of entries in the central directory on this disk
1445        decToHex(zipData.length, 2) +
1446        // total number of entries in the central directory
1447        decToHex(zipData.length, 2) +
1448        // size of the central directory   4 bytes
1449        decToHex(centralDirLength, 4) +
1450        // offset of start of central directory with respect to the starting disk number
1451        decToHex(localDirLength, 4) +
1452        // .ZIP file comment length
1453        decToHex(utfEncodedComment.length, 2) +
1454        // .ZIP file comment
1455        utfEncodedComment;
1456
1457
1458        // we have all the parts (and the total length)
1459        // time to create a writer !
1460        var typeName = options.type.toLowerCase();
1461        if(typeName==="uint8array"||typeName==="arraybuffer"||typeName==="blob"||typeName==="nodebuffer") {
1462            writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length);
1463        }else{
1464            writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length);
1465        }
1466
1467        for (i = 0; i < zipData.length; i++) {
1468            writer.append(zipData[i].fileRecord);
1469            writer.append(zipData[i].compressedObject.compressedContent);
1470        }
1471        for (i = 0; i < zipData.length; i++) {
1472            writer.append(zipData[i].dirRecord);
1473        }
1474
1475        writer.append(dirEnd);
1476
1477        var zip = writer.finalize();
1478
1479
1480
1481        switch(options.type.toLowerCase()) {
1482            // case "zip is an Uint8Array"
1483            case "uint8array" :
1484            case "arraybuffer" :
1485            case "nodebuffer" :
1486               return utils.transformTo(options.type.toLowerCase(), zip);
1487            case "blob" :
1488               return utils.arrayBuffer2Blob(utils.transformTo("arraybuffer", zip), options.mimeType

1488);
1489            // case "zip is a string"
1490            case "base64" :
1491               return (options.base64) ? base64.encode(zip) : zip;
1492            default : // case "string" :
1493               return zip;
1494         }
1495
1496    },
1497
1498    /**
1499     * @deprecated
1500     * This method will be removed in a future version without replacement.
1501     */
1502    crc32: function (input, crc) {
1503        return crc32(input, crc);
1504    },
1505
1506    /**
1507     * @deprecated
1508     * This method will be removed in a future version without replacement.
1509     */
1510    utf8encode: function (string) {
1511        return utils.transformTo("string", utf8.utf8encode(string));
1512    },
1513
1514    /**
1515     * @deprecated
1516     * This method will be removed in a future version without replacement.
1517     */
1518    utf8decode: function (input) {
1519        return utf8.utf8decode(input);
1520    }
1521};
1522module.exports = out;
1523
1524},{"./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){
1525'use strict';
1526exports.LOCAL_FILE_HEADER = "PK\x03\x04";
1527exports.CENTRAL_FILE_HEADER = "PK\x01\x02";
1528exports.CENTRAL_DIRECTORY_END = "PK\x05\x06";
1529exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
1530exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
1531exports.DATA_DESCRIPTOR = "PK\x07\x08";
1532
1533},{}],15:[function(_dereq_,module,exports){
1534'use strict';
1535var DataReader = _dereq_('./dataReader');
1536var utils = _dereq_('./utils');
1537
1538function StringReader(data, optimizedBinaryString) {
1539    this.data = data;
1540    if (!optimizedBinaryString) {
1541        this.data = utils.string2binary(this.data);
1542    }
1543    this.length = this.data.length;
1544    this.index = 0;
1545}
1546StringReader.prototype = new DataReader();
1547/**
1548 * @see DataReader.byteAt
1549 */
1550StringReader.prototype.byteAt = function(i) {
1551    return this.data.charCodeAt(i);
1552};
1553/**
1554 * @see DataReader.lastIndexOfSignature
1555 */
1556StringReader.prototype.lastIndexOfSignature = function(sig) {
1557    return this.data.lastIndexOf(sig);
1558};
1559/**
1560 * @see DataReader.readData
1561 */
1562StringReader.prototype.readData = function(size) {
1563    this.checkOffset(size);
1564    // this will work because the constructor applied the "& 0xff" mask.
1565    var result = this.data.slice(this.index, this.index + size);
1566    this.index += size;
1567    return result;
1568};
1569module.exports = StringReader;
1570
1571},{"./dataReader":5,"./utils":21}],16:[function(_dereq_,module,exports){
1572'use strict';
1573
1574var utils = _dereq_('./utils');
1575
1576/**
1577 * An object to write any content to a string.
1578 * @constructor
1579 */
1580var StringWriter = function() {
1581    this.data = [];
1582};
1583StringWriter.prototype = {
1584    /**
1585     * Append any content to the current string.
1586     * @param {Object} input the content to add.
1587     */
1588    append: function(input) {
1589        input = utils.transformTo("string", input);
1590        this.data.push(input);
1591    },
1592    /**
1593     * Finalize the construction an return the result.
1594     * @return {string} the generated string.
1595     */
1596    finalize: function() {
1597        return this.data.join("");
1598    }
1599};
1600
1601module.exports = StringWriter;
1602
1603},{"./utils":21}],17:[function(_dereq_,module,exports){
1604(function (Buffer){
1605'use strict';
1606exports.base64 = true;
1607exports.array = true;
1608exports.string = true;
1609exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
1610// contains true if JSZip can read/generate nodejs Buffer, false otherwise.
1611// Browserify will provide a Buffer implementation for browsers, which is
1612// an augmented Uint8Array (i.e., can be used as either Buffer or U8).
1613exports.nodebuffer = typeof Buffer !== "undefined";
1614// contains true if JSZip can read/generate Uint8Array, false otherwise.
1615exports.uint8array = typeof Uint8Array !== "undefined";
1616
1617if (typeof ArrayBuffer === "undefined") {
1618    exports.blob = false;
1619}
1620else {
1621    var buffer = new ArrayBuffer(0);
1622    try {
1623        exports.blob = new Blob([buffer], {
1624            type: "application/zip"
1625        }).size === 0;
1626    }
1627    catch (e) {
1628        try {
1629            var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
1630            var builder = new Builder();
1631            builder.append(buffer);
1632            exports.blob = builder.getBlob('application/zip').size === 0;
1633        }
1634        catch (e) {
1635            exports.blob = false;
1636        }
1637    }
1638}
1639
1640}).call(this,(typeof Buffer !== "undefined" ? Buffer : undefined))
1641},{}],18:[function(_dereq_,module,exports){
1642'use strict';
1643var DataReader = _dereq_('./dataReader');
1644
1645function Uint8ArrayReader(data) {
1646    if (data) {
1647        this.data = data;
1648        this.length = this.data.length;
1649        this.index = 0;
1650    }
1651}
1652Uint8ArrayReader.prototype = new DataReader();
1653/**
1654 * @see DataReader.byteAt
1655 */
1656Uint8ArrayReader.prototype.byteAt = function(i) {
1657    return this.data[i];
1658};
1659/**
1660 * @see DataReader.lastIndexOfSignature
1661 */
1662Uint8ArrayReader.prototype.lastIndexOfSignature = function(sig) {
1663    var sig0 = sig.charCodeAt(0),
1664        sig1 = sig.charCodeAt(1),
1665        sig2 = sig.charCodeAt(2),
1666        sig3 = sig.charCodeAt(3);
1667    for (var i = this.length - 4; i >= 0; --i) {
1668        if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
1669            return i;
1670        }
1671    }
1672
1673    return -1;
1674};
1675/**
1676 * @see DataReader.readData
1677 */
1678Uint8ArrayReader.prototype.readData = function(size) {
1679    this.checkOffset(size);
1680    if(size === 0) {
1681        // in IE10, when using subarray(idx, idx), we get the array [0x00] instead of [].
1682        return new Uint8Array(0);
1683    }
1684    var result = this.data.subarray(this.index, this.index + size);
1685    this.index += size;
1686    return result;
1687};
1688module.exports = Uint8ArrayReader;
1689
1690},{"./dataReader":5}],19:[function(_dereq_,module,exports){
1691'use strict';
1692
1693var utils = _dereq_('./utils');
1694
1695/**
1696 * An object to write any content to an Uint8Array.
1697 * @constructor
1698 * @param {number} length The length of the array.
1699 */
1700var Uint8ArrayWriter = function(length) {
1701    this.data = new Uint8Array(length);
1702    this.index = 0;
1703};
1704Uint8ArrayWriter.prototype = {
1705    /**
1706     * Append any content to the current array.
1707     * @param {Object} input the content to add.
1708     */
1709    append: function(input) {
1710        if (input.length !== 0) {
1711            // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
1712            input = utils.transformTo("uint8array", input);
1713            this.data.set(input, this.index);
1714            this.index += input.length;
1715        }
1716    },
1717    /**
1718     * Finalize the construction an return the result.
1719     * @return {Uint8Array} the generated array.
1720     */
1721    finalize: function() {
1722        return this.data;
1723    }
1724};
1725
1726module.exports = Uint8ArrayWriter;
1727
1728},{"./utils":21}],20:[function(_dereq_,module,exports){
1729'use strict';
1730
1731var utils = _dereq_('./utils');
1732var support = _dereq_('./support');
1733var nodeBuffer = _dereq_('./nodeBuffer');
1734
1735/**
1736 * The following functions come from pako, from pako/lib/utils/strings
1737 * released under the MIT license, see pako https://github.com/nodeca/pako/
1738 */
1739
1740// Table with utf8 lengths (calculated by first byte of sequence)
1741// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
1742// because max possible codepoint is 0x10ffff
1743var _utf8len = new Array(256);
1744for (var i=0; i<256; i++) {
1745  _utf8len[i] = (i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1);
1746}
1747_utf8len[254]=_utf8len[254]=1; // Invalid sequence start
1748
1749// convert string to array (typed, when possible)
1750var string2buf = function (str) {
1751    var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
1752
1753    // count binary size
1754    for (m_pos = 0; m_pos < str_len; m_pos++) {
1755        c = str.charCodeAt(m_pos);
1756        if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
1757            c2 = str.charCodeAt(m_pos+1);
1758            if ((c2 & 0xfc00) === 0xdc00) {
1759                c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
1760                m_pos++;
1761            }
1762        }
1763        buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
1764    }
1765
1766    // allocate buffer
1767    if (support.uint8array) {
1768        buf = new Uint8Array(buf_len);
1769    } else {
1770        buf = new Array(buf_len);
1771    }
1772
1773    // convert
1774    for (i=0, m_pos = 0; i < buf_len; m_pos++) {
1775        c = str.charCodeAt(m_pos);
1776        if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
1777            c2 = str.charCodeAt(m_pos+1);
1778            if ((c2 & 0xfc00) === 0xdc00) {
1779                c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
1780                m_pos++;
1781            }
1782        }
1783        if (c < 0x80) {
1784            /* one byte */
1785            buf[i++] = c;
1786        } else if (c < 0x800) {
1787            /* two bytes */
1788            buf[i++] = 0xC0 | (c >>> 6);
1789            buf[i++] = 0x80 | (c & 0x3f);
1790        } else if (c < 0x10000) {
1791            /* three bytes */
1792            buf[i++] = 0xE0 | (c >>> 12);
1793            buf[i++] = 0x80 | (c >>> 6 & 0x3f);
1794            buf[i++] = 0x80 | (c & 0x3f);
1795        } else {
1796            /* four bytes */
1797            buf[i++] = 0xf0 | (c >>> 18);
1798            buf[i++] = 0x80 | (c >>> 12 & 0x3f);
1799            buf[i++] = 0x80 | (c >>> 6 & 0x3f);
1800            buf[i++] = 0x80 | (c & 0x3f);
1801        }
1802    }
1803
1804    return buf;
1805};
1806
1807// Calculate max possible position in utf8 buffer,
1808// that will not break sequence. If that's not possible
1809// - (very small limits) return max size as is.
1810//
1811// buf[] - utf8 bytes array
1812// max   - length limit (mandatory);
1813var utf8border = function(buf, max) {
1814    var pos;
1815
1816    max = max || buf.length;
1817    if (max > buf.length) { max = buf.length; }
1818
1819    // go back from last position, until start of sequence found
1820    pos = max-1;
1821    while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
1822
1823    // Fuckup - very small and broken sequence,
1824    // return max, because we should return something anyway.
1825    if (pos < 0) { return max; }
1826
1827    // If we came to start of buffer - that means vuffer is too small,
1828    // return max too.
1829    if (pos === 0) { return max; }
1830
1831    return (pos + _utf8len[buf[pos]] > max) ? pos : max;
1832};
1833
1834// convert array to string
1835var buf2string = function (buf) {
1836    var str, i, out, c, c_len;
1837    var len = buf.length;
1838
1839    // Reserve max possible length (2 words per char)
1840    // NB: by unknown reasons, Array is significantly faster for
1841    //     String.fromCharCode.apply than Uint16Array.
1842    var utf16buf = new Array(len*2);
1843
1844    for (out=0, i=0; i<len;) {
1845        c = buf[i++];
1846        // quick process ascii
1847        if (c < 0x80) { utf16buf[out++] = c; continue; }
1848
1849        c_len = _utf8len[c];
1850        // skip 5 & 6 byte codes
1851        if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; }
1852
1853        // apply mask on first byte
1854        c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
1855        // join the rest
1856        while (c_len > 1 && i < len) {
1857            c = (c << 6) | (buf[i++] & 0x3f);
1858            c_len--;
1859        }
1860
1861        // terminated by end of string?
1862        if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
1863
1864        if (c < 0x10000) {
1865            utf16buf[out++] = c;
1866        } else {
1867            c -= 0x10000;
1868            utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
1869            utf16buf[out++] = 0xdc00 | (c & 0x3ff);
1870        }
1871    }
1872
1873    // shrinkBuf(utf16buf, out)
1874    if (utf16buf.length !== out) {
1875        if(utf16buf.subarray) {
1876            utf16buf = utf16buf.subarray(0, out);
1877        } else {
1878            utf16buf.length = out;
1879        }
1880    }
1881
1882    // return String.fromCharCode.apply(null, utf16buf);
1883    return utils.applyFromCharCode(utf16buf);
1884};
1885
1886
1887// That's all for the pako functions.
1888
1889
1890/**
1891 * Transform a javascript string into an array (typed if possible) of bytes,
1892 * UTF-8 encoded.
1893 * @param {String} str the string to encode
1894 * @return {Array|Uint8Array|Buffer} the UTF-8 encoded string.
1895 */
1896exports.utf8encode = function utf8encode(str) {
1897    if (support.nodebuffer) {
1898        return nodeBuffer(str, "utf-8");
1899    }
1900
1901    return string2buf(str);
1902};
1903
1904
1905/**
1906 * Transform a bytes array (or a representation) representing an UTF-8 encoded
1907 * string into a javascript string.
1908 * @param {Array|Uint8Array|Buffer} buf the data de decode
1909 * @return {String} the decoded string.
1910 */
1911exports.utf8decode = function utf8decode(buf) {
1912    if (support.nodebuffer) {
1913        return utils.transformTo("nodebuffer", buf).toString("utf-8");
1914    }
1915
1916    buf = utils.transformTo(support.uint8array ? "uint8array" : "array", buf);
1917
1918    // return buf2string(buf);
1919    // Chrome prefers to work with "small" chunks of data
1920    // for the method buf2string.
1921    // Firefox and Chrome has their own shortcut, IE doesn't seem to really care.
1922    var result = [], k = 0, len = buf.length, chunk = 65536;
1923    while (k < len) {
1924        var nextBoundary = utf8border(buf, Math.min(k + chunk, len));
1925        if (support.uint8array) {
1926            result.push(buf2string(buf.subarray(k, nextBoundary)));
1927        } else {
1928            result.push(buf2string(buf.slice(k, nextBoundary)));
1929        }
1930        k = nextBoundary;
1931    }
1932    return result.join("");
1933
1934};
1935// vim: set shiftwidth=4 softtabstop=4:
1936
1937},{"./nodeBuffer":11,"./support":17,"./utils":21}],21:[function(_dereq_,module,exports){
1938'use strict';
1939var support = _dereq_('./support');
1940var compressions = _dereq_('./compressions');
1941var nodeBuffer = _dereq_('./nodeBuffer');
1942/**
1943 * Convert a string to a "binary string" : a string containing only char codes between 0 and 255.
1944 * @param {string} str the string to transform.
1945 * @return {String} the binary string.
1946 */
1947exports.string2binary = function(str) {
1948    var result = "";
1949    for (var i = 0; i < str.length; i++) {
1950        result += String.fromCharCode(str.charCodeAt(i) & 0xff);
1951    }
1952    return result;
1953};
1954exports.arrayBuffer2Blob = function(buffer

1971);
1972        }
1973        catch (e) {
1974
1975            // well, fuck ?!
1976            throw new Error("Bug : can't construct the Blob.");
1977        }
1978    }
1979
1980
1981};
1982/**
1983 * The identity function.
1984 * @param {Object} input the input.
1985 * @return {Object} the same input.
1986 */
1987function identity(input) {
1988    return input;
1989}
1990
1991/**
1992 * Fill in an array with a string.
1993 * @param {String} str the string to use.
1994 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
1995 * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
1996 */
1997function stringToArrayLike(str, array) {
1998    for (var i = 0; i < str.length; ++i) {
1999        array[i] = str.charCodeAt(i) & 0xFF;
2000    }
2001    return array;
2002}
2003
2004/**
2005 * Transform an array-like object to a string.
2006 * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
2007 * @return {String} the result.
2008 */
2009function arrayLikeToString(array) {
2010    // Performances notes :
2011    // --------------------
2012    // String.fromCharCode.apply(null, array) is the fastest, see
2013    // see http://jsperf.com/converting-a-uint8array-to-a-string/2
2014    // but the stack is limited (and we can get huge arrays !).
2015    //
2016    // result += String.fromCharCode(array[i]); generate too many strings !
2017    //
2018    // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2
2019    var chunk = 65536;
2020    var result = [],
2021        len = array.length,
2022        type = exports.getTypeOf(array),
2023        k = 0,
2024        canUseApply = true;
2025      try {
2026         switch(type) {
2027            case "uint8array":
2028               String.fromCharCode.apply(null, new Uint8Array(0));
2029               break;
2030            case "nodebuffer":
2031               String.fromCharCode.apply(null, nodeBuffer(0));
2032               break;
2033         }
2034      } catch(e) {
2035         canUseApply = false;
2036      }
2037
2038      // no apply : slow and painful algorithm
2039      // default browser on android 4.*
2040      if (!canUseApply) {
2041         var resultStr = "";
2042         for(var i = 0; i < array.length;i++) {
2043            resultStr += String.fromCharCode(array[i]);
2044         }
2045    return resultStr;
2046    }
2047    while (k < len && chunk > 1) {
2048        try {
2049            if (type === "array" || type === "nodebuffer") {
2050                result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
2051            }
2052            else {
2053                result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
2054            }
2055            k += chunk;
2056        }
2057        catch (e) {
2058            chunk = Math.floor(chunk / 2);
2059        }
2060    }
2061    return result.join("");
2062}
2063
2064exports.applyFromCharCode = arrayLikeToString;
2065
2066
2067/**
2068 * Copy the data from an array-like to an other array-like.
2069 * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
2070 * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
2071 * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
2072 */
2073function arrayLikeToArrayLike(arrayFrom, arrayTo) {
2074    for (var i = 0; i < arrayFrom.length; i++) {
2075        arrayTo[i] = arrayFrom[i];
2076    }
2077    return arrayTo;
2078}
2079
2080// a matrix containing functions to transform everything into everything.
2081var transform = {};
2082
2083// string to ?
2084transform["string"] = {
2085    "string": identity,
2086    "array": function(input) {
2087        return stringToArrayLike(input, new Array(input.length));
2088    },
2089    "arraybuffer": function(input) {
2090        return transform["string"]["uint8array"](input).buffer;
2091    },
2092    "uint8array": function(input) {
2093        return stringToArrayLike(input, new Uint8Array(input.length));
2094    },
2095    "nodebuffer": function(input) {
2096        return stringToArrayLike(input, nodeBuffer(input.length));
2097    }
2098};
2099
2100// array to ?
2101transform["array"] = {
2102    "string": arrayLikeToString,
2103    "array": identity,
2104    "arraybuffer": function(input) {
2105        return (new Uint8Array(input)).buffer;
2106    },
2107    "uint8array": function(input) {
2108        return new Uint8Array(input);
2109    },
2110    "nodebuffer": function(input) {
2111        return nodeBuffer(input);
2112    }
2113};
2114
2115// arraybuffer to ?
2116transform["arraybuffer"] = {
2117    "string": function(input) {
2118        return arrayLikeToString(new Uint8Array(input));
2119    },
2120    "array": function(input) {
2121        return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
2122    },
2123    "arraybuffer": identity,
2124    "uint8array": function(input) {
2125        return new Uint8Array(input);
2126    },
2127    "nodebuffer": function(input) {
2128        return nodeBuffer(new Uint8Array(input));
2129    }
2130};
2131
2132// uint8array to ?
2133transform["uint8array"] = {
2134    "string": arrayLikeToString,
2135    "array": function(input) {
2136        return arrayLikeToArrayLike(input, new Array(input.length));
2137    },
2138    "arraybuffer": function(input) {
2139        return input.buffer;
2140    },
2141    "uint8array": identity,
2142    "nodebuffer": function(input) {
2143        return nodeBuffer(input);
2144    }
2145};
2146
2147// nodebuffer to ?
2148transform["nodebuffer"] = {
2149    "string": arrayLikeToString,
2150    "array": function(input) {
2151        return arrayLikeToArrayLike(input, new Array(input.length));
2152    },
2153    "arraybuffer": function(input) {
2154        return transform["nodebuffer"]["uint8array"](input).buffer;
2155    },
2156    "uint8array": function(input) {
2157        return arrayLikeToArrayLike(input, new Uint8Array(input.length));
2158    },
2159    "nodebuffer": identity
2160};
2161
2162/**
2163 * Transform an input into any type.
2164 * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer.
2165 * If no output type is specified, the unmodified input will be returned.
2166 * @param {String} outputType the output type.
2167 * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
2168 * @throws {Error} an Error if the browser doesn't support the requested output type.
2169 */
2170exports.transformTo = function(outputType, input) {
2171    if (!input) {
2172        // undefined, null, etc
2173        // an empty string won't harm.
2174        input = "";
2175    }
2176    if (!outputType) {
2177        return input;
2178    }
2179    exports.checkSupport(outputType);
2180    var inputType = exports.getTypeOf(input);
2181    var result = transform[inputType][outputType](input);
2182    return result;
2183};
2184
2185/**
2186 * Return the type of the input.
2187 * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
2188 * @param {Object} input the input to identify.
2189 * @return {String} the (lowercase) type of the input.
2190 */
2191exports.getTypeOf = function(input) {
2192    if (typeof input === "string") {
2193        return "string";
2194    }
2195    if (Object.prototype.toString.call(input) === "[object Array]") {
2196        return "array";
2197    }
2198    if (support.nodebuffer && nodeBuffer.test(input)) {
2199        return "nodebuffer";
2200    }
2201    if (support.uint8array && input instanceof Uint8Array) {
2202        return "uint8array";
2203    }
2204    if (support.arraybuffer && input instanceof ArrayBuffer) {
2205        return "arraybuffer";
2206    }
2207};
2208
2209/**
2210 * Throw an exception if the type is not supported.
2211 * @param {String} type the type to check.
2212 * @throws {Error} an Error if the browser doesn't support the requested type.
2213 */
2214exports.checkSupport = function(type) {
2215    var supported = support[type.toLowerCase()];
2216    if (!supported) {
2217        throw new Error(type + " is not supported by this browser");
2218    }
2219};
2220exports.MAX_VALUE_16BITS = 65535;
2221exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1
2222
2223/**
2224 * Prettify a string read as binary.
2225 * @param {string} str the string to prettify.
2226 * @return {string} a pretty string.
2227 */
2228exports.pretty = function(str) {
2229    var res = '',
2230        code, i;
2231    for (i = 0; i < (str || "").length; i++) {
2232        code = str.charCodeAt(i);
2233        res += '\\x' + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
2234    }
2235    return res;
2236};
2237
2238/**
2239 * Find a compression registered in JSZip.
2240 * @param {string} compressionMethod the method magic to find.
2241 * @return {Object|null} the JSZip compression object, null if none found.
2242 */
2243exports.findCompression = function(compressionMethod) {
2244    for (var method in compressions) {
2245        if (!compressions.hasOwnProperty(method)) {
2246            continue;
2247        }
2248        if (compressions[method].magic === compressionMethod) {
2249            return compressions[method];
2250        }
2251    }
2252    return null;
2253};
2254/**
2255* Cross-window, cross-Node-context regular expression detection
2256* @param  {Object}  object Anything
2257* @return {Boolean}        true if the object is a regular expression,
2258* false otherwise
2259*/
2260exports.isRegExp = function (object) {
2261    return Object.prototype.toString.call(object) === "[object RegExp]";
2262};
2263
2264
2265},{"./compressions":3,"./nodeBuffer":11,"./support":17}],22:[function(_dereq_,module,exports){
2266'use strict';
2267var StringReader = _dereq_('./stringReader');
2268var NodeBufferReader = _dereq_('./nodeBufferReader');
2269var Uint8ArrayReader = _dereq_('./uint8ArrayReader');
2270var utils = _dereq_('./utils');
2271var sig = _dereq_('./signature');
2272var ZipEntry = _dereq_('./zipEntry');
2273var support = _dereq_('./support');
2274var jszipProto = _dereq_('./object');
2275//  class ZipEntries {{{
2276/**
2277 * All the entries in the zip file.
2278 * @constructor
2279 * @param {String|ArrayBuffer|Uint8Array} data the binary stream to load.
2280 * @param {Object} loadOptions Options for loading the stream.
2281 */
2282function ZipEntries(data, loadOptions) {
2283    this.files = [];
2284    this.loadOptions = loadOptions;
2285    if (data) {
2286        this.load(data);
2287    }
2288}
2289ZipEntries.prototype = {
2290    /**
2291     * Check that the reader is on the speficied signature.
2292     * @param {string} expectedSignature the expected signature.
2293     * @throws {Error} if it is an other signature.
2294     */
2295    checkSignature: function(expectedSignature) {
2296        var signature = this.reader.readString(4);
2297        if (signature !== expectedSignature) {
2298            throw new Error("Corrupted zip or bug : unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
2299        }
2300    },
2301    /**
2302     * Read the end of the central directory.
2303     */
2304    readBlockEndOfCentral: function() {
2305        this.diskNumber = this.reader.readInt(2);
2306        this.diskWithCentralDirStart = this.reader.readInt(2);
2307        this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
2308        this.centralDirRecords = this.reader.readInt(2);
2309        this.centralDirSize = this.reader.readInt(4);
2310        this.centralDirOffset = this.reader.readInt(4);
2311
2312        this.zipCommentLength = this.reader.readInt(2);
2313        // warning : the encoding depends of the system locale
2314        // On a linux machine with LANG=en_US.utf8, this field is utf8 encoded.
2315        // On a windows machine, this field is encoded with the localized windows code page.
2316        this.zipComment = this.reader.readString(this.zipCommentLength);
2317        // To get consistent behavior with the generation part, we will assume that
2318        // this is utf8 encoded.
2319        this.zipComment = jszipProto.utf8decode(this.zipComment);
2320    },
2321    /**
2322     * Read the end of the Zip 64 central directory.
2323     * Not merged with the method readEndOfCentral :
2324     * The end of central can coexist with its Zip64 brother,
2325     * I don't want to read the wrong number of bytes !
2326     */
2327    readBlockZip64EndOfCentral: function() {
2328        this.zip64EndOfCentralSize = this.reader.readInt(8);
2329        this.versionMadeBy = this.reader.readString(2);
2330        this.versionNeeded = this.reader.readInt(2);
2331        this.diskNumber = this.reader.readInt(4);
2332        this.diskWithCentralDirStart = this.reader.readInt(4);
2333        this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
2334        this.centralDirRecords = this.reader.readInt(8);
2335        this.centralDirSize = this.reader.readInt(8);
2336        this.centralDirOffset = this.reader.readInt(8);
2337
2338        this.zip64ExtensibleData = {};
2339        var extraDataSize = this.zip64EndOfCentralSize - 44,
2340            index = 0,
2341            extraFieldId,
2342            extraFieldLength,
2343            extraFieldValue;
2344        while (index < extraDataSize) {
2345            extraFieldId = this.reader.readInt(2);
2346            extraFieldLength = this.reader.readInt(4);
2347            extraFieldValue = this.reader.readString(extraFieldLength);
2348            this.zip64ExtensibleData[extraFieldId] = {
2349                id: extraFieldId,
2350                length: extraFieldLength,
2351                value: extraFieldValue
2352            };
2353        }
2354    },
2355    /**
2356     * Read the end of the Zip 64 central directory locator.
2357     */
2358    readBlockZip64EndOfCentralLocator: function() {
2359        this.diskWithZip64CentralDirStart = this.reader.readInt(4);
2360        this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
2361        this.disksCount = this.reader.readInt(4);
2362        if (this.disksCount > 1) {
2363            throw new Error("Multi-volumes zip are not supported");
2364        }
2365    },
2366    /**
2367     * Read the local files, based on the offset read in the central part.
2368     */
2369    readLocalFiles: function() {
2370        var i, file;
2371        for (i = 0; i < this.files.length; i++) {
2372            file = this.files[i];
2373            this.reader.setIndex(file.localHeaderOffset);
2374            this.checkSignature(sig.LOCAL_FILE_HEADER);
2375            file.readLocalPart(this.reader);
2376            file.handleUTF8();
2377        

2411            } catch (e) {}
2412
2413            if (isGarbage) {
2414                throw new Error("Can't find end of central directory : is this a zip file ? " +
2415                                "If it is, see http://stuk.github.io/jszip/documentation/howto/read_zip.html");
2416            } else {
2417                throw new Error("Corrupted zip : can't find end of central directory");
2418            }
2419        }
2420        this.reader.setIndex(offset);
2421        this.checkSignature(sig.CENTRAL_DIRECTORY_END);
2422        this.readBlockEndOfCentral();
2423
2424
2425        /* extract from the zip spec :
2426            4)  If one of the fields in the end of central directory
2427                record is too small to hold required data, the field
2428                should be set to -1 (0xFFFF or 0xFFFFFFFF) and the
2429                ZIP64 format record should be created.
2430            5)  The end of central directory record and the
2431                Zip64 end of central directory locator record must
2432                reside on the same disk when splitting or spanning
2433                an archive.
2434         */
2435        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) {
2436            this.zip64 = true;
2437
2438            /*
2439            Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from
2440            the zip file can fit into a 32bits integer. This cannot be solved : Javascript represents
2441            all numbers as 64-bit double precision IEEE 754 floating point numbers.
2442            So, we have 53bits for integers and bitwise operations treat everything as 32bits.
2443            see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators
2444            and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5
2445            */
2446
2447            // should look for a zip64 EOCD locator
2448            offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
2449            if (offset === -1) {
2450                throw new Error("Corrupted zip : can't find the ZIP64 end of central directory locator");
2451            }
2452            this.reader.setIndex(offset);
2453            this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
2454            this.readBlockZip64EndOfCentralLocator();
2455
2456            // now the zip64 EOCD record
2457            this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
2458            this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
2459            this.readBlockZip64EndOfCentral();
2460        }
2461    },
2462    prepareReader: function(data) {
2463        var type = utils.getTypeOf(data);
2464        if (type === "string" && !support.uint8array) {
2465            this.reader = new StringReader(data, this.loadOptions.optimizedBinaryString);
2466        }
2467        else if (type === "nodebuffer") {
2468            this.reader = new NodeBufferReader(data);
2469        }
2470        else {
2471            this.reader = new Uint8ArrayReader(utils.transformTo("uint8array", data));
2472        }
2473    },
2474    /**
2475     * Read a zip file and create ZipEntries.
2476     * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
2477     */
2478    load: function(data) {
2479        this.prepareReader(data);
2480        this.readEndOfCentral();
2481        this.readCentralDir();
2482        this.readLocalFiles();
2483    }
2484};
2485// }}} end of ZipEntries
2486module.exports = ZipEntries;
2487
2488},{"./nodeBufferReader":12,"./object":13,"./signature":14,"./stringReader":15,"./support":17,"./uint8ArrayReader":18,"./utils":21,"./zipEntry":23}],23:[function(_dereq_,module,exports){
2489'use strict';
2490var StringReader = _dereq_('./stringReader');
2491var utils = _dereq_('./utils');
2492var CompressedObject = _dereq_('./compressedObject');
2493var jszipProto = _dereq_('./object');
2494
2495var MADE_BY_DOS = 0x00;
2496var MADE_BY_UNIX = 0x03;
2497
2498// class ZipEntry {{{
2499/**
2500 * An entry in the zip file.
2501 * @constructor
2502 * @param {Object} options Options of the current file.
2503 * @param {Object} loadOptions Options for loading the stream.
2504 */
2505function ZipEntry(options, loadOptions) {
2506    this.options = options;
2507    this.loadOptions = loadOptions;
2508}
2509ZipEntry.prototype = {
2510    /**
2511     * say if the file is encrypted.
2512     * @return {boolean} true if the file is encrypted, false otherwise.
2513     */
2514    isEncrypted: function() {
2515        // bit 1 is set
2516        return (this.bitFlag & 0x0001) === 0x0001;
2517    },
2518    /**
2519     * say if the file has utf-8 filename/comment.
2520     * @return {boolean} true if the filename/comment is in utf-8, false otherwise.
2521     */
2522    useUTF8: function() {
2523        // bit 11 is set
2524        return (this.bitFlag & 0x0800) === 0x0800;
2525    },
2526    /**
2527     * Prepare the function used to generate the compressed content from this ZipFile.
2528     * @param {DataReader} reader the reader to use.
2529     * @param {number} from the offset from where we should read the data.
2530     * @param {number} length the length of the data to read.
2531     * @return {Function} the callback to get the compressed content (the type depends of the DataReader class).
2532     */
2533    prepareCompressedContent: function(reader, from, length) {
2534        return function() {
2535            var previousIndex = reader.index;
2536            reader.setIndex(from);
2537            var compressedFileData = reader.readData(length);
2538            reader.setIndex(previousIndex);
2539
2540            return compressedFileData;
2541        };
2542    },
2543    /**
2544     * Prepare the function used to generate the uncompressed content from this ZipFile.
2545     * @param {DataReader} reader the reader to use.
2546     * @param {number} from the offset from where we should read the data.
2547     * @param {number} length the length of the data to read.
2548     * @param {JSZip.compression} compression the compression used on this file.
2549     * @param {number} uncompressedSize the uncompressed size to expect.
2550     * @return {Function} the callback to get the uncompressed content (the type depends of the DataReader class).
2551     */
2552    prepareContent: function(reader, from, length, compression, uncompressedSize) {
2553        return function() {
2554
2555            var compressedFileData = utils.transformTo(compression.uncompressInputType, this.getCompressedContent());
2556            var uncompressedFileData = compression.uncompress(compressedFileData);
2557
2558            if (uncompressedFileData.length !== uncompressedSize) {
2559                throw new Error("Bug : uncompressed data size mismatch");
2560            }
2561
2562            return uncompressedFileData;
2563        };
2564    },
2565    /**
2566     * Read the local part of a zip file and add the info in this object.
2567     * @param {DataReader} reader the reader to use.
2568     */
2569    readLocalPart: function(reader) {
2570        var compression, localExtraFieldsLength;
2571
2572        // we already know everything from the central dir !
2573        // If the central dir data are false, we are doomed.
2574        // On the bright side, the local part is scary  : zip64, data descriptors, both, etc.
2575        // The less data we get here, the more reliable this should be.
2576        // Let's skip the whole header and dash to the data !
2577        reader.skip(22);
2578        // in some zip created on windows, the filename stored in the central dir contains \ instead of /.
2579        // Strangely, the filename here is OK.
2580        // I would love to treat these zip files as corrupted (see http://www.info-zip.org/FAQ.html#backslashes
2581        // or APPNOTE#4.4.17.1, "All slashes MUST be forward slashes '/'") but there are a lot of bad zip generators...
2582        // Search "unzip mismatching "local" filename continuing with "central" filename version" on
2583        // the internet.
2584        //
2585        // I think I see the logic here : the central directory is used to display
2586        // content and the local directory is used to extract the files. Mixing / and \
2587        // may be used to display \ to windows users and use / when extracting the files.

2588        // Unfortunately, this lead also to some issues : http://seclists.org/fulldisclosure/2009/Sep/394
2589        this.fileNameLength = reader.readInt(2);
2590        localExtraFieldsLength = reader.readInt(2); // can't be sure this will be the same as the central dir
2591        this.fileName = reader.readString(this.fileNameLength);
2592        reader.skip(localExtraFieldsLength);
2593
2594        if (this.compressedSize == -1 || this.uncompressedSize == -1) {
2595            throw new Error("Bug or corrupted zip : didn't get enough informations from the central directory " + "(compressedSize == -1 || uncompressedSize == -1)");
2596        }
2597
2598        compression = utils.findCompression(this.compressionMethod);
2599        if (compression === null) { // no compression found
2600            throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + this.fileName + ")");
2601        }
2602        this.decompressed = new CompressedObject();
2603        this.decompressed.compressedSize = this.compressedSize;
2604        this.decompressed.uncompressedSize = this.uncompressedSize;
2605        this.decompressed.crc32 = this.crc32;
2606        this.decompressed.compressionMethod = this.compressionMethod;
2607        this.decompressed.getCompressedContent = this.prepareCompressedContent(reader, reader.index, this.compressedSize, compression);
2608        this.decompressed.getContent = this.prepareContent(reader, reader.index, this.compressedSize, compression, this.uncompressedSize);
2609
2610        // we need to compute the crc32...
2611        if (this.loadOptions.checkCRC32) {
2612            this.decompressed = utils.transformTo("string", this.decompressed.getContent());
2613            if (jszipProto.crc32(this.decompressed) !== this.crc32) {
2614                throw new Error("Corrupted zip : CRC32 mismatch");
2615            }
2616        }
2617    },
2618
2619    /**
2620     * Read the central part of a zip file and add the info in this object.
2621     * @param {DataReader} reader the reader to use.
2622     */
2623    readCentralPart: function(reader) {
2624        this.versionMadeBy = reader.readInt(2);
2625        this.versionNeeded = reader.readInt(2);
2626        this.bitFlag = reader.readInt(2);
2627        this.compressionMethod = reader.readString(2);
2628        this.date = reader.readDate();
2629        this.crc32 = reader.readInt(4);
2630        this.compressedSize = reader.readInt(4);
2631        this.uncompressedSize = reader.readInt(4);
2632        this.fileNameLength = reader.readInt(2);
2633        this.extraFieldsLength = reader.readInt(2);
2634        this.fileCommentLength = reader.readInt(2);
2635        this.diskNumberStart = reader.readInt(2);
2636        this.internalFileAttributes = reader.readInt(2);
2637        this.externalFileAttributes = reader.readInt(4);
2638        this.localHeaderOffset = reader.readInt(4);
2639
2640        if (this.isEncrypted()) {
2641            throw new Error("Encrypted zip are not supported");
2642        }
2643
2644        this.fileName = reader.readString(this.fileNameLength);
2645        this.readExtraFields(reader);
2646        this.parseZIP64ExtraField(reader);
2647        this.fileComment = reader.readString(this.fileCommentLength);
2648    },
2649
2650    /**
2651     * Parse the external file attributes and get the unix/dos permissions.
2652     */
2653    processAttributes: function () {
2654        this.unixPermissions = null;
2655        this.dosPermissions = null;
2656        var madeBy = this.versionMadeBy >> 8;
2657
2658        // Check if we have the DOS directory flag set.
2659        // We look for it in the DOS and UNIX permissions
2660        // but some unknown platform could set it as a compatibility flag.
2661        this.dir = this.externalFileAttributes & 0x0010 ? true : false;
2662
2663        if(madeBy === MADE_BY_DOS) {
2664            // first 6 bits (0 to 5)
2665            this.dosPermissions = this.externalFileAttributes & 0x3F;
2666        }
2667
2668        if(madeBy === MADE_BY_UNIX) {
2669            this.unixPermissions = (this.externalFileAttributes >> 16) & 0xFFFF;
2670            // the octal permissions are in (this.unixPermissions & 0x01FF).toString(8);
2671        }
2672
2673        // fail safe : if the name ends with a / it probably means a folder
2674        if (!this.dir && this.fileName.slice(-1) === '/') {
2675            this.dir = true;
2676        }
2677    },