Update jszip to the latest git (202003821d).

docs/assets/js/vendor/jszip.js

@@ -1,11 +1,267 @@
-/*!
+(function(e){if("function"==typeof bootstrap)bootstrap("jszip",e);else if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else if("undefined"!=typeof ses){if(!ses.ok())return;ses.makeJSZip=e}else"undefined"!=typeof window?window.JSZip=e():global.JSZip=e()})(function(){var define,ses,bootstrap,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(require,module,exports){
+'use strict';
+// private property
+var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+
+// public method for encoding
+exports.encode = function(input, utf8) {
+    var output = "";
+    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+    var i = 0;
+
+    while (i < input.length) {
+
+        chr1 = input.charCodeAt(i++);
+        chr2 = input.charCodeAt(i++);
+        chr3 = input.charCodeAt(i++);
+
+        enc1 = chr1 >> 2;
+        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+        enc4 = chr3 & 63;
+
+        if (isNaN(chr2)) {
+            enc3 = enc4 = 64;
+        }
+        else if (isNaN(chr3)) {
+            enc4 = 64;
+        }
+
+        output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
+
+    }
+
+    return output;
+};
+
+// public method for decoding
+exports.decode = function(input, utf8) {
+    var output = "";
+    var chr1, chr2, chr3;
+    var enc1, enc2, enc3, enc4;
+    var i = 0;
+
+    input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+    while (i < input.length) {
+
+        enc1 = _keyStr.indexOf(input.charAt(i++));
+        enc2 = _keyStr.indexOf(input.charAt(i++));
+        enc3 = _keyStr.indexOf(input.charAt(i++));
+        enc4 = _keyStr.indexOf(input.charAt(i++));
+
+        chr1 = (enc1 << 2) | (enc2 >> 4);
+        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+        chr3 = ((enc3 & 3) << 6) | enc4;
+
+        output = output + String.fromCharCode(chr1);
+
+        if (enc3 != 64) {
+            output = output + String.fromCharCode(chr2);
+        }
+        if (enc4 != 64) {
+            output = output + String.fromCharCode(chr3);
+        }
+
+    }
+
+    return output;
+
+};
+
+},{}],2:[function(require,module,exports){
+'use strict';
+function CompressedObject() {
+    this.compressedSize = 0;
+    this.uncompressedSize = 0;
+    this.crc32 = 0;
+    this.compressionMethod = null;
+    this.compressedContent = null;
+}
+
+CompressedObject.prototype = {
+    /**
+     * Return the decompressed content in an unspecified format.
+     * The format will depend on the decompressor.
+     * @return {Object} the decompressed content.
+     */
+    getContent: function() {
+        return null; // see implementation
+    },
+    /**
+     * Return the compressed content in an unspecified format.
+     * The format will depend on the compressed conten source.
+     * @return {Object} the compressed content.
+     */
+    getCompressedContent: function() {
+        return null; // see implementation
+    }
+};
+module.exports = CompressedObject;
+
+},{}],3:[function(require,module,exports){
+'use strict';
+exports.STORE = {
+    magic: "\x00\x00",
+    compress: function(content) {
+        return content; // no compression
+    },
+    uncompress: function(content) {
+        return content; // no compression
+    },
+    compressInputType: null,
+    uncompressInputType: null
+};
+exports.DEFLATE = require('./flate');
+
+},{"./flate":6}],4:[function(require,module,exports){
+'use strict';
+var utils = require('./utils');
+
+function DataReader(data) {
+    this.data = null; // type : see implementation
+    this.length = 0;
+    this.index = 0;
+}
+DataReader.prototype = {
+    /**
+     * Check that the offset will not go too far.
+     * @param {string} offset the additional offset to check.
+     * @throws {Error} an Error if the offset is out of bounds.
+     */
+    checkOffset: function(offset) {
+        this.checkIndex(this.index + offset);
+    },
+    /**
+     * Check that the specifed index will not be too far.
+     * @param {string} newIndex the index to check.
+     * @throws {Error} an Error if the index is out of bounds.
+     */
+    checkIndex: function(newIndex) {
+        if (this.length < newIndex || newIndex < 0) {
+            throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
+        }
+    },
+    /**
+     * Change the index.
+     * @param {number} newIndex The new index.
+     * @throws {Error} if the new index is out of the data.
+     */
+    setIndex: function(newIndex) {
+        this.checkIndex(newIndex);
+        this.index = newIndex;
+    },
+    /**
+     * Skip the next n bytes.
+     * @param {number} n the number of bytes to skip.
+     * @throws {Error} if the new index is out of the data.
+     */
+    skip: function(n) {
+        this.setIndex(this.index + n);
+    },
+    /**
+     * Get the byte at the specified index.
+     * @param {number} i the index to use.
+     * @return {number} a byte.
+     */
+    byteAt: function(i) {
+        // see implementations
+    },
+    /**
+     * Get the next number with a given byte size.
+     * @param {number} size the number of bytes to read.
+     * @return {number} the corresponding number.
+     */
+    readInt: function(size) {
+        var result = 0,
+            i;
+        this.checkOffset(size);
+        for (i = this.index + size - 1; i >= this.index; i--) {
+            result = (result << 8) + this.byteAt(i);
+        }
+        this.index += size;
+        return result;
+    },
+    /**
+     * Get the next string with a given byte size.
+     * @param {number} size the number of bytes to read.
+     * @return {string} the corresponding string.
+     */
+    readString: function(size) {
+        return utils.transformTo("string", this.readData(size));
+    },
+    /**
+     * Get raw data without conversion, <size> bytes.
+     * @param {number} size the number of bytes to read.
+     * @return {Object} the raw data, implementation specific.
+     */
+    readData: function(size) {
+        // see implementations
+    },
+    /**
+     * Find the last occurence of a zip signature (4 bytes).
+     * @param {string} sig the signature to find.
+     * @return {number} the index of the last occurence, -1 if not found.
+     */
+    lastIndexOfSignature: function(sig) {
+        // see implementations
+    },
+    /**
+     * Get the next date.
+     * @return {Date} the date.
+     */
+    readDate: function() {
+        var dostime = this.readInt(4);
+        return new Date(
+        ((dostime >> 25) & 0x7f) + 1980, // year
+        ((dostime >> 21) & 0x0f) - 1, // month
+        (dostime >> 16) & 0x1f, // day
+        (dostime >> 11) & 0x1f, // hour
+        (dostime >> 5) & 0x3f, // minute
+        (dostime & 0x1f) << 1); // second
+    }
+};
+module.exports = DataReader;
+
+},{"./utils":15}],5:[function(require,module,exports){
+'use strict';
+exports.base64 = false;
+exports.binary = false;
+exports.dir = false;
+exports.date = null;
+exports.compression = null;
+
+},{}],6:[function(require,module,exports){
+'use strict';
+var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
+
+var  ZlibDeflate = require('zlibjs/bin/rawdeflate.min').Zlib;
+var  ZlibInflate = require('zlibjs/bin/rawinflate.min').Zlib;
+exports.uncompressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
+exports.compressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
+
+exports.magic = "\x08\x00";
+exports.compress = function(input) {
+    var deflate = new ZlibDeflate.RawDeflate(input);
+    return deflate.compress();
+};
+exports.uncompress =  function(input) {
+    var inflate = new ZlibInflate.RawInflate(input);
+    return inflate.decompress();
+};
+
+},{"zlibjs/bin/rawdeflate.min":20,"zlibjs/bin/rawinflate.min":21}],7:[function(require,module,exports){
+'use strict';
+/**
+
 JSZip - A Javascript class for generating and reading zip files
 <http://stuartk.com/jszip>
 
 (c) 2009-2012 Stuart Knightley <stuart [at] stuartk.com>
-Dual licenced under the MIT license or GPLv3. See LICENSE.markdown.
+Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/master/LICENSE.markdown.
-*/
+
-/**
 Usage:
    zip = new JSZip();
    zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing");
@@ -16,119 +272,126 @@ Usage:
    base64zip = zip.generate();
 
 **/
-// We use strict, but it should not be placed outside of a function because
-// the environment is shared inside the browser.
-// "use strict";
 
 /**
  * Representation a of zip file in js
  * @constructor
- * @param {String=|ArrayBuffer=|Uint8Array=|Buffer=} data the data to load, if any (optional).
+ * @param {String=|ArrayBuffer=|Uint8Array=} data the data to load, if any (optional).
  * @param {Object=} options the options for creating this objects (optional).
  */
-var JSZip = function(data, options) {
+function JSZip(data, options) {
     // object containing the files :
     // {
     //   "folder/" : {...},
     //   "folder/data.txt" : {...}
     // }
+
     this.files = {};
 
     // Where we are in the hierarchy
     this.root = "";
-
     if (data) {
         this.load(data, options);
     }
+    this.clone = function() {
+        var newObj = new JSZip();
+        for (var i in this) {
+            if (typeof this[i] !== "function") {
+                newObj[i] = this[i];
+            }
+        }
+        return newObj;
+    };
+}
+JSZip.prototype = require('./object');
+JSZip.prototype.load = require('./load');
+JSZip.support = require('./support');
+JSZip.utils = require('./utils');
+JSZip.base64 = require('./base64');
+JSZip.compressions = require('./compressions');
+module.exports = JSZip;
+
+},{"./base64":1,"./compressions":3,"./load":8,"./object":10,"./support":13,"./utils":15}],8:[function(require,module,exports){
+'use strict';
+var base64 = require('./base64');
+var ZipEntries = require('./zipEntries');
+module.exports = function(data, options) {
+    var files, zipEntries, i, input;
+    options = options || {};
+    if (options.base64) {
+        data = base64.decode(data);
+    }
+
+    zipEntries = new ZipEntries(data, options);
+    files = zipEntries.files;
+    for (i = 0; i < files.length; i++) {
+        input = files[i];
+        this.file(input.fileName, input.decompressed, {
+            binary: true,
+            optimizedBinaryString: true,
+            date: input.date,
+            dir: input.dir
+        });
+    }
+
+    return this;
 };
 
-JSZip.signature = {
+},{"./base64":1,"./zipEntries":16}],9:[function(require,module,exports){
-   LOCAL_FILE_HEADER : "\x50\x4b\x03\x04",
+'use strict';
-   CENTRAL_FILE_HEADER : "\x50\x4b\x01\x02",
+var Uint8ArrayReader = require('./uint8ArrayReader');
-   CENTRAL_DIRECTORY_END : "\x50\x4b\x05\x06",
-   ZIP64_CENTRAL_DIRECTORY_LOCATOR : "\x50\x4b\x06\x07",
-   ZIP64_CENTRAL_DIRECTORY_END : "\x50\x4b\x06\x06",
-   DATA_DESCRIPTOR : "\x50\x4b\x07\x08"
-};
 
-// Default properties for a new file
+function NodeBufferReader(data) {
-JSZip.defaults = {
+    this.data = data;
-   base64: false,
+    this.length = this.data.length;
-   binary: false,
+    this.index = 0;
-   dir: false,
+}
-   date: null,
+NodeBufferReader.prototype = new Uint8ArrayReader();
-   compression: null
-};
 
-/*
+/**
- * List features that require a modern browser, and if the current browser support them.
+ * @see DataReader.readData
  */
-JSZip.support = {
+NodeBufferReader.prototype.readData = function(size) {
-   // contains true if JSZip can read/generate ArrayBuffer, false otherwise.
+    this.checkOffset(size);
-   arraybuffer : (function(){
+    var result = this.data.slice(this.index, this.index + size);
-      return typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
+    this.index += size;
-   })(),
+    return result;
-   // contains true if JSZip can read/generate nodejs Buffer, false otherwise.
-   nodebuffer : (function(){
-      return typeof Buffer !== "undefined";
-   })(),
-   // contains true if JSZip can read/generate Uint8Array, false otherwise.
-   uint8array : (function(){
-      return typeof Uint8Array !== "undefined";
-   })(),
-   // contains true if JSZip can read/generate Blob, false otherwise.
-   blob : (function(){
-      // the spec started with BlobBuilder then replaced it with a construtor for Blob.
-      // Result : we have browsers that :
-      // * know the BlobBuilder (but with prefix)
-      // * know the Blob constructor
-      // * know about Blob but not about how to build them
-      // About the "=== 0" test : if given the wrong type, it may be converted to a string.
-      // Instead of an empty content, we will get "[object Uint8Array]" for example.
-      if (typeof ArrayBuffer === "undefined") {
-         return false;
-      }
-      var buffer = new ArrayBuffer(0);
-      try {
-         return new Blob([buffer], { type: "application/zip" }).size === 0;
-      }
-      catch(e) {}
-
-      try {
-         var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
-         var builder = new BlobBuilder();
-         builder.append(buffer);
-         return builder.getBlob('application/zip').size === 0;
-      }
-      catch(e) {}
-
-      return false;
-   })()
 };
+module.exports = NodeBufferReader;
 
-JSZip.prototype = (function () {
+},{"./uint8ArrayReader":14}],10:[function(require,module,exports){
-   var textEncoder, textDecoder;
+'use strict';
-   if (
+var support = require('./support');
-      JSZip.support.uint8array &&
+var utils = require('./utils');
-      typeof TextEncoder === "function" &&
+var signature = require('./signature');
-      typeof TextDecoder === "function"
+var defaults = require('./defaults');
-   ) {
+var base64 = require('./base64');
-      textEncoder = new TextEncoder("utf-8");
+var compressions = require('./compressions');
-      textDecoder = new TextDecoder("utf-8");
+var CompressedObject = require('./compressedObject');
-   }
+var nodeBuffer = require('./nodeBuffer');
-
+/**
-   /**
  * Returns the raw data of a ZipObject, decompress the content if necessary.
  * @param {ZipObject} file the file to use.
  * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
  */
-   var getRawData = function (file) {
+
-      if (file._data instanceof JSZip.CompressedObject) {
+var textEncoder, textDecoder;
+if (
+    support.uint8array &&
+    typeof TextEncoder === "function" &&
+    typeof TextDecoder === "function"
+) {
+    textEncoder = new TextEncoder("utf-8");
+    textDecoder = new TextDecoder("utf-8");
+}
+
+var getRawData = function(file) {
+    if (file._data instanceof CompressedObject) {
         file._data = file._data.getContent();
         file.options.binary = true;
         file.options.base64 = false;
 
-         if (JSZip.utils.getTypeOf(file._data) === "uint8array") {
+        if (utils.getTypeOf(file._data) === "uint8array") {
             var copy = file._data;
             // when reading an arraybuffer, the CompressedObject mechanism will keep it and subarray() a Uint8Array.
             // if we request a file in the same format, we might get the same Uint8Array or its ArrayBuffer (the original zip file).
@@ -140,15 +403,16 @@ JSZip.prototype = (function () {
         }
     }
     return file._data;
-   };
+};
 
-   /**
+/**
  * Returns the data of a ZipObject in a binary form. If the content is an unicode string, encode it.
  * @param {ZipObject} file the file to use.
  * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
  */
-   var getBinaryData = function (file) {
+var getBinaryData = function(file) {
-      var result = getRawData(file), type = JSZip.utils.getTypeOf(result);
+    var result = getRawData(file),
+        type = utils.getTypeOf(result);
     if (type === "string") {
         if (!file.options.binary) {
             // unicode text !
@@ -156,119 +420,121 @@ JSZip.prototype = (function () {
             if (textEncoder) {
                 return textEncoder.encode(result);
             }
-            if (JSZip.support.nodebuffer) {
+            if (support.nodebuffer) {
-               return new Buffer(result, "utf-8");
+                return nodeBuffer(result, "utf-8");
             }
         }
         return file.asBinary();
     }
     return result;
-   };
+};
 
-   /**
+/**
  * Transform this._data into a string.
  * @param {function} filter a function String -> String, applied if not null on the result.
  * @return {String} the string representing this._data.
  */
-   var dataToString = function (asUTF8) {
+var dataToString = function(asUTF8) {
     var result = getRawData(this);
     if (result === null || typeof result === "undefined") {
         return "";
     }
     // if the data is a base64 string, we decode it before checking the encoding !
     if (this.options.base64) {
-         result = JSZip.base64.decode(result);
+        result = base64.decode(result);
     }
     if (asUTF8 && this.options.binary) {
         // JSZip.prototype.utf8decode supports arrays as input
         // skip to array => string step, utf8decode will do it.
-         result = JSZip.prototype.utf8decode(result);
+        result = out.utf8decode(result);
-      } else {
+    }
+    else {
         // no utf8 transformation, do the array => string step.
-         result = JSZip.utils.transformTo("string", result);
+        result = utils.transformTo("string", result);
     }
 
     if (!asUTF8 && !this.options.binary) {
-         result = JSZip.prototype.utf8encode(result);
+        result = out.utf8encode(result);
     }
     return result;
-   };
+};
-   /**
+/**
  * A simple object representing a file in the zip file.
  * @constructor
  * @param {string} name the name of the file
  * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data
  * @param {Object} options the options of the file
  */
-   var ZipObject = function (name, data, options) {
+var ZipObject = function(name, data, options) {
     this.name = name;
     this._data = data;
     this.options = options;
-   };
+};
 
-   ZipObject.prototype = {
+ZipObject.prototype = {
     /**
      * Return the content as UTF8 string.
      * @return {string} the UTF8 string.
      */
-      asText : function () {
+    asText: function() {
         return dataToString.call(this, true);
     },
     /**
      * Returns the binary content.
      * @return {string} the content as binary.
      */
-      asBinary : function () {
+    asBinary: function() {
         return dataToString.call(this, false);
     },
     /**
      * Returns the content as a nodejs Buffer.
      * @return {Buffer} the content as a Buffer.
      */
-      asNodeBuffer : function () {
+    asNodeBuffer: function() {
         var result = getBinaryData(this);
-         return JSZip.utils.transformTo("nodebuffer", result);
+        return utils.transformTo("nodebuffer", result);
     },
     /**
      * Returns the content as an Uint8Array.
      * @return {Uint8Array} the content as an Uint8Array.
      */
-      asUint8Array : function () {
+    asUint8Array: function() {
         var result = getBinaryData(this);
-         return JSZip.utils.transformTo("uint8array", result);
+        return utils.transformTo("uint8array", result);
     },
     /**
      * Returns the content as an ArrayBuffer.
      * @return {ArrayBuffer} the content as an ArrayBufer.
      */
-      asArrayBuffer : function () {
+    asArrayBuffer: function() {
         return this.asUint8Array().buffer;
     }
-   };
+};
 
-   /**
+/**
  * Transform an integer into a string in hexadecimal.
  * @private
  * @param {number} dec the number to convert.
  * @param {number} bytes the number of bytes to generate.
  * @returns {string} the result.
  */
-   var decToHex = function(dec, bytes) {
+var decToHex = function(dec, bytes) {
-      var hex = "", i;
+    var hex = "",
-      for(i = 0; i < bytes; i++) {
+        i;
-         hex += String.fromCharCode(dec&0xff);
+    for (i = 0; i < bytes; i++) {
-         dec=dec>>>8;
+        hex += String.fromCharCode(dec & 0xff);
+        dec = dec >>> 8;
     }
     return hex;
-   };
+};
 
-   /**
+/**
  * Merge the objects passed as parameters into a new one.
  * @private
  * @param {...Object} var_args All objects to merge.
  * @return {Object} a new object with the data of the others.
  */
-   var extend = function () {
+var extend = function() {
     var result = {}, i, attr;
     for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
         for (attr in arguments[i]) {
@@ -278,30 +544,28 @@ JSZip.prototype = (function () {
         }
     }
     return result;
-   };
+};
 
-   /**
+/**
  * Transforms the (incomplete) options from the user into the complete
  * set of options to create a file.
  * @private
  * @param {Object} o the options from the user.
  * @return {Object} the complete set of options.
  */
-   var prepareFileAttrs = function (o) {
+var prepareFileAttrs = function(o) {
     o = o || {};
-      /*jshint -W041 */
+    if (o.base64 === true && (o.binary === null || o.binary === undefined)) {
-      if (o.base64 === true && o.binary == null) {
         o.binary = true;
     }
-      /*jshint +W041 */
+    o = extend(o, defaults);
-      o = extend(o, JSZip.defaults);
     o.date = o.date || new Date();
     if (o.compression !== null) o.compression = o.compression.toUpperCase();
 
     return o;
-   };
+};
 
-   /**
+/**
  * Add a file in the current folder.
  * @private
  * @param {string} name the name of the file
@@ -309,9 +573,10 @@ JSZip.prototype = (function () {
  * @param {Object} o the options of the file
  * @return {Object} the new file.
  */
-   var fileAdd = function (name, data, o) {
+var fileAdd = function(name, data, o) {
     // be sure sub folders exist
-      var parent = parentFolder(name), dataType = JSZip.utils.getTypeOf(data);
+    var parent = parentFolder(name),
+        dataType = utils.getTypeOf(data);
     if (parent) {
         folderAdd.call(this, parent);
     }
@@ -322,56 +587,58 @@ JSZip.prototype = (function () {
         o.base64 = false;
         o.binary = false;
         data = null;
-      } else if (dataType === "string") {
+    }
+    else if (dataType === "string") {
         if (o.binary && !o.base64) {
             // optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask
             if (o.optimizedBinaryString !== true) {
                 // this is a string, not in a base64 format.
                 // Be sure that this is a correct "binary string"
-               data = JSZip.utils.string2binary(data);
+                data = utils.string2binary(data);
             }
         }
-      } else { // arraybuffer, uint8array, ...
+    }
+    else { // arraybuffer, uint8array, ...
         o.base64 = false;
         o.binary = true;
 
-         if (!dataType && !(data instanceof JSZip.CompressedObject)) {
+        if (!dataType && !(data instanceof CompressedObject)) {
             throw new Error("The data of '" + name + "' is in an unsupported format !");
         }
 
         // special case : it's way easier to work with Uint8Array than with ArrayBuffer
         if (dataType === "arraybuffer") {
-            data = JSZip.utils.transformTo("uint8array", data);
+            data = utils.transformTo("uint8array", data);
         }
     }
 
     var object = new ZipObject(name, data, o);
     this.files[name] = object;
     return object;
-   };
+};
 
 
-   /**
+/**
  * Find the parent folder of the path.
  * @private
  * @param {string} path the path to use
  * @return {string} the parent folder, or ""
  */
-   var parentFolder = function (path) {
+var parentFolder = function(path) {
     if (path.slice(-1) == '/') {
         path = path.substring(0, path.length - 1);
     }
     var lastSlash = path.lastIndexOf('/');
     return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
-   };
+};
 
-   /**
+/**
  * Add a (sub) folder in the current folder.
  * @private
  * @param {string} name the folder's name
  * @return {Object} the new folder.
  */
-   var folderAdd = function (name) {
+var folderAdd = function(name) {
     // Check the name ends with a /
     if (name.slice(-1) != "/") {
         name += "/"; // IE doesn't like substr(-1)
@@ -379,55 +646,61 @@ JSZip.prototype = (function () {
 
     // Does this folder already exist?
     if (!this.files[name]) {
-         fileAdd.call(this, name, null, {dir:true});
+        fileAdd.call(this, name, null, {
+            dir: true
+        });
     }
     return this.files[name];
-   };
+};
 
-   /**
+/**
  * Generate a JSZip.CompressedObject for a given zipOject.
  * @param {ZipObject} file the object to read.
  * @param {JSZip.compression} compression the compression to use.
  * @return {JSZip.CompressedObject} the compressed result.
  */
-   var generateCompressedObjectFrom = function (file, compression) {
+var generateCompressedObjectFrom = function(file, compression) {
-      var result = new JSZip.CompressedObject(), content;
+    var result = new CompressedObject(),
+        content;
 
     // the data has not been decompressed, we might reuse things !
-      if (file._data instanceof JSZip.CompressedObject) {
+    if (file._data instanceof CompressedObject) {
         result.uncompressedSize = file._data.uncompressedSize;
         result.crc32 = file._data.crc32;
 
         if (result.uncompressedSize === 0 || file.options.dir) {
-            compression = JSZip.compressions['STORE'];
+            compression = compressions['STORE'];
             result.compressedContent = "";
             result.crc32 = 0;
-         } else if (file._data.compressionMethod === compression.magic) {
+        }
+        else if (file._data.compressionMethod === compression.magic) {
             result.compressedContent = file._data.getCompressedContent();
-         } else {
+        }
+        else {
             content = file._data.getContent();
             // need to decompress / recompress
-            result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content));
+            result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content));
         }
-      } else {
+    }
+    else {
         // have uncompressed data
         content = getBinaryData(file);
         if (!content || content.length === 0 || file.options.dir) {
-            compression = JSZip.compressions['STORE'];
+            compression = compressions['STORE'];
             content = "";
         }
         result.uncompressedSize = content.length;
         result.crc32 = this.crc32(content);
-         result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content));
+        result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content));
     }
 
     result.compressedSize = result.compressedContent.length;
     result.compressionMethod = compression.magic;
 
     return result;
-   };
+};
 
-   /**
+/**
  * Generate the various parts used in the construction of the final zip file.
  * @param {string} name the file name.
  * @param {ZipObject} file the file content.
@@ -435,7 +708,7 @@ JSZip.prototype = (function () {
  * @param {number} offset the current offset from the start of the zip file.
  * @return {object} the zip parts.
  */
-   var generateZipParts = function(name, file, compressedObject, offset) {
+var generateZipParts = function(name, file, compressedObject, offset) {
     var data = compressedObject.compressedContent,
         utfEncodedFileName = this.utf8encode(file.name),
         useUTF8 = utfEncodedFileName !== file.name,
@@ -486,9 +759,9 @@ JSZip.prototype = (function () {
     header += "\x00\x00";
 
 
-      var fileRecord = JSZip.signature.LOCAL_FILE_HEADER + header + utfEncodedFileName;
+    var fileRecord = signature.LOCAL_FILE_HEADER + header + utfEncodedFileName;
 
-      var dirRecord = JSZip.signature.CENTRAL_FILE_HEADER +
+    var dirRecord = signature.CENTRAL_FILE_HEADER +
     // version made by (00: DOS)
     "\x14\x00" +
     // file header (common to file and central directory)
@@ -500,7 +773,7 @@ JSZip.prototype = (function () {
     // internal file attributes TODO
     "\x00\x00" +
     // external file attributes
-      (file.options.dir===true?"\x10\x00\x00\x00":"\x00\x00\x00\x00")+
+    (file.options.dir === true ? "\x10\x00\x00\x00" : "\x00\x00\x00\x00") +
     // relative offset of local header
     decToHex(offset, 4) +
     // file name
@@ -508,54 +781,54 @@ JSZip.prototype = (function () {
 
 
     return {
-         fileRecord : fileRecord,
+        fileRecord: fileRecord,
-         dirRecord : dirRecord,
+        dirRecord: dirRecord,
-         compressedObject : compressedObject
+        compressedObject: compressedObject
-      };
     };
+};
 
-   /**
+/**
  * An object to write any content to a string.
  * @constructor
  */
-   var StringWriter = function () {
+var StringWriter = function() {
     this.data = [];
-   };
+};
-   StringWriter.prototype = {
+StringWriter.prototype = {
     /**
      * Append any content to the current string.
      * @param {Object} input the content to add.
      */
-      append : function (input) {
+    append: function(input) {
-         input = JSZip.utils.transformTo("string", input);
+        input = utils.transformTo("string", input);
         this.data.push(input);
     },
     /**
      * Finalize the construction an return the result.
      * @return {string} the generated string.
      */
-      finalize : function () {
+    finalize: function() {
         return this.data.join("");
     }
-   };
+};
-   /**
+/**
  * An object to write any content to an Uint8Array.
  * @constructor
  * @param {number} length The length of the array.
  */
-   var Uint8ArrayWriter = function (length) {
+var Uint8ArrayWriter = function(length) {
     this.data = new Uint8Array(length);
     this.index = 0;
-   };
+};
-   Uint8ArrayWriter.prototype = {
+Uint8ArrayWriter.prototype = {
     /**
      * Append any content to the current array.
      * @param {Object} input the content to add.
      */
-      append : function (input) {
+    append: function(input) {
         if (input.length !== 0) {
             // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
-            input = JSZip.utils.transformTo("uint8array", input);
+            input = utils.transformTo("uint8array", input);
             this.data.set(input, this.index);
             this.index += input.length;
         }
@@ -564,13 +837,13 @@ JSZip.prototype = (function () {
      * Finalize the construction an return the result.
      * @return {Uint8Array} the generated array.
      */
-      finalize : function () {
+    finalize: function() {
         return this.data;
     }
-   };
+};
 
-   // return the actual prototype of JSZip
+// return the actual prototype of JSZip
-   return {
+var out = {
     /**
      * Read an existing zip and merge the data in the current JSZip object.
      * The implementation is in jszip-load.js, don't forget to include it.
@@ -579,7 +852,7 @@ JSZip.prototype = (function () {
      *  options.base64 : is the stream in base64 ? default : false
      * @return {JSZip} the current JSZip object
      */
-      load : function (stream, options) {
+    load: function(stream, options) {
         throw new Error("Load method is not defined. Is the file jszip-load.js included ?");
     },
 
@@ -590,10 +863,13 @@ JSZip.prototype = (function () {
      * It takes 2 arguments : the relative path and the file.
      * @return {Array} An array of matching elements.
      */
-      filter : function (search) {
+    filter: function(search) {
-         var result = [], filename, relativePath, file, fileClone;
+        var result = [],
+            filename, relativePath, file, fileClone;
         for (filename in this.files) {
-            if ( !this.files.hasOwnProperty(filename) ) { continue; }
+            if (!this.files.hasOwnProperty(filename)) {
+                continue;
+            }
             file = this.files[filename];
             // return a new object, don't let the user mess with our internal objects :)
             fileClone = new ZipObject(file.name, file._data, extend(file.options));
@@ -615,20 +891,22 @@ JSZip.prototype = (function () {
      * @return  {JSZip|Object|Array} this JSZip object (when adding a file),
      * a file (when searching by string) or an array of files (when searching by regex).
      */
-      file : function(name, data, o) {
+    file: function(name, data, o) {
         if (arguments.length === 1) {
-            if (JSZip.utils.isRegExp(name)) {
+            if (utils.isRegExp(name)) {
                 var regexp = name;
                 return this.filter(function(relativePath, file) {
                     return !file.options.dir && regexp.test(relativePath);
                 });
-            } else { // text
-               return this.filter(function (relativePath, file) {
-                  return !file.options.dir && relativePath === name;
-               })[0]||null;
             }
-         } else { // more than one argument : we have data !
+            else { // text
-            name = this.root+name;
+                return this.filter(function(relativePath, file) {
+                    return !file.options.dir && relativePath === name;
+                })[0] || null;
+            }
+        }
+        else { // more than one argument : we have data !
+            name = this.root + name;
             fileAdd.call(this, name, data, o);
         }
         return this;
@@ -639,12 +917,12 @@ JSZip.prototype = (function () {
      * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
      * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
      */
-      folder : function(arg) {
+    folder: function(arg) {
         if (!arg) {
             return this;
         }
 
-         if (JSZip.utils.isRegExp(arg)) {
+        if (utils.isRegExp(arg)) {
             return this.filter(function(relativePath, file) {
                 return file.options.dir && arg.test(relativePath);
             });
@@ -665,7 +943,7 @@ JSZip.prototype = (function () {
      * @param {string} name the name of the file to delete
      * @return {JSZip} this JSZip object
      */
-      remove : function(name) {
+    remove: function(name) {
         name = this.root + name;
         var file = this.files[name];
         if (!file) {
@@ -680,9 +958,10 @@ JSZip.prototype = (function () {
             if (!file.options.dir) {
                 // file
                 delete this.files[name];
-            } else {
+            }
+            else {
                 // folder
-               var kids = this.filter(function (relativePath, file) {
+                var kids = this.filter(function(relativePath, file) {
                     return file.name.slice(0, name.length) === name;
                 });
                 for (var i = 0; i < kids.length; i++) {
@@ -702,25 +981,30 @@ JSZip.prototype = (function () {
      * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
      * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
      */
-      generate : function(options) {
+    generate: function(options) {
         options = extend(options || {}, {
-            base64 : true,
+            base64: true,
-            compression : "STORE",
+            compression: "STORE",
-            type : "base64"
+            type: "base64"
         });
 
-         JSZip.utils.checkSupport(options.type);
+        utils.checkSupport(options.type);
 
-         var zipData = [], localDirLength = 0, centralDirLength = 0, writer, i;
+        var zipData = [],
+            localDirLength = 0,
+            centralDirLength = 0,
+            writer, i;
 
 
         // first, generate all the zip parts.
         for (var name in this.files) {
-            if ( !this.files.hasOwnProperty(name) ) { continue; }
+            if (!this.files.hasOwnProperty(name)) {
+                continue;
+            }
             var file = this.files[name];
 
             var compressionName = file.options.compression || options.compression.toUpperCase();
-            var compression = JSZip.compressions[compressionName];
+            var compression = compressions[compressionName];
             if (!compression) {
                 throw new Error(compressionName + " is not a valid compression method !");
             }
@@ -736,7 +1020,7 @@ JSZip.prototype = (function () {
         var dirEnd = "";
 
         // end of central dir signature
-         dirEnd = JSZip.signature.CENTRAL_DIRECTORY_END +
+        dirEnd = signature.CENTRAL_DIRECTORY_END +
         // number of this disk
         "\x00\x00" +
         // number of the disk with the start of the central directory
@@ -755,18 +1039,11 @@ JSZip.prototype = (function () {
 
         // we have all the parts (and the total length)
         // time to create a writer !
-         switch(options.type.toLowerCase()) {
+        var typeName = options.type.toLowerCase();
-            case "uint8array" :
+        if(typeName==="uint8array"||typeName==="arraybuffer"||typeName==="blob"||typeName==="nodebuffer") {
-            case "arraybuffer" :
-            case "blob" :
-            case "nodebuffer" :
             writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length);
-               break;
+        }else{
-            // case "base64" :
-            // case "string" :
-            default :
             writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length);
-               break;
         }
 
         for (i = 0; i < zipData.length; i++) {
@@ -788,16 +1065,16 @@ JSZip.prototype = (function () {
             case "uint8array" :
             case "arraybuffer" :
             case "nodebuffer" :
-               return JSZip.utils.transformTo(options.type.toLowerCase(), zip);
+               return utils.transformTo(options.type.toLowerCase(), zip);
             case "blob" :
-               return JSZip.utils.arrayBuffer2Blob(JSZip.utils.transformTo("arraybuffer", zip));
+               return utils.arrayBuffer2Blob(utils.transformTo("arraybuffer", zip));
-
             // case "zip is a string"
             case "base64" :
-               return (options.base64) ? JSZip.base64.encode(zip) : zip;
+               return (options.base64) ? base64.encode(zip) : zip;
             default : // case "string" :
                return zip;
          }
+
     },
 
     /**
@@ -806,12 +1083,12 @@ JSZip.prototype = (function () {
      *  http://www.webtoolkit.info/
      *
      */
-      crc32 : function crc32(input, crc) {
+    crc32: function crc32(input, crc) {
         if (typeof input === "undefined" || !input.length) {
             return 0;
         }
 
-         var isArray = JSZip.utils.getTypeOf(input) !== "string";
+        var isArray = utils.getTypeOf(input) !== "string";
 
         var table = [
         0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
@@ -877,55 +1154,47 @@ JSZip.prototype = (function () {
         0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
         0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
         0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
-            0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+        0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D];
-         ];
 
-         if (typeof(crc) == "undefined") { crc = 0; }
+        if (typeof(crc) == "undefined") {
+            crc = 0;
+        }
         var x = 0;
         var y = 0;
-         var byte = 0;
+        var b = 0;
 
         crc = crc ^ (-1);
-         for( var i = 0, iTop = input.length; i < iTop; i++ ) {
+        for (var i = 0, iTop = input.length; i < iTop; i++) {
-            byte = isArray ? input[i] : input.charCodeAt(i);
+            b = isArray ? input[i] : input.charCodeAt(i);
-            y = ( crc ^ byte ) & 0xFF;
+            y = (crc ^ b) & 0xFF;
             x = table[y];
-            crc = ( crc >>> 8 ) ^ x;
+            crc = (crc >>> 8) ^ x;
         }
 
         return crc ^ (-1);
     },
 
     // Inspired by http://my.opera.com/GreyWyvern/blog/show.dml/1725165
-      clone : function() {
-         var newObj = new JSZip();
-         for (var i in this) {
-            if (typeof this[i] !== "function") {
-               newObj[i] = this[i];
-            }
-         }
-         return newObj;
-      },
-
 
     /**
      * http://www.webtoolkit.info/javascript-utf8.html
      */
-      utf8encode : function (string) {
+    utf8encode: function(string) {
         // TextEncoder + Uint8Array to binary string is faster than checking every bytes on long strings.
         // http://jsperf.com/utf8encode-vs-textencoder
         // On short strings (file names for example), the TextEncoder API is (currently) slower.
         if (textEncoder) {
             var u8 = textEncoder.encode(string);
-            return JSZip.utils.transformTo("string", u8);
+            return utils.transformTo("string", u8);
         }
-         if (JSZip.support.nodebuffer) {
+        if (support.nodebuffer) {
-            return JSZip.utils.transformTo("string", new Buffer(string, "utf-8"));
+            return utils.transformTo("string", nodeBuffer(string, "utf-8"));
         }
 
         // array.join may be slower than string concatenation but generates less objects (less time spent garbage collecting).
         // See also http://jsperf.com/array-direct-assignment-vs-push/31
-         var result = [], resIndex = 0;
+        var result = [],
+            resIndex = 0;
 
         for (var n = 0; n < string.length; n++) {
 
@@ -933,10 +1202,12 @@ JSZip.prototype = (function () {
 
             if (c < 128) {
                 result[resIndex++] = String.fromCharCode(c);
-            } else if ((c > 127) && (c < 2048)) {
+            }
+            else if ((c > 127) && (c < 2048)) {
                 result[resIndex++] = String.fromCharCode((c >> 6) | 192);
                 result[resIndex++] = String.fromCharCode((c & 63) | 128);
-            } else {
+            }
+            else {
                 result[resIndex++] = String.fromCharCode((c >> 12) | 224);
                 result[resIndex++] = String.fromCharCode(((c >> 6) & 63) | 128);
                 result[resIndex++] = String.fromCharCode((c & 63) | 128);
@@ -950,38 +1221,44 @@ JSZip.prototype = (function () {
     /**
      * http://www.webtoolkit.info/javascript-utf8.html
      */
-      utf8decode : function (input) {
+    utf8decode: function(input) {
-         var result = [], resIndex = 0;
+        var result = [],
-         var type = JSZip.utils.getTypeOf(input);
+            resIndex = 0;
+        var type = utils.getTypeOf(input);
         var isArray = type !== "string";
         var i = 0;
-         var c = 0, c1 = 0, c2 = 0, c3 = 0;
+        var c = 0,
+            c1 = 0,
+            c2 = 0,
+            c3 = 0;
 
         // check if we can use the TextDecoder API
         // see http://encoding.spec.whatwg.org/#api
         if (textDecoder) {
             return textDecoder.decode(
-               JSZip.utils.transformTo("uint8array", input)
+                utils.transformTo("uint8array", input)
             );
         }
-         if (JSZip.support.nodebuffer) {
+        if (support.nodebuffer) {
-            return JSZip.utils.transformTo("nodebuffer", input).toString("utf-8");
+            return utils.transformTo("nodebuffer", input).toString("utf-8");
         }
 
-         while ( i < input.length ) {
+        while (i < input.length) {
 
             c = isArray ? input[i] : input.charCodeAt(i);
 
             if (c < 128) {
                 result[resIndex++] = String.fromCharCode(c);
                 i++;
-            } else if ((c > 191) && (c < 224)) {
+            }
-               c2 = isArray ? input[i+1] : input.charCodeAt(i+1);
+            else if ((c > 191) && (c < 224)) {
+                c2 = isArray ? input[i + 1] : input.charCodeAt(i + 1);
                 result[resIndex++] = String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                 i += 2;
-            } else {
+            }
-               c2 = isArray ? input[i+1] : input.charCodeAt(i+1);
+            else {
-               c3 = isArray ? input[i+2] : input.charCodeAt(i+2);
+                c2 = isArray ? input[i + 1] : input.charCodeAt(i + 1);
+                c3 = isArray ? input[i + 2] : input.charCodeAt(i + 2);
                 result[resIndex++] = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                 i += 3;
             }
@@ -990,139 +1267,236 @@ JSZip.prototype = (function () {
 
         return result.join("");
     }
-   };
-}());
-
-/*
- * Compression methods
- * This object is filled in as follow :
- * name : {
- *    magic // the 2 bytes indentifying the compression method
- *    compress // function, take the uncompressed content and return it compressed.
- *    uncompress // function, take the compressed content and return it uncompressed.
- *    compressInputType // string, the type accepted by the compress method. null to accept everything.
- *    uncompressInputType // string, the type accepted by the uncompress method. null to accept everything.
- * }
- *
- * STORE is the default compression method, so it's included in this file.
- * Other methods should go to separated files : the user wants modularity.
- */
-JSZip.compressions = {
-   "STORE" : {
-      magic : "\x00\x00",
-      compress : function (content) {
-         return content; // no compression
-      },
-      uncompress : function (content) {
-         return content; // no compression
-      },
-      compressInputType : null,
-      uncompressInputType : null
-   }
 };
+module.exports = out;
 
-(function () {
+},{"./base64":1,"./compressedObject":2,"./compressions":3,"./defaults":5,"./nodeBuffer":18,"./signature":11,"./support":13,"./utils":15}],11:[function(require,module,exports){
-   JSZip.utils = {
+'use strict';
-      /**
+exports.LOCAL_FILE_HEADER = "PK\x03\x04";
+exports.CENTRAL_FILE_HEADER = "PK\x01\x02";
+exports.CENTRAL_DIRECTORY_END = "PK\x05\x06";
+exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
+exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
+exports.DATA_DESCRIPTOR = "PK\x07\x08";
+
+},{}],12:[function(require,module,exports){
+'use strict';
+var DataReader = require('./dataReader');
+var utils = require('./utils');
+
+function StringReader(data, optimizedBinaryString) {
+    this.data = data;
+    if (!optimizedBinaryString) {
+        this.data = utils.string2binary(this.data);
+    }
+    this.length = this.data.length;
+    this.index = 0;
+}
+StringReader.prototype = new DataReader();
+/**
+ * @see DataReader.byteAt
+ */
+StringReader.prototype.byteAt = function(i) {
+    return this.data.charCodeAt(i);
+};
+/**
+ * @see DataReader.lastIndexOfSignature
+ */
+StringReader.prototype.lastIndexOfSignature = function(sig) {
+    return this.data.lastIndexOf(sig);
+};
+/**
+ * @see DataReader.readData
+ */
+StringReader.prototype.readData = function(size) {
+    this.checkOffset(size);
+    // this will work because the constructor applied the "& 0xff" mask.
+    var result = this.data.slice(this.index, this.index + size);
+    this.index += size;
+    return result;
+};
+module.exports = StringReader;
+
+},{"./dataReader":4,"./utils":15}],13:[function(require,module,exports){
+var process=require("__browserify_process");'use strict';
+exports.base64 = true;
+exports.array = true;
+exports.string = true;
+exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
+// contains true if JSZip can read/generate nodejs Buffer, false otherwise, aka checks if we arn't in a browser.
+exports.nodebuffer = !process.browser;
+// contains true if JSZip can read/generate Uint8Array, false otherwise.
+exports.uint8array = typeof Uint8Array !== "undefined";
+
+if (typeof ArrayBuffer === "undefined") {
+    exports.blob = false;
+}
+else {
+    var buffer = new ArrayBuffer(0);
+    try {
+        exports.blob = new Blob([buffer], {
+            type: "application/zip"
+        }).size === 0;
+    }
+    catch (e) {
+        try {
+            var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
+            var builder = new Builder();
+            builder.append(buffer);
+            exports.blob = builder.getBlob('application/zip').size === 0;
+        }
+        catch (e) {
+            exports.blob = false;
+        }
+    }
+}
+
+},{"__browserify_process":19}],14:[function(require,module,exports){
+'use strict';
+var DataReader = require('./dataReader');
+
+function Uint8ArrayReader(data) {
+    if (data) {
+        this.data = data;
+        this.length = this.data.length;
+        this.index = 0;
+    }
+}
+Uint8ArrayReader.prototype = new DataReader();
+/**
+ * @see DataReader.byteAt
+ */
+Uint8ArrayReader.prototype.byteAt = function(i) {
+    return this.data[i];
+};
+/**
+ * @see DataReader.lastIndexOfSignature
+ */
+Uint8ArrayReader.prototype.lastIndexOfSignature = function(sig) {
+    var sig0 = sig.charCodeAt(0),
+        sig1 = sig.charCodeAt(1),
+        sig2 = sig.charCodeAt(2),
+        sig3 = sig.charCodeAt(3);
+    for (var i = this.length - 4; i >= 0; --i) {
+        if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
+            return i;
+        }
+    }
+
+    return -1;
+};
+/**
+ * @see DataReader.readData
+ */
+Uint8ArrayReader.prototype.readData = function(size) {
+    this.checkOffset(size);
+    var result = this.data.subarray(this.index, this.index + size);
+    this.index += size;
+    return result;
+};
+module.exports = Uint8ArrayReader;
+
+},{"./dataReader":4}],15:[function(require,module,exports){
+'use strict';
+var support = require('./support');
+var compressions = require('./compressions');
+var nodeBuffer = require('./nodeBuffer');
+/**
  * Convert a string to a "binary string" : a string containing only char codes between 0 and 255.
  * @param {string} str the string to transform.
  * @return {String} the binary string.
  */
-      string2binary : function (str) {
+exports.string2binary = function(str) {
     var result = "";
     for (var i = 0; i < str.length; i++) {
         result += String.fromCharCode(str.charCodeAt(i) & 0xff);
     }
     return result;
-      },
+};
-      /**
+/**
  * Create a Uint8Array from the string.
  * @param {string} str the string to transform.
  * @return {Uint8Array} the typed array.
  * @throws {Error} an Error if the browser doesn't support the requested feature.
-       * @deprecated : use JSZip.utils.transformTo instead.
  */
-      string2Uint8Array : function (str) {
+exports.string2Uint8Array = function(str) {
-         return JSZip.utils.transformTo("uint8array", str);
+    return exports.transformTo("uint8array", str);
-      },
+};
 
-      /**
+/**
  * Create a string from the Uint8Array.
  * @param {Uint8Array} array the array to transform.
  * @return {string} the string.
  * @throws {Error} an Error if the browser doesn't support the requested feature.
-       * @deprecated : use JSZip.utils.transformTo instead.
  */
-      uint8Array2String : function (array) {
+exports.uint8Array2String = function(array) {
-         return JSZip.utils.transformTo("string", array);
+    return exports.transformTo("string", array);
-      },
+};
-      /**
+/**
-       * Create a blob from the given ArrayBuffer.
+ * Create a blob from the given string.
-       * @param {ArrayBuffer} buffer the buffer to transform.
+ * @param {string} str the string to transform.
-       * @return {Blob} the result.
+ * @return {Blob} the string.
  * @throws {Error} an Error if the browser doesn't support the requested feature.
  */
-      arrayBuffer2Blob : function (buffer) {
+exports.string2Blob = function(str) {
-         JSZip.utils.checkSupport("blob");
+    var buffer = exports.transformTo("arraybuffer", str);
+    return exports.arrayBuffer2Blob(buffer);
+};
+exports.arrayBuffer2Blob = function(buffer) {
+    exports.checkSupport("blob");
 
     try {
         // Blob constructor
-            return new Blob([buffer], { type: "application/zip" });
+        return new Blob([buffer], {
+            type: "application/zip"
+        });
     }
-         catch(e) {}
+    catch (e) {
 
         try {
             // deprecated, browser only, old way
-            var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
+            var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
-            var builder = new BlobBuilder();
+            var builder = new Builder();
             builder.append(buffer);
             return builder.getBlob('application/zip');
         }
-         catch(e) {}
+        catch (e) {
 
             // well, fuck ?!
             throw new Error("Bug : can't construct the Blob.");
-      },
-      /**
-       * Create a blob from the given string.
-       * @param {string} str the string to transform.
-       * @return {Blob} the result.
-       * @throws {Error} an Error if the browser doesn't support the requested feature.
-       */
-      string2Blob : function (str) {
-         var buffer = JSZip.utils.transformTo("arraybuffer", str);
-         return JSZip.utils.arrayBuffer2Blob(buffer);
         }
-   };
+    }
 
-   /**
+
+};
+/**
  * The identity function.
  * @param {Object} input the input.
  * @return {Object} the same input.
  */
-   function identity(input) {
+function identity(input) {
     return input;
-   }
+}
 
-   /**
+/**
  * Fill in an array with a string.
  * @param {String} str the string to use.
  * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
  * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
  */
-   function stringToArrayLike(str, array) {
+function stringToArrayLike(str, array) {
     for (var i = 0; i < str.length; ++i) {
         array[i] = str.charCodeAt(i) & 0xFF;
     }
     return array;
-   }
+}
 
-   /**
+/**
  * Transform an array-like object to a string.
  * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
  * @return {String} the result.
  */
-   function arrayLikeToString(array) {
+function arrayLikeToString(array) {
     // Performances notes :
     // --------------------
     // String.fromCharCode.apply(null, array) is the fastest, see
@@ -1133,16 +1507,18 @@ JSZip.compressions = {
     //
     // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2
     var chunk = 65536;
-      var result = [], len = array.length, type = JSZip.utils.getTypeOf(array), k = 0;
+    var result = [],
-
+        len = array.length,
-      var canUseApply = true;
+        type = exports.getTypeOf(array),
+        k = 0,
+        canUseApply = true;
       try {
          switch(type) {
             case "uint8array":
                String.fromCharCode.apply(null, new Uint8Array(0));
                break;
             case "nodebuffer":
-               String.fromCharCode.apply(null, new Buffer(0));
+               String.fromCharCode.apply(null, nodeBuffer(0));
                break;
          }
       } catch(e) {
@@ -1158,118 +1534,119 @@ JSZip.compressions = {
          }
     return resultStr;
     }
-
     while (k < len && chunk > 1) {
         try {
             if (type === "array" || type === "nodebuffer") {
                 result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
-            } else {
+            }
+            else {
                 result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
             }
             k += chunk;
-         } catch (e) {
+        }
+        catch (e) {
             chunk = Math.floor(chunk / 2);
         }
     }
     return result.join("");
-   }
+}
 
-   /**
+/**
  * Copy the data from an array-like to an other array-like.
  * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
  * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
  * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
  */
-   function arrayLikeToArrayLike(arrayFrom, arrayTo) {
+function arrayLikeToArrayLike(arrayFrom, arrayTo) {
-      for(var i = 0; i < arrayFrom.length; i++) {
+    for (var i = 0; i < arrayFrom.length; i++) {
         arrayTo[i] = arrayFrom[i];
     }
     return arrayTo;
-   }
+}
 
-   // a matrix containing functions to transform everything into everything.
+// a matrix containing functions to transform everything into everything.
-   var transform = {};
+var transform = {};
 
-   // string to ?
+// string to ?
-   transform["string"] = {
+transform["string"] = {
-      "string" : identity,
+    "string": identity,
-      "array" : function (input) {
+    "array": function(input) {
         return stringToArrayLike(input, new Array(input.length));
     },
-      "arraybuffer" : function (input) {
+    "arraybuffer": function(input) {
         return transform["string"]["uint8array"](input).buffer;
     },
-      "uint8array" : function (input) {
+    "uint8array": function(input) {
         return stringToArrayLike(input, new Uint8Array(input.length));
     },
-      "nodebuffer" : function (input) {
+    "nodebuffer": function(input) {
-         return stringToArrayLike(input, new Buffer(input.length));
+        return stringToArrayLike(input, nodeBuffer(input.length));
     }
-   };
+};
 
-   // array to ?
+// array to ?
-   transform["array"] = {
+transform["array"] = {
-      "string" : arrayLikeToString,
+    "string": arrayLikeToString,
-      "array" : identity,
+    "array": identity,
-      "arraybuffer" : function (input) {
+    "arraybuffer": function(input) {
         return (new Uint8Array(input)).buffer;
     },
-      "uint8array" : function (input) {
+    "uint8array": function(input) {
         return new Uint8Array(input);
     },
-      "nodebuffer" : function (input) {
+    "nodebuffer": function(input) {
-         return new Buffer(input);
+        return nodeBuffer(input);
     }
-   };
+};
 
-   // arraybuffer to ?
+// arraybuffer to ?
-   transform["arraybuffer"] = {
+transform["arraybuffer"] = {
-      "string" : function (input) {
+    "string": function(input) {
         return arrayLikeToString(new Uint8Array(input));
     },
-      "array" : function (input) {
+    "array": function(input) {
         return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
     },
-      "arraybuffer" : identity,
+    "arraybuffer": identity,
-      "uint8array" : function (input) {
+    "uint8array": function(input) {
         return new Uint8Array(input);
     },
-      "nodebuffer" : function (input) {
+    "nodebuffer": function(input) {
-         return new Buffer(new Uint8Array(input));
+        return nodeBuffer(new Uint8Array(input));
     }
-   };
+};
 
-   // uint8array to ?
+// uint8array to ?
-   transform["uint8array"] = {
+transform["uint8array"] = {
-      "string" : arrayLikeToString,
+    "string": arrayLikeToString,
-      "array" : function (input) {
+    "array": function(input) {
         return arrayLikeToArrayLike(input, new Array(input.length));
     },
-      "arraybuffer" : function (input) {
+    "arraybuffer": function(input) {
         return input.buffer;
     },
-      "uint8array" : identity,
+    "uint8array": identity,
-      "nodebuffer" : function(input) {
+    "nodebuffer": function(input) {
-         return new Buffer(input);
+        return nodeBuffer(input);
     }
-   };
+};
 
-   // nodebuffer to ?
+// nodebuffer to ?
-   transform["nodebuffer"] = {
+transform["nodebuffer"] = {
-      "string" : arrayLikeToString,
+    "string": arrayLikeToString,
-      "array" : function (input) {
+    "array": function(input) {
         return arrayLikeToArrayLike(input, new Array(input.length));
     },
-      "arraybuffer" : function (input) {
+    "arraybuffer": function(input) {
         return transform["nodebuffer"]["uint8array"](input).buffer;
     },
-      "uint8array" : function (input) {
+    "uint8array": function(input) {
         return arrayLikeToArrayLike(input, new Uint8Array(input.length));
     },
-      "nodebuffer" : identity
+    "nodebuffer": identity
-   };
+};
 
-   /**
+/**
  * Transform an input into any type.
  * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer.
  * If no output type is specified, the unmodified input will be returned.
@@ -1277,7 +1654,7 @@ JSZip.compressions = {
  * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
  * @throws {Error} an Error if the browser doesn't support the requested output type.
  */
-   JSZip.utils.transformTo = function (outputType, input) {
+exports.transformTo = function(outputType, input) {
     if (!input) {
         // undefined, null, etc
         // an empty string won't harm.
@@ -1286,189 +1663,613 @@ JSZip.compressions = {
     if (!outputType) {
         return input;
     }
-      JSZip.utils.checkSupport(outputType);
+    exports.checkSupport(outputType);
-      var inputType = JSZip.utils.getTypeOf(input);
+    var inputType = exports.getTypeOf(input);
     var result = transform[inputType][outputType](input);
     return result;
-   };
+};
 
-   /**
+/**
  * Return the type of the input.
  * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
  * @param {Object} input the input to identify.
  * @return {String} the (lowercase) type of the input.
  */
-   JSZip.utils.getTypeOf = function (input) {
+exports.getTypeOf = function(input) {
     if (typeof input === "string") {
         return "string";
     }
     if (Object.prototype.toString.call(input) === "[object Array]") {
         return "array";
     }
-      if (JSZip.support.nodebuffer && Buffer.isBuffer(input)) {
+    if (support.nodebuffer && nodeBuffer.test(input)) {
         return "nodebuffer";
     }
-      if (JSZip.support.uint8array && input instanceof Uint8Array) {
+    if (support.uint8array && input instanceof Uint8Array) {
         return "uint8array";
     }
-      if (JSZip.support.arraybuffer && input instanceof ArrayBuffer) {
+    if (support.arraybuffer && input instanceof ArrayBuffer) {
         return "arraybuffer";
     }
-   };
+};
 
-   /**
+/**
-    * Cross-window, cross-Node-context regular expression detection
-    * @param  {Object}  object Anything
-    * @return {Boolean}        true if the object is a regular expression,
-    * false otherwise
-    */
-   JSZip.utils.isRegExp = function (object) {
-      return Object.prototype.toString.call(object) === "[object RegExp]";
-   };
-
-   /**
  * Throw an exception if the type is not supported.
  * @param {String} type the type to check.
  * @throws {Error} an Error if the browser doesn't support the requested type.
  */
-   JSZip.utils.checkSupport = function (type) {
+exports.checkSupport = function(type) {
-      var supported = true;
+    var supported = support[type.toLowerCase()];
-      switch (type.toLowerCase()) {
-         case "uint8array":
-            supported = JSZip.support.uint8array;
-         break;
-         case "arraybuffer":
-            supported = JSZip.support.arraybuffer;
-         break;
-         case "nodebuffer":
-            supported = JSZip.support.nodebuffer;
-         break;
-         case "blob":
-            supported = JSZip.support.blob;
-         break;
-      }
     if (!supported) {
         throw new Error(type + " is not supported by this browser");
     }
-   };
+};
-
+exports.MAX_VALUE_16BITS = 65535;
-
+exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1
-})();
-
-(function (){
-   /**
-    * Represents an entry in the zip.
-    * The content may or may not be compressed.
-    * @constructor
-    */
-   JSZip.CompressedObject = function () {
-         this.compressedSize = 0;
-         this.uncompressedSize = 0;
-         this.crc32 = 0;
-         this.compressionMethod = null;
-         this.compressedContent = null;
-   };
-
-   JSZip.CompressedObject.prototype = {
-      /**
-       * Return the decompressed content in an unspecified format.
-       * The format will depend on the decompressor.
-       * @return {Object} the decompressed content.
-       */
-      getContent : function () {
-         return null; // see implementation
-      },
-      /**
-       * Return the compressed content in an unspecified format.
-       * The format will depend on the compressed conten source.
-       * @return {Object} the compressed content.
-       */
-      getCompressedContent : function () {
-         return null; // see implementation
-      }
-   };
-})();
 
 /**
- *
+ * Prettify a string read as binary.
- *  Base64 encode / decode
+ * @param {string} str the string to prettify.
- *  http://www.webtoolkit.info/
+ * @return {string} a pretty string.
- *
+ */
- *  Hacked so that it doesn't utf8 en/decode everything
+exports.pretty = function(str) {
- **/
+    var res = '',
-JSZip.base64 = (function() {
+        code, i;
-   // private property
+    for (i = 0; i < (str || "").length; i++) {
-   var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+        code = str.charCodeAt(i);
+        res += '\\x' + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
+    }
+    return res;
+};
 
-   return {
+/**
-      // public method for encoding
+ * Find a compression registered in JSZip.
-      encode : function(input, utf8) {
+ * @param {string} compressionMethod the method magic to find.
-         var output = "";
+ * @return {Object|null} the JSZip compression object, null if none found.
-         var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+ */
-         var i = 0;
+exports.findCompression = function(compressionMethod) {
+    for (var method in compressions) {
+        if (!compressions.hasOwnProperty(method)) {
+            continue;
+        }
+        if (compressions[method].magic === compressionMethod) {
+            return compressions[method];
+        }
+    }
+    return null;
+};
+/**
+* Cross-window, cross-Node-context regular expression detection
+* @param  {Object}  object Anything
+* @return {Boolean}        true if the object is a regular expression,
+* false otherwise
+*/
+exports.isRegExp = function (object) {
+    return Object.prototype.toString.call(object) === "[object RegExp]";
+};
 
-         while (i < input.length) {
 
-            chr1 = input.charCodeAt(i++);
+},{"./compressions":3,"./nodeBuffer":18,"./support":13}],16:[function(require,module,exports){
-            chr2 = input.charCodeAt(i++);
+'use strict';
-            chr3 = input.charCodeAt(i++);
+var StringReader = require('./stringReader');
+var NodeBufferReader = require('./nodeBufferReader');
+var Uint8ArrayReader = require('./uint8ArrayReader');
+var utils = require('./utils');
+var sig = require('./signature');
+var ZipEntry = require('./zipEntry');
+var support = require('./support');
+//  class ZipEntries {{{
+/**
+ * All the entries in the zip file.
+ * @constructor
+ * @param {String|ArrayBuffer|Uint8Array} data the binary stream to load.
+ * @param {Object} loadOptions Options for loading the stream.
+ */
+function ZipEntries(data, loadOptions) {
+    this.files = [];
+    this.loadOptions = loadOptions;
+    if (data) {
+        this.load(data);
+    }
+}
+ZipEntries.prototype = {
+    /**
+     * Check that the reader is on the speficied signature.
+     * @param {string} expectedSignature the expected signature.
+     * @throws {Error} if it is an other signature.
+     */
+    checkSignature: function(expectedSignature) {
+        var signature = this.reader.readString(4);
+        if (signature !== expectedSignature) {
+            throw new Error("Corrupted zip or bug : unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
+        }
+    },
+    /**
+     * Read the end of the central directory.
+     */
+    readBlockEndOfCentral: function() {
+        this.diskNumber = this.reader.readInt(2);
+        this.diskWithCentralDirStart = this.reader.readInt(2);
+        this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
+        this.centralDirRecords = this.reader.readInt(2);
+        this.centralDirSize = this.reader.readInt(4);
+        this.centralDirOffset = this.reader.readInt(4);
 
-            enc1 = chr1 >> 2;
+        this.zipCommentLength = this.reader.readInt(2);
-            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+        this.zipComment = this.reader.readString(this.zipCommentLength);
-            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+    },
-            enc4 = chr3 & 63;
+    /**
+     * Read the end of the Zip 64 central directory.
+     * Not merged with the method readEndOfCentral :
+     * The end of central can coexist with its Zip64 brother,
+     * I don't want to read the wrong number of bytes !
+     */
+    readBlockZip64EndOfCentral: function() {
+        this.zip64EndOfCentralSize = this.reader.readInt(8);
+        this.versionMadeBy = this.reader.readString(2);
+        this.versionNeeded = this.reader.readInt(2);
+        this.diskNumber = this.reader.readInt(4);
+        this.diskWithCentralDirStart = this.reader.readInt(4);
+        this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
+        this.centralDirRecords = this.reader.readInt(8);
+        this.centralDirSize = this.reader.readInt(8);
+        this.centralDirOffset = this.reader.readInt(8);
 
-            if (isNaN(chr2)) {
+        this.zip64ExtensibleData = {};
-               enc3 = enc4 = 64;
+        var extraDataSize = this.zip64EndOfCentralSize - 44,
-            } else if (isNaN(chr3)) {
+            index = 0,
-               enc4 = 64;
+            extraFieldId,
+            extraFieldLength,
+            extraFieldValue;
+        while (index < extraDataSize) {
+            extraFieldId = this.reader.readInt(2);
+            extraFieldLength = this.reader.readInt(4);
+            extraFieldValue = this.reader.readString(extraFieldLength);
+            this.zip64ExtensibleData[extraFieldId] = {
+                id: extraFieldId,
+                length: extraFieldLength,
+                value: extraFieldValue
+            };
+        }
+    },
+    /**
+     * Read the end of the Zip 64 central directory locator.
+     */
+    readBlockZip64EndOfCentralLocator: function() {
+        this.diskWithZip64CentralDirStart = this.reader.readInt(4);
+        this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
+        this.disksCount = this.reader.readInt(4);
+        if (this.disksCount > 1) {
+            throw new Error("Multi-volumes zip are not supported");
+        }
+    },
+    /**
+     * Read the local files, based on the offset read in the central part.
+     */
+    readLocalFiles: function() {
+        var i, file;
+        for (i = 0; i < this.files.length; i++) {
+            file = this.files[i];
+            this.reader.setIndex(file.localHeaderOffset);
+            this.checkSignature(sig.LOCAL_FILE_HEADER);
+            file.readLocalPart(this.reader);
+            file.handleUTF8();
+        }
+    },
+    /**
+     * Read the central directory.
+     */
+    readCentralDir: function() {
+        var file;
+
+        this.reader.setIndex(this.centralDirOffset);
+        while (this.reader.readString(4) === sig.CENTRAL_FILE_HEADER) {
+            file = new ZipEntry({
+                zip64: this.zip64
+            }, this.loadOptions);
+            file.readCentralPart(this.reader);
+            this.files.push(file);
+        }
+    },
+    /**
+     * Read the end of central directory.
+     */
+    readEndOfCentral: function() {
+        var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
+        if (offset === -1) {
+            throw new Error("Corrupted zip : can't find end of central directory");
+        }
+        this.reader.setIndex(offset);
+        this.checkSignature(sig.CENTRAL_DIRECTORY_END);
+        this.readBlockEndOfCentral();
+
+
+        /* extract from the zip spec :
+            4)  If one of the fields in the end of central directory
+                record is too small to hold required data, the field
+                should be set to -1 (0xFFFF or 0xFFFFFFFF) and the
+                ZIP64 format record should be created.
+            5)  The end of central directory record and the
+                Zip64 end of central directory locator record must
+                reside on the same disk when splitting or spanning
+                an archive.
+         */
+        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) {
+            this.zip64 = true;
+
+            /*
+            Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from
+            the zip file can fit into a 32bits integer. This cannot be solved : Javascript represents
+            all numbers as 64-bit double precision IEEE 754 floating point numbers.
+            So, we have 53bits for integers and bitwise operations treat everything as 32bits.
+            see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators
+            and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5
+            */
+
+            // should look for a zip64 EOCD locator
+            offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
+            if (offset === -1) {
+                throw new Error("Corrupted zip : can't find the ZIP64 end of central directory locator");
+            }
+            this.reader.setIndex(offset);
+            this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
+            this.readBlockZip64EndOfCentralLocator();
+
+            // now the zip64 EOCD record
+            this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
+            this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
+            this.readBlockZip64EndOfCentral();
+        }
+    },
+    prepareReader: function(data) {
+        var type = utils.getTypeOf(data);
+        if (type === "string" && !support.uint8array) {
+            this.reader = new StringReader(data, this.loadOptions.optimizedBinaryString);
+        }
+        else if (type === "nodebuffer") {
+            this.reader = new NodeBufferReader(data);
+        }
+        else {
+            this.reader = new Uint8ArrayReader(utils.transformTo("uint8array", data));
+        }
+    },
+    /**
+     * Read a zip file and create ZipEntries.
+     * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
+     */
+    load: function(data) {
+        this.prepareReader(data);
+        this.readEndOfCentral();
+        this.readCentralDir();
+        this.readLocalFiles();
+    }
+};
+// }}} end of ZipEntries
+module.exports = ZipEntries;
+
+},{"./nodeBufferReader":9,"./signature":11,"./stringReader":12,"./support":13,"./uint8ArrayReader":14,"./utils":15,"./zipEntry":17}],17:[function(require,module,exports){
+'use strict';
+var StringReader = require('./stringReader');
+var utils = require('./utils');
+var CompressedObject = require('./compressedObject');
+var jszipProto = require('./object');
+// class ZipEntry {{{
+/**
+ * An entry in the zip file.
+ * @constructor
+ * @param {Object} options Options of the current file.
+ * @param {Object} loadOptions Options for loading the stream.
+ */
+function ZipEntry(options, loadOptions) {
+    this.options = options;
+    this.loadOptions = loadOptions;
+}
+ZipEntry.prototype = {
+    /**
+     * say if the file is encrypted.
+     * @return {boolean} true if the file is encrypted, false otherwise.
+     */
+    isEncrypted: function() {
+        // bit 1 is set
+        return (this.bitFlag & 0x0001) === 0x0001;
+    },
+    /**
+     * say if the file has utf-8 filename/comment.
+     * @return {boolean} true if the filename/comment is in utf-8, false otherwise.
+     */
+    useUTF8: function() {
+        // bit 11 is set
+        return (this.bitFlag & 0x0800) === 0x0800;
+    },
+    /**
+     * Prepare the function used to generate the compressed content from this ZipFile.
+     * @param {DataReader} reader the reader to use.
+     * @param {number} from the offset from where we should read the data.
+     * @param {number} length the length of the data to read.
+     * @return {Function} the callback to get the compressed content (the type depends of the DataReader class).
+     */
+    prepareCompressedContent: function(reader, from, length) {
+        return function() {
+            var previousIndex = reader.index;
+            reader.setIndex(from);
+            var compressedFileData = reader.readData(length);
+            reader.setIndex(previousIndex);
+
+            return compressedFileData;
+        };
+    },
+    /**
+     * Prepare the function used to generate the uncompressed content from this ZipFile.
+     * @param {DataReader} reader the reader to use.
+     * @param {number} from the offset from where we should read the data.
+     * @param {number} length the length of the data to read.
+     * @param {JSZip.compression} compression the compression used on this file.
+     * @param {number} uncompressedSize the uncompressed size to expect.
+     * @return {Function} the callback to get the uncompressed content (the type depends of the DataReader class).
+     */
+    prepareContent: function(reader, from, length, compression, uncompressedSize) {
+        return function() {
+
+            var compressedFileData = utils.transformTo(compression.uncompressInputType, this.getCompressedContent());
+            var uncompressedFileData = compression.uncompress(compressedFileData);
+
+            if (uncompressedFileData.length !== uncompressedSize) {
+                throw new Error("Bug : uncompressed data size mismatch");
             }
 
-            output = output +
+            return uncompressedFileData;
-               _keyStr.charAt(enc1) + _keyStr.charAt(enc2) +
+        };
-               _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
+    },
+    /**
+     * Read the local part of a zip file and add the info in this object.
+     * @param {DataReader} reader the reader to use.
+     */
+    readLocalPart: function(reader) {
+        var compression, localExtraFieldsLength;
 
+        // we already know everything from the central dir !
+        // If the central dir data are false, we are doomed.
+        // On the bright side, the local part is scary  : zip64, data descriptors, both, etc.
+        // The less data we get here, the more reliable this should be.
+        // Let's skip the whole header and dash to the data !
+        reader.skip(22);
+        // in some zip created on windows, the filename stored in the central dir contains \ instead of /.
+        // Strangely, the filename here is OK.
+        // I would love to treat these zip files as corrupted (see http://www.info-zip.org/FAQ.html#backslashes
+        // or APPNOTE#4.4.17.1, "All slashes MUST be forward slashes '/'") but there are a lot of bad zip generators...
+        // Search "unzip mismatching "local" filename continuing with "central" filename version" on
+        // the internet.
+        //
+        // I think I see the logic here : the central directory is used to display
+        // content and the local directory is used to extract the files. Mixing / and \
+        // may be used to display \ to windows users and use / when extracting the files.
+        // Unfortunately, this lead also to some issues : http://seclists.org/fulldisclosure/2009/Sep/394
+        this.fileNameLength = reader.readInt(2);
+        localExtraFieldsLength = reader.readInt(2); // can't be sure this will be the same as the central dir
+        this.fileName = reader.readString(this.fileNameLength);
+        reader.skip(localExtraFieldsLength);
+
+        if (this.compressedSize == -1 || this.uncompressedSize == -1) {
+            throw new Error("Bug or corrupted zip : didn't get enough informations from the central directory " + "(compressedSize == -1 || uncompressedSize == -1)");
         }
 
-         return output;
+        compression = utils.findCompression(this.compressionMethod);
+        if (compression === null) { // no compression found
+            throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + this.fileName + ")");
+        }
+        this.decompressed = new CompressedObject();
+        this.decompressed.compressedSize = this.compressedSize;
+        this.decompressed.uncompressedSize = this.uncompressedSize;
+        this.decompressed.crc32 = this.crc32;
+        this.decompressed.compressionMethod = this.compressionMethod;
+        this.decompressed.getCompressedContent = this.prepareCompressedContent(reader, reader.index, this.compressedSize, compression);
+        this.decompressed.getContent = this.prepareContent(reader, reader.index, this.compressedSize, compression, this.uncompressedSize);
+
+        // we need to compute the crc32...
+        if (this.loadOptions.checkCRC32) {
+            this.decompressed = utils.transformTo("string", this.decompressed.getContent());
+            if (jszipProto.crc32(this.decompressed) !== this.crc32) {
+                throw new Error("Corrupted zip : CRC32 mismatch");
+            }
+        }
     },
 
-      // public method for decoding
+    /**
-      decode : function(input, utf8) {
+     * Read the central part of a zip file and add the info in this object.
-         var output = "";
+     * @param {DataReader} reader the reader to use.
-         var chr1, chr2, chr3;
+     */
-         var enc1, enc2, enc3, enc4;
+    readCentralPart: function(reader) {
-         var i = 0;
+        this.versionMadeBy = reader.readString(2);
+        this.versionNeeded = reader.readInt(2);
+        this.bitFlag = reader.readInt(2);
+        this.compressionMethod = reader.readString(2);
+        this.date = reader.readDate();
+        this.crc32 = reader.readInt(4);
+        this.compressedSize = reader.readInt(4);
+        this.uncompressedSize = reader.readInt(4);
+        this.fileNameLength = reader.readInt(2);
+        this.extraFieldsLength = reader.readInt(2);
+        this.fileCommentLength = reader.readInt(2);
+        this.diskNumberStart = reader.readInt(2);
+        this.internalFileAttributes = reader.readInt(2);
+        this.externalFileAttributes = reader.readInt(4);
+        this.localHeaderOffset = reader.readInt(4);
 
-         input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+        if (this.isEncrypted()) {
-
+            throw new Error("Encrypted zip are not supported");
-         while (i < input.length) {
-
-            enc1 = _keyStr.indexOf(input.charAt(i++));
-            enc2 = _keyStr.indexOf(input.charAt(i++));
-            enc3 = _keyStr.indexOf(input.charAt(i++));
-            enc4 = _keyStr.indexOf(input.charAt(i++));
-
-            chr1 = (enc1 << 2) | (enc2 >> 4);
-            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
-            chr3 = ((enc3 & 3) << 6) | enc4;
-
-            output = output + String.fromCharCode(chr1);
-
-            if (enc3 != 64) {
-               output = output + String.fromCharCode(chr2);
-            }
-            if (enc4 != 64) {
-               output = output + String.fromCharCode(chr3);
         }
 
+        this.fileName = reader.readString(this.fileNameLength);
+        this.readExtraFields(reader);
+        this.parseZIP64ExtraField(reader);
+        this.fileComment = reader.readString(this.fileCommentLength);
+
+        // warning, this is true only for zip with madeBy == DOS (plateform dependent feature)
+        this.dir = this.externalFileAttributes & 0x00000010 ? true : false;
+    },
+    /**
+     * Parse the ZIP64 extra field and merge the info in the current ZipEntry.
+     * @param {DataReader} reader the reader to use.
+     */
+    parseZIP64ExtraField: function(reader) {
+
+        if (!this.extraFields[0x0001]) {
+            return;
         }
 
-         return output;
+        // should be something, preparing the extra reader
+        var extraReader = new StringReader(this.extraFields[0x0001].value);
 
+        // I really hope that these 64bits integer can fit in 32 bits integer, because js
+        // won't let us have more.
+        if (this.uncompressedSize === utils.MAX_VALUE_32BITS) {
+            this.uncompressedSize = extraReader.readInt(8);
         }
+        if (this.compressedSize === utils.MAX_VALUE_32BITS) {
+            this.compressedSize = extraReader.readInt(8);
+        }
+        if (this.localHeaderOffset === utils.MAX_VALUE_32BITS) {
+            this.localHeaderOffset = extraReader.readInt(8);
+        }
+        if (this.diskNumberStart === utils.MAX_VALUE_32BITS) {
+            this.diskNumberStart = extraReader.readInt(4);
+        }
+    },
+    /**
+     * Read the central part of a zip file and add the info in this object.
+     * @param {DataReader} reader the reader to use.
+     */
+    readExtraFields: function(reader) {
+        var start = reader.index,
+            extraFieldId,
+            extraFieldLength,
+            extraFieldValue;
+
+        this.extraFields = this.extraFields || {};
+
+        while (reader.index < start + this.extraFieldsLength) {
+            extraFieldId = reader.readInt(2);
+            extraFieldLength = reader.readInt(2);
+            extraFieldValue = reader.readString(extraFieldLength);
+
+            this.extraFields[extraFieldId] = {
+                id: extraFieldId,
+                length: extraFieldLength,
+                value: extraFieldValue
             };
-}());
+        }
+    },
+    /**
+     * Apply an UTF8 transformation if needed.
+     */
+    handleUTF8: function() {
+        if (this.useUTF8()) {
+            this.fileName = jszipProto.utf8decode(this.fileName);
+            this.fileComment = jszipProto.utf8decode(this.fileComment);
+        }
+    }
+};
+module.exports = ZipEntry;
 
-// enforcing Stuk's coding style
+},{"./compressedObject":2,"./object":10,"./stringReader":12,"./utils":15}],18:[function(require,module,exports){
-// vim: set shiftwidth=3 softtabstop=3:
+
+},{}],19:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+    var canSetImmediate = typeof window !== 'undefined'
+    && window.setImmediate;
+    var canPost = typeof window !== 'undefined'
+    && window.postMessage && window.addEventListener
+    ;
+
+    if (canSetImmediate) {
+        return function (f) { return window.setImmediate(f) };
+    }
+
+    if (canPost) {
+        var queue = [];
+        window.addEventListener('message', function (ev) {
+            if (ev.source === window && ev.data === 'process-tick') {
+                ev.stopPropagation();
+                if (queue.length > 0) {
+                    var fn = queue.shift();
+                    fn();
+                }
+            }
+        }, true);
+
+        return function nextTick(fn) {
+            queue.push(fn);
+            window.postMessage('process-tick', '*');
+        };
+    }
+
+    return function nextTick(fn) {
+        setTimeout(fn, 0);
+    };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+
+},{}],20:[function(require,module,exports){
+/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var n=void 0,u=!0,aa=this;function ba(e,d){var c=e.split("."),f=aa;!(c[0]in f)&&f.execScript&&f.execScript("var "+c[0]);for(var a;c.length&&(a=c.shift());)!c.length&&d!==n?f[a]=d:f=f[a]?f[a]:f[a]={}};var C="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array;function K(e,d){this.index="number"===typeof d?d:0;this.d=0;this.buffer=e instanceof(C?Uint8Array:Array)?e:new (C?Uint8Array:Array)(32768);if(2*this.buffer.length<=this.index)throw Error("invalid index");this.buffer.length<=this.index&&ca(this)}function ca(e){var d=e.buffer,c,f=d.length,a=new (C?Uint8Array:Array)(f<<1);if(C)a.set(d);else for(c=0;c<f;++c)a[c]=d[c];return e.buffer=a}
+K.prototype.a=function(e,d,c){var f=this.buffer,a=this.index,b=this.d,k=f[a],m;c&&1<d&&(e=8<d?(L[e&255]<<24|L[e>>>8&255]<<16|L[e>>>16&255]<<8|L[e>>>24&255])>>32-d:L[e]>>8-d);if(8>d+b)k=k<<d|e,b+=d;else for(m=0;m<d;++m)k=k<<1|e>>d-m-1&1,8===++b&&(b=0,f[a++]=L[k],k=0,a===f.length&&(f=ca(this)));f[a]=k;this.buffer=f;this.d=b;this.index=a};K.prototype.finish=function(){var e=this.buffer,d=this.index,c;0<this.d&&(e[d]<<=8-this.d,e[d]=L[e[d]],d++);C?c=e.subarray(0,d):(e.length=d,c=e);return c};
+var ga=new (C?Uint8Array:Array)(256),M;for(M=0;256>M;++M){for(var R=M,S=R,ha=7,R=R>>>1;R;R>>>=1)S<<=1,S|=R&1,--ha;ga[M]=(S<<ha&255)>>>0}var L=ga;function ja(e){this.buffer=new (C?Uint16Array:Array)(2*e);this.length=0}ja.prototype.getParent=function(e){return 2*((e-2)/4|0)};ja.prototype.push=function(e,d){var c,f,a=this.buffer,b;c=this.length;a[this.length++]=d;for(a[this.length++]=e;0<c;)if(f=this.getParent(c),a[c]>a[f])b=a[c],a[c]=a[f],a[f]=b,b=a[c+1],a[c+1]=a[f+1],a[f+1]=b,c=f;else break;return this.length};
+ja.prototype.pop=function(){var e,d,c=this.buffer,f,a,b;d=c[0];e=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(b=0;;){a=2*b+2;if(a>=this.length)break;a+2<this.length&&c[a+2]>c[a]&&(a+=2);if(c[a]>c[b])f=c[b],c[b]=c[a],c[a]=f,f=c[b+1],c[b+1]=c[a+1],c[a+1]=f;else break;b=a}return{index:e,value:d,length:this.length}};function ka(e,d){this.e=ma;this.f=0;this.input=C&&e instanceof Array?new Uint8Array(e):e;this.c=0;d&&(d.lazy&&(this.f=d.lazy),"number"===typeof d.compressionType&&(this.e=d.compressionType),d.outputBuffer&&(this.b=C&&d.outputBuffer instanceof Array?new Uint8Array(d.outputBuffer):d.outputBuffer),"number"===typeof d.outputIndex&&(this.c=d.outputIndex));this.b||(this.b=new (C?Uint8Array:Array)(32768))}var ma=2,T=[],U;
+for(U=0;288>U;U++)switch(u){case 143>=U:T.push([U+48,8]);break;case 255>=U:T.push([U-144+400,9]);break;case 279>=U:T.push([U-256+0,7]);break;case 287>=U:T.push([U-280+192,8]);break;default:throw"invalid literal: "+U;}
+ka.prototype.h=function(){var e,d,c,f,a=this.input;switch(this.e){case 0:c=0;for(f=a.length;c<f;){d=C?a.subarray(c,c+65535):a.slice(c,c+65535);c+=d.length;var b=d,k=c===f,m=n,g=n,p=n,v=n,x=n,l=this.b,h=this.c;if(C){for(l=new Uint8Array(this.b.buffer);l.length<=h+b.length+5;)l=new Uint8Array(l.length<<1);l.set(this.b)}m=k?1:0;l[h++]=m|0;g=b.length;p=~g+65536&65535;l[h++]=g&255;l[h++]=g>>>8&255;l[h++]=p&255;l[h++]=p>>>8&255;if(C)l.set(b,h),h+=b.length,l=l.subarray(0,h);else{v=0;for(x=b.length;v<x;++v)l[h++]=
+b[v];l.length=h}this.c=h;this.b=l}break;case 1:var q=new K(C?new Uint8Array(this.b.buffer):this.b,this.c);q.a(1,1,u);q.a(1,2,u);var t=na(this,a),w,da,z;w=0;for(da=t.length;w<da;w++)if(z=t[w],K.prototype.a.apply(q,T[z]),256<z)q.a(t[++w],t[++w],u),q.a(t[++w],5),q.a(t[++w],t[++w],u);else if(256===z)break;this.b=q.finish();this.c=this.b.length;break;case ma:var B=new K(C?new Uint8Array(this.b.buffer):this.b,this.c),ra,J,N,O,P,Ia=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],W,sa,X,ta,ea,ia=Array(19),
+ua,Q,fa,y,va;ra=ma;B.a(1,1,u);B.a(ra,2,u);J=na(this,a);W=oa(this.j,15);sa=pa(W);X=oa(this.i,7);ta=pa(X);for(N=286;257<N&&0===W[N-1];N--);for(O=30;1<O&&0===X[O-1];O--);var wa=N,xa=O,F=new (C?Uint32Array:Array)(wa+xa),r,G,s,Y,E=new (C?Uint32Array:Array)(316),D,A,H=new (C?Uint8Array:Array)(19);for(r=G=0;r<wa;r++)F[G++]=W[r];for(r=0;r<xa;r++)F[G++]=X[r];if(!C){r=0;for(Y=H.length;r<Y;++r)H[r]=0}r=D=0;for(Y=F.length;r<Y;r+=G){for(G=1;r+G<Y&&F[r+G]===F[r];++G);s=G;if(0===F[r])if(3>s)for(;0<s--;)E[D++]=0,
+H[0]++;else for(;0<s;)A=138>s?s:138,A>s-3&&A<s&&(A=s-3),10>=A?(E[D++]=17,E[D++]=A-3,H[17]++):(E[D++]=18,E[D++]=A-11,H[18]++),s-=A;else if(E[D++]=F[r],H[F[r]]++,s--,3>s)for(;0<s--;)E[D++]=F[r],H[F[r]]++;else for(;0<s;)A=6>s?s:6,A>s-3&&A<s&&(A=s-3),E[D++]=16,E[D++]=A-3,H[16]++,s-=A}e=C?E.subarray(0,D):E.slice(0,D);ea=oa(H,7);for(y=0;19>y;y++)ia[y]=ea[Ia[y]];for(P=19;4<P&&0===ia[P-1];P--);ua=pa(ea);B.a(N-257,5,u);B.a(O-1,5,u);B.a(P-4,4,u);for(y=0;y<P;y++)B.a(ia[y],3,u);y=0;for(va=e.length;y<va;y++)if(Q=
+e[y],B.a(ua[Q],ea[Q],u),16<=Q){y++;switch(Q){case 16:fa=2;break;case 17:fa=3;break;case 18:fa=7;break;default:throw"invalid code: "+Q;}B.a(e[y],fa,u)}var ya=[sa,W],za=[ta,X],I,Aa,Z,la,Ba,Ca,Da,Ea;Ba=ya[0];Ca=ya[1];Da=za[0];Ea=za[1];I=0;for(Aa=J.length;I<Aa;++I)if(Z=J[I],B.a(Ba[Z],Ca[Z],u),256<Z)B.a(J[++I],J[++I],u),la=J[++I],B.a(Da[la],Ea[la],u),B.a(J[++I],J[++I],u);else if(256===Z)break;this.b=B.finish();this.c=this.b.length;break;default:throw"invalid compression type";}return this.b};
+function qa(e,d){this.length=e;this.g=d}
+var Fa=function(){function e(a){switch(u){case 3===a:return[257,a-3,0];case 4===a:return[258,a-4,0];case 5===a:return[259,a-5,0];case 6===a:return[260,a-6,0];case 7===a:return[261,a-7,0];case 8===a:return[262,a-8,0];case 9===a:return[263,a-9,0];case 10===a:return[264,a-10,0];case 12>=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272,
+a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:throw"invalid length: "+a;}}var d=[],c,f;for(c=3;258>=c;c++)f=e(c),d[c]=f[2]<<24|
+f[1]<<16|f[0];return d}(),Ga=C?new Uint32Array(Fa):Fa;
+function na(e,d){function c(a,c){var b=a.g,d=[],f=0,e;e=Ga[a.length];d[f++]=e&65535;d[f++]=e>>16&255;d[f++]=e>>24;var g;switch(u){case 1===b:g=[0,b-1,0];break;case 2===b:g=[1,b-2,0];break;case 3===b:g=[2,b-3,0];break;case 4===b:g=[3,b-4,0];break;case 6>=b:g=[4,b-5,1];break;case 8>=b:g=[5,b-7,1];break;case 12>=b:g=[6,b-9,2];break;case 16>=b:g=[7,b-13,2];break;case 24>=b:g=[8,b-17,3];break;case 32>=b:g=[9,b-25,3];break;case 48>=b:g=[10,b-33,4];break;case 64>=b:g=[11,b-49,4];break;case 96>=b:g=[12,b-
+65,5];break;case 128>=b:g=[13,b-97,5];break;case 192>=b:g=[14,b-129,6];break;case 256>=b:g=[15,b-193,6];break;case 384>=b:g=[16,b-257,7];break;case 512>=b:g=[17,b-385,7];break;case 768>=b:g=[18,b-513,8];break;case 1024>=b:g=[19,b-769,8];break;case 1536>=b:g=[20,b-1025,9];break;case 2048>=b:g=[21,b-1537,9];break;case 3072>=b:g=[22,b-2049,10];break;case 4096>=b:g=[23,b-3073,10];break;case 6144>=b:g=[24,b-4097,11];break;case 8192>=b:g=[25,b-6145,11];break;case 12288>=b:g=[26,b-8193,12];break;case 16384>=
+b:g=[27,b-12289,12];break;case 24576>=b:g=[28,b-16385,13];break;case 32768>=b:g=[29,b-24577,13];break;default:throw"invalid distance";}e=g;d[f++]=e[0];d[f++]=e[1];d[f++]=e[2];var k,m;k=0;for(m=d.length;k<m;++k)l[h++]=d[k];t[d[0]]++;w[d[3]]++;q=a.length+c-1;x=null}var f,a,b,k,m,g={},p,v,x,l=C?new Uint16Array(2*d.length):[],h=0,q=0,t=new (C?Uint32Array:Array)(286),w=new (C?Uint32Array:Array)(30),da=e.f,z;if(!C){for(b=0;285>=b;)t[b++]=0;for(b=0;29>=b;)w[b++]=0}t[256]=1;f=0;for(a=d.length;f<a;++f){b=
+m=0;for(k=3;b<k&&f+b!==a;++b)m=m<<8|d[f+b];g[m]===n&&(g[m]=[]);p=g[m];if(!(0<q--)){for(;0<p.length&&32768<f-p[0];)p.shift();if(f+3>=a){x&&c(x,-1);b=0;for(k=a-f;b<k;++b)z=d[f+b],l[h++]=z,++t[z];break}0<p.length?(v=Ha(d,f,p),x?x.length<v.length?(z=d[f-1],l[h++]=z,++t[z],c(v,0)):c(x,-1):v.length<da?x=v:c(v,0)):x?c(x,-1):(z=d[f],l[h++]=z,++t[z])}p.push(f)}l[h++]=256;t[256]++;e.j=t;e.i=w;return C?l.subarray(0,h):l}
+function Ha(e,d,c){var f,a,b=0,k,m,g,p,v=e.length;m=0;p=c.length;a:for(;m<p;m++){f=c[p-m-1];k=3;if(3<b){for(g=b;3<g;g--)if(e[f+g-1]!==e[d+g-1])continue a;k=b}for(;258>k&&d+k<v&&e[f+k]===e[d+k];)++k;k>b&&(a=f,b=k);if(258===k)break}return new qa(b,d-a)}
+function oa(e,d){var c=e.length,f=new ja(572),a=new (C?Uint8Array:Array)(c),b,k,m,g,p;if(!C)for(g=0;g<c;g++)a[g]=0;for(g=0;g<c;++g)0<e[g]&&f.push(g,e[g]);b=Array(f.length/2);k=new (C?Uint32Array:Array)(f.length/2);if(1===b.length)return a[f.pop().index]=1,a;g=0;for(p=f.length/2;g<p;++g)b[g]=f.pop(),k[g]=b[g].value;m=Ja(k,k.length,d);g=0;for(p=b.length;g<p;++g)a[b[g].index]=m[g];return a}
+function Ja(e,d,c){function f(a){var b=g[a][p[a]];b===d?(f(a+1),f(a+1)):--k[b];++p[a]}var a=new (C?Uint16Array:Array)(c),b=new (C?Uint8Array:Array)(c),k=new (C?Uint8Array:Array)(d),m=Array(c),g=Array(c),p=Array(c),v=(1<<c)-d,x=1<<c-1,l,h,q,t,w;a[c-1]=d;for(h=0;h<c;++h)v<x?b[h]=0:(b[h]=1,v-=x),v<<=1,a[c-2-h]=(a[c-1-h]/2|0)+d;a[0]=b[0];m[0]=Array(a[0]);g[0]=Array(a[0]);for(h=1;h<c;++h)a[h]>2*a[h-1]+b[h]&&(a[h]=2*a[h-1]+b[h]),m[h]=Array(a[h]),g[h]=Array(a[h]);for(l=0;l<d;++l)k[l]=c;for(q=0;q<a[c-1];++q)m[c-
+1][q]=e[q],g[c-1][q]=q;for(l=0;l<c;++l)p[l]=0;1===b[c-1]&&(--k[0],++p[c-1]);for(h=c-2;0<=h;--h){t=l=0;w=p[h+1];for(q=0;q<a[h];q++)t=m[h+1][w]+m[h+1][w+1],t>e[l]?(m[h][q]=t,g[h][q]=d,w+=2):(m[h][q]=e[l],g[h][q]=l,++l);p[h]=0;1===b[h]&&f(h)}return k}
+function pa(e){var d=new (C?Uint16Array:Array)(e.length),c=[],f=[],a=0,b,k,m,g;b=0;for(k=e.length;b<k;b++)c[e[b]]=(c[e[b]]|0)+1;b=1;for(k=16;b<=k;b++)f[b]=a,a+=c[b]|0,a<<=1;b=0;for(k=e.length;b<k;b++){a=f[e[b]];f[e[b]]+=1;m=d[b]=0;for(g=e[b];m<g;m++)d[b]=d[b]<<1|a&1,a>>>=1}return d};ba("Zlib.RawDeflate",ka);ba("Zlib.RawDeflate.prototype.compress",ka.prototype.h);var Ka={NONE:0,FIXED:1,DYNAMIC:ma},V,La,$,Ma;if(Object.keys)V=Object.keys(Ka);else for(La in V=[],$=0,Ka)V[$++]=La;$=0;for(Ma=V.length;$<Ma;++$)La=V[$],ba("Zlib.RawDeflate.CompressionType."+La,Ka[La]);}).call(this); //@ sourceMappingURL=rawdeflate.min.js.map
+
+},{}],21:[function(require,module,exports){
+/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var l=void 0,p=this;function q(c,d){var a=c.split("."),b=p;!(a[0]in b)&&b.execScript&&b.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)!a.length&&d!==l?b[e]=d:b=b[e]?b[e]:b[e]={}};var r="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array;function u(c){var d=c.length,a=0,b=Number.POSITIVE_INFINITY,e,f,g,h,k,m,s,n,t;for(n=0;n<d;++n)c[n]>a&&(a=c[n]),c[n]<b&&(b=c[n]);e=1<<a;f=new (r?Uint32Array:Array)(e);g=1;h=0;for(k=2;g<=a;){for(n=0;n<d;++n)if(c[n]===g){m=0;s=h;for(t=0;t<g;++t)m=m<<1|s&1,s>>=1;for(t=m;t<e;t+=k)f[t]=g<<16|n;++h}++g;h<<=1;k<<=1}return[f,a,b]};function v(c,d){this.g=[];this.h=32768;this.c=this.f=this.d=this.k=0;this.input=r?new Uint8Array(c):c;this.l=!1;this.i=w;this.p=!1;if(d||!(d={}))d.index&&(this.d=d.index),d.bufferSize&&(this.h=d.bufferSize),d.bufferType&&(this.i=d.bufferType),d.resize&&(this.p=d.resize);switch(this.i){case x:this.a=32768;this.b=new (r?Uint8Array:Array)(32768+this.h+258);break;case w:this.a=0;this.b=new (r?Uint8Array:Array)(this.h);this.e=this.u;this.m=this.r;this.j=this.s;break;default:throw Error("invalid inflate mode");
+}}var x=0,w=1;
+v.prototype.t=function(){for(;!this.l;){var c=y(this,3);c&1&&(this.l=!0);c>>>=1;switch(c){case 0:var d=this.input,a=this.d,b=this.b,e=this.a,f=l,g=l,h=l,k=b.length,m=l;this.c=this.f=0;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: LEN (first byte)");g=f;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: LEN (second byte)");g|=f<<8;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: NLEN (first byte)");h=f;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: NLEN (second byte)");h|=
+f<<8;if(g===~h)throw Error("invalid uncompressed block header: length verify");if(a+g>d.length)throw Error("input buffer is broken");switch(this.i){case x:for(;e+g>b.length;){m=k-e;g-=m;if(r)b.set(d.subarray(a,a+m),e),e+=m,a+=m;else for(;m--;)b[e++]=d[a++];this.a=e;b=this.e();e=this.a}break;case w:for(;e+g>b.length;)b=this.e({o:2});break;default:throw Error("invalid inflate mode");}if(r)b.set(d.subarray(a,a+g),e),e+=g,a+=g;else for(;g--;)b[e++]=d[a++];this.d=a;this.a=e;this.b=b;break;case 1:this.j(z,
+A);break;case 2:B(this);break;default:throw Error("unknown BTYPE: "+c);}}return this.m()};
+var C=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],D=r?new Uint16Array(C):C,E=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258],F=r?new Uint16Array(E):E,G=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0],H=r?new Uint8Array(G):G,I=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],J=r?new Uint16Array(I):I,K=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,
+13],L=r?new Uint8Array(K):K,M=new (r?Uint8Array:Array)(288),N,O;N=0;for(O=M.length;N<O;++N)M[N]=143>=N?8:255>=N?9:279>=N?7:8;var z=u(M),P=new (r?Uint8Array:Array)(30),Q,R;Q=0;for(R=P.length;Q<R;++Q)P[Q]=5;var A=u(P);function y(c,d){for(var a=c.f,b=c.c,e=c.input,f=c.d,g;b<d;){g=e[f++];if(g===l)throw Error("input buffer is broken");a|=g<<b;b+=8}g=a&(1<<d)-1;c.f=a>>>d;c.c=b-d;c.d=f;return g}
+function S(c,d){for(var a=c.f,b=c.c,e=c.input,f=c.d,g=d[0],h=d[1],k,m,s;b<h;){k=e[f++];if(k===l)break;a|=k<<b;b+=8}m=g[a&(1<<h)-1];s=m>>>16;c.f=a>>s;c.c=b-s;c.d=f;return m&65535}
+function B(c){function d(a,c,b){var d,f,e,g;for(g=0;g<a;)switch(d=S(this,c),d){case 16:for(e=3+y(this,2);e--;)b[g++]=f;break;case 17:for(e=3+y(this,3);e--;)b[g++]=0;f=0;break;case 18:for(e=11+y(this,7);e--;)b[g++]=0;f=0;break;default:f=b[g++]=d}return b}var a=y(c,5)+257,b=y(c,5)+1,e=y(c,4)+4,f=new (r?Uint8Array:Array)(D.length),g,h,k,m;for(m=0;m<e;++m)f[D[m]]=y(c,3);g=u(f);h=new (r?Uint8Array:Array)(a);k=new (r?Uint8Array:Array)(b);c.j(u(d.call(c,a,g,h)),u(d.call(c,b,g,k)))}
+v.prototype.j=function(c,d){var a=this.b,b=this.a;this.n=c;for(var e=a.length-258,f,g,h,k;256!==(f=S(this,c));)if(256>f)b>=e&&(this.a=b,a=this.e(),b=this.a),a[b++]=f;else{g=f-257;k=F[g];0<H[g]&&(k+=y(this,H[g]));f=S(this,d);h=J[f];0<L[f]&&(h+=y(this,L[f]));b>=e&&(this.a=b,a=this.e(),b=this.a);for(;k--;)a[b]=a[b++-h]}for(;8<=this.c;)this.c-=8,this.d--;this.a=b};
+v.prototype.s=function(c,d){var a=this.b,b=this.a;this.n=c;for(var e=a.length,f,g,h,k;256!==(f=S(this,c));)if(256>f)b>=e&&(a=this.e(),e=a.length),a[b++]=f;else{g=f-257;k=F[g];0<H[g]&&(k+=y(this,H[g]));f=S(this,d);h=J[f];0<L[f]&&(h+=y(this,L[f]));b+k>e&&(a=this.e(),e=a.length);for(;k--;)a[b]=a[b++-h]}for(;8<=this.c;)this.c-=8,this.d--;this.a=b};
+v.prototype.e=function(){var c=new (r?Uint8Array:Array)(this.a-32768),d=this.a-32768,a,b,e=this.b;if(r)c.set(e.subarray(32768,c.length));else{a=0;for(b=c.length;a<b;++a)c[a]=e[a+32768]}this.g.push(c);this.k+=c.length;if(r)e.set(e.subarray(d,d+32768));else for(a=0;32768>a;++a)e[a]=e[d+a];this.a=32768;return e};
+v.prototype.u=function(c){var d,a=this.input.length/this.d+1|0,b,e,f,g=this.input,h=this.b;c&&("number"===typeof c.o&&(a=c.o),"number"===typeof c.q&&(a+=c.q));2>a?(b=(g.length-this.d)/this.n[2],f=258*(b/2)|0,e=f<h.length?h.length+f:h.length<<1):e=h.length*a;r?(d=new Uint8Array(e),d.set(h)):d=h;return this.b=d};
+v.prototype.m=function(){var c=0,d=this.b,a=this.g,b,e=new (r?Uint8Array:Array)(this.k+(this.a-32768)),f,g,h,k;if(0===a.length)return r?this.b.subarray(32768,this.a):this.b.slice(32768,this.a);f=0;for(g=a.length;f<g;++f){b=a[f];h=0;for(k=b.length;h<k;++h)e[c++]=b[h]}f=32768;for(g=this.a;f<g;++f)e[c++]=d[f];this.g=[];return this.buffer=e};
+v.prototype.r=function(){var c,d=this.a;r?this.p?(c=new Uint8Array(d),c.set(this.b.subarray(0,d))):c=this.b.subarray(0,d):(this.b.length>d&&(this.b.length=d),c=this.b);return this.buffer=c};q("Zlib.RawInflate",v);q("Zlib.RawInflate.prototype.decompress",v.prototype.t);var T={ADAPTIVE:w,BLOCK:x},U,V,W,X;if(Object.keys)U=Object.keys(T);else for(V in U=[],W=0,T)U[W++]=V;W=0;for(X=U.length;W<X;++W)V=U[W],q("Zlib.RawInflate.BufferType."+V,T[V]);}).call(this); //@ sourceMappingURL=rawinflate.min.js.map
+
+},{}]},{},[7])
+(7)
+});
+;