/**

 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.

 Usage:

    zip = new JSZip();

    zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing");

    zip.folder("images").file("smile.gif", base64Data, {base64: true});

    zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")});

    zip.remove("tempfile");

    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 {Object=} options the options for creating this objects (optional).

  */

 var JSZip = function(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);

    }

 };

 JSZip.signature = {

    LOCAL_FILE_HEADER : "\x50\x4b\x03\x04",

    CENTRAL_FILE_HEADER : "\x50\x4b\x01\x02",

    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

 JSZip.defaults = {

    base64: false,

    binary: false,

    dir: false,

    date: null,

    compression: null

 };

 /*

  * List features that require a modern browser, and if the current browser support them.

  */

 JSZip.support = {

    // contains true if JSZip can read/generate ArrayBuffer, false otherwise.

    arraybuffer : (function(){

       return typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";

    })(),

    // 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;

    })()

 };

 JSZip.prototype = (function () {

    var textEncoder, textDecoder;

    if (

       JSZip.support.uint8array &&

       typeof TextEncoder === "function" &&

       typeof TextDecoder === "function"

    ) {

       textEncoder = new TextEncoder("utf-8");

       textDecoder = new TextDecoder("utf-8");

    }

    /**

     * 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) {

          file._data = file._data.getContent();

          file.options.binary = true;

          file.options.base64 = false;

          if (JSZip.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).

             file._data = new Uint8Array(copy.length);

             // with an empty Uint8Array, Opera fails with a "Offset larger than array size"

             if (copy.length !== 0) {

                file._data.set(copy, 0);

             }

          }

       }

       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 result = getRawData(file), type = JSZip.utils.getTypeOf(result);

       if (type === "string") {

          if (!file.options.binary) {

             // unicode text !

             // unicode string => binary string is a painful process, check if we can avoid it.

             if (textEncoder) {

                return textEncoder.encode(result);

             }

             if (JSZip.support.nodebuffer) {

                return new Buffer(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 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);

       }

       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);

       } else {

          // no utf8 transformation, do the array => string step.

          result = JSZip.utils.transformTo("string", result);

       }

       if (!asUTF8 && !this.options.binary) {

          result = JSZip.prototype.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) {

       this.name = name;

       this._data = data;

       this.options = options;

    };

    ZipObject.prototype = {

       /**

        * Return the content as UTF8 string.

        * @return {string} the UTF8 string.

        */

       asText : function () {

          return dataToString.call(this, true);

       },

       /**

        * Returns the binary content.

        * @return {string} the content as binary.

        */

       asBinary : function () {

          return dataToString.call(this, false);

       },

       /**

        * Returns the content as a nodejs Buffer.

        * @return {Buffer} the content as a Buffer.

        */

       asNodeBuffer : function () {

          var result = getBinaryData(this);

          return JSZip.utils.transformTo("nodebuffer", result);

       },

       /**

        * Returns the content as an Uint8Array.

        * @return {Uint8Array} the content as an Uint8Array.

        */

       asUint8Array : function () {

          var result = getBinaryData(this);

          return JSZip.utils.transformTo("uint8array", result);

       },

       /**

        * Returns the content as an ArrayBuffer.

        * @return {ArrayBuffer} the content as an ArrayBufer.

        */

       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 hex = "", i;

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

          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 result = {}, i, attr;

       for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers

          for (attr in arguments[i]) {

             if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {

                result[attr] = arguments[i][attr];

             }

          }

       }

       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) {

       o = o || {};

       /*jshint -W041 */

       if (o.base64 === true && o.binary == null) {

          o.binary = true;

       }

       /*jshint +W041 */

       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

     * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file

     * @param {Object} o the options of the file

     * @return {Object} the new file.

     */

    var fileAdd = function (name, data, o) {

       // be sure sub folders exist

       var parent = parentFolder(name), dataType = JSZip.utils.getTypeOf(data);

       if (parent) {

          folderAdd.call(this, parent);

       }

       o = prepareFileAttrs(o);

       if (o.dir || data === null || typeof data === "undefined") {

          o.base64 = false;

          o.binary = false;

          data = null;

       } 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);

             }

          }

       } else { // arraybuffer, uint8array, ...

          o.base64 = false;

          o.binary = true;

          if (!dataType && !(data instanceof JSZip.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);

          }

       }

       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) {

       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) {

       // Check the name ends with a /

       if (name.slice(-1) != "/") {

          name += "/"; // IE doesn't like substr(-1)

       }

       // Does this folder already exist?

       if (!this.files[name]) {

          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 result = new JSZip.CompressedObject(), content;

       // the data has not been decompressed, we might reuse things !

       if (file._data instanceof JSZip.CompressedObject) {

          result.uncompressedSize = file._data.uncompressedSize;

          result.crc32 = file._data.crc32;

          if (result.uncompressedSize === 0 || file.options.dir) {

             compression = JSZip.compressions['STORE'];

             result.compressedContent = "";

             result.crc32 = 0;

          } else if (file._data.compressionMethod === compression.magic) {

             result.compressedContent = file._data.getCompressedContent();

          } else {

             content = file._data.getContent();

             // need to decompress / recompress

             result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content));

          }

       } else {

          // have uncompressed data

          content = getBinaryData(file);

          if (!content || content.length === 0 || file.options.dir) {

             compression = JSZip.compressions['STORE'];

             content = "";

          }

          result.uncompressedSize = content.length;

          result.crc32 = this.crc32(content);

          result.compressedContent = compression.compress(JSZip.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.

     * @param {JSZip.CompressedObject} compressedObject the compressed object.

     * @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 data = compressedObject.compressedContent,

           utfEncodedFileName = this.utf8encode(file.name),

           useUTF8 = utfEncodedFileName !== file.name,

           o       = file.options,

           dosTime,

           dosDate;

       // date

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

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

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

       dosTime = o.date.getHours();

       dosTime = dosTime << 6;

       dosTime = dosTime | o.date.getMinutes();

       dosTime = dosTime << 5;

       dosTime = dosTime | o.date.getSeconds() / 2;

       dosDate = o.date.getFullYear() - 1980;

       dosDate = dosDate << 4;

       dosDate = dosDate | (o.date.getMonth() + 1);

       dosDate = dosDate << 5;

       dosDate = dosDate | o.date.getDate();

       var header = "";

       // version needed to extract

       header += "\x0A\x00";

       // general purpose bit flag

       // set bit 11 if utf8

       header += useUTF8 ? "\x00\x08" : "\x00\x00";

       // compression method

       header += compressedObject.compressionMethod;

       // last mod file time

       header += decToHex(dosTime, 2);

       // last mod file date

       header += decToHex(dosDate, 2);

       // crc-32

       header += decToHex(compressedObject.crc32, 4);

       // compressed size

       header += decToHex(compressedObject.compressedSize, 4);

       // uncompressed size

       header += decToHex(compressedObject.uncompressedSize, 4);

       // file name length

       header += decToHex(utfEncodedFileName.length, 2);

       // extra field length

       header += "\x00\x00";

       var fileRecord = JSZip.signature.LOCAL_FILE_HEADER + header + utfEncodedFileName;

       var dirRecord = JSZip.signature.CENTRAL_FILE_HEADER +

       // version made by (00: DOS)

       "\x14\x00" +

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

       header +

       // file comment length

       "\x00\x00" +

       // disk number start

       "\x00\x00" +

       // internal file attributes TODO

       "\x00\x00" +

       // external file attributes

       (file.options.dir===true?"\x10\x00\x00\x00":"\x00\x00\x00\x00")+

       // relative offset of local header

       decToHex(offset, 4) +

       // file name

       utfEncodedFileName;

       return {

          fileRecord : fileRecord,

          dirRecord : dirRecord,

          compressedObject : compressedObject

       };

    };

    /**

     * An object to write any content to a string.

     * @constructor

     */

    var StringWriter = function () {

       this.data = [];

    };

    StringWriter.prototype = {

       /**

        * Append any content to the current string.

        * @param {Object} input the content to add.

        */

       append : function (input) {

          input = JSZip.utils.transformTo("string", input);

          this.data.push(input);

       },

       /**

        * Finalize the construction an return the result.

        * @return {string} the generated string.

        */

       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) {

       this.data = new Uint8Array(length);

       this.index = 0;

    };

    Uint8ArrayWriter.prototype = {

       /**

        * Append any content to the current array.

        * @param {Object} input the content to add.

        */

       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);

             this.data.set(input, this.index);

             this.index += input.length;

          }

       },

       /**

        * Finalize the construction an return the result.

        * @return {Uint8Array} the generated array.

        */

       finalize : function () {

          return this.data;

       }

    };

    // return the actual prototype of JSZip

    return {

       /**

        * 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.

        * @param {String|ArrayBuffer|Uint8Array|Buffer} stream  The stream to load

        * @param {Object} options Options for loading the stream.

        *  options.base64 : is the stream in base64 ? default : false

        * @return {JSZip} the current JSZip object

        */

       load : function (stream, options) {

          throw new Error("Load method is not defined. Is the file jszip-load.js included ?");

       },

       /**

        * Filter nested files/folders with the specified function.

        * @param {Function} search the predicate to use :

        * function (relativePath, file) {...}

        * It takes 2 arguments : the relative path and the file.

        * @return {Array} An array of matching elements.

        */

       filter : function (search) {

          var result = [], filename, relativePath, file, fileClone;

          for (filename in this.files) {

             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));

             relativePath = filename.slice(this.root.length, filename.length);

             if (filename.slice(0, this.root.length) === this.root && // the file is in the current root

                 search(relativePath, fileClone)) { // and the file matches the function

                result.push(fileClone);

             }

          }

          return result;

       },

       /**

        * Add a file to the zip file, or search a file.

        * @param   {string|RegExp} name The name of the file to add (if data is defined),

        * the name of the file to find (if no data) or a regex to match files.

        * @param   {String|ArrayBuffer|Uint8Array|Buffer} data  The file data, either raw or base64 encoded

        * @param   {Object} o     File options

        * @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) {

          if (arguments.length === 1) {

             if (JSZip.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 !

             name = this.root+name;

             fileAdd.call(this, name, data, o);

          }

          return this;

       },

       /**

        * Add a directory to the zip file, or search.

        * @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) {

          if (!arg) {

             return this;

          }

          if (JSZip.utils.isRegExp(arg)) {

             return this.filter(function(relativePath, file) {

                return file.options.dir && arg.test(relativePath);

             });

          }

          // else, name is a new folder

          var name = this.root + arg;

          var newFolder = folderAdd.call(this, name);

          // Allow chaining by returning a new object with this folder as the root

          var ret = this.clone();

          ret.root = newFolder.name;

          return ret;

       },

       /**

        * Delete a file, or a directory and all sub-files, from the zip

        * @param {string} name the name of the file to delete

        * @return {JSZip} this JSZip object

        */

       remove : function(name) {

          name = this.root + name;

          var file = this.files[name];

          if (!file) {

             // Look for any folders

             if (name.slice(-1) != "/") {

                name += "/";

             }

             file = this.files[name];

          }

          if (file) {

             if (!file.options.dir) {

                // file

                delete this.files[name];

             } else {

                // folder

                var kids = this.filter(function (relativePath, file) {

                   return file.name.slice(0, name.length) === name;

                });

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

                   delete this.files[kids[i].name];

                }

             }

          }

          return this;

       },

       /**

        * Generate the complete zip file

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

        * - base64, (deprecated, use type instead) true to generate base64.

        * - compression, "STORE" by default.

        * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.

        * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file

        */

       generate : function(options) {

          options = extend(options || {}, {

             base64 : true,

             compression : "STORE",

             type : "base64"

          });

          JSZip.utils.checkSupport(options.type);

          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; }

             var file = this.files[name];

             var compressionName = file.options.compression || options.compression.toUpperCase();

             var compression = JSZip.compressions[compressionName];

             if (!compression) {

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

             }

             var compressedObject = generateCompressedObjectFrom.call(this, file, compression);

             var zipPart = generateZipParts.call(this, name, file, compressedObject, localDirLength);

             localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize;

             centralDirLength += zipPart.dirRecord.length;

             zipData.push(zipPart);

          }

          var dirEnd = "";

          // end of central dir signature

          dirEnd = JSZip.signature.CENTRAL_DIRECTORY_END +

          // number of this disk

          "\x00\x00" +

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

          "\x00\x00" +

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

          decToHex(zipData.length, 2) +

          // total number of entries in the central directory

          decToHex(zipData.length, 2) +

          // size of the central directory   4 bytes

          decToHex(centralDirLength, 4) +

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

          decToHex(localDirLength, 4) +

          // .ZIP file comment length

          "\x00\x00";

          // we have all the parts (and the total length)

          // time to create a writer !

          switch(options.type.toLowerCase()) {

             case "uint8array" :

             case "arraybuffer" :

             case "blob" :

             case "nodebuffer" :

                writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length);

                break;

             // case "base64" :

             // case "string" :

             default :

                writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length);

                break;

          }

          for (i = 0; i < zipData.length; i++) {

             writer.append(zipData[i].fileRecord);

             writer.append(zipData[i].compressedObject.compressedContent);

          }

          for (i = 0; i < zipData.length; i++) {

             writer.append(zipData[i].dirRecord);

          }

          writer.append(dirEnd);

          var zip = writer.finalize();

          switch(options.type.toLowerCase()) {

             // case "zip is an Uint8Array"

             case "uint8array" :

             case "arraybuffer" :

             case "nodebuffer" :

                return JSZip.utils.transformTo(options.type.toLowerCase(), zip);

             case "blob" :

                return JSZip.utils.arrayBuffer2Blob(JSZip.utils.transformTo("arraybuffer", zip));

             // case "zip is a string"

             case "base64" :

                return (options.base64) ? JSZip.base64.encode(zip) : zip;

             default : // case "string" :

                return zip;

          }

       },

       /**

        *

        *  Javascript crc32

        *  http://www.webtoolkit.info/

        *

        */

       crc32 : function crc32(input, crc) {

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

             return 0;

          }

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

          var table = [

             0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,

             0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,

             0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,

             0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,

             0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,

             0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,

             0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,

             0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,

             0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,

             0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,

             0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,

             0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,

             0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,

             0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,

             0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,

             0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,

             0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,

             0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,

             0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,

             0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,

             0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,

             0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,

             0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,

             0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,

             0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,

             0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,

             0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,

             0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,

             0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,

             0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,

             0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,

             0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,

             0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,

             0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,

             0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,

             0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,

             0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,

             0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,

             0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,

             0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,

             0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,

             0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,

             0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,

             0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,

             0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,

             0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,

             0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,

             0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,

             0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,

             0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,

             0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,

             0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,

             0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,

             0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,

             0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,

             0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,

             0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,

             0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,

             0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,

             0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,

             0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,

             0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,

             0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,

             0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D

          ];

          if (typeof(crc) == "undefined") { crc = 0; }

          var x = 0;

          var y = 0;

          var byte = 0;

          crc = crc ^ (-1);

          for( var i = 0, iTop = input.length; i < iTop; i++ ) {

             byte = isArray ? input[i] : input.charCodeAt(i);

             y = ( crc ^ byte ) & 0xFF;

             x = table[y];

             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) {

          // 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);

          }

          if (JSZip.support.nodebuffer) {

             return JSZip.utils.transformTo("string", new Buffer(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;

          for (var n = 0; n < string.length; n++) {

             var c = string.charCodeAt(n);

             if (c < 128) {

                result[resIndex++] = String.fromCharCode(c);

             } else if ((c > 127) && (c < 2048)) {

                result[resIndex++] = String.fromCharCode((c >> 6) | 192);

                result[resIndex++] = String.fromCharCode((c & 63) | 128);

             } else {

                result[resIndex++] = String.fromCharCode((c >> 12) | 224);

                result[resIndex++] = String.fromCharCode(((c >> 6) & 63) | 128);

                result[resIndex++] = String.fromCharCode((c & 63) | 128);

             }

          }

          return result.join("");

       },

       /**

        * http://www.webtoolkit.info/javascript-utf8.html

        */

       utf8decode : function (input) {

          var result = [], resIndex = 0;

          var type = JSZip.utils.getTypeOf(input);

          var isArray = type !== "string";

          var i = 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)

             );

          }

          if (JSZip.support.nodebuffer) {

             return JSZip.utils.transformTo("nodebuffer", input).toString("utf-8");

          }

          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);

                result[resIndex++] = String.fromCharCode(((c & 31) << 6) | (c2 & 63));

                i += 2;

             } else {

                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;

             }

          }

          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

    }

 };

 (function () {

    JSZip.utils = {

       /**

        * 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) {

          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) {

          return JSZip.utils.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) {

          return JSZip.utils.transformTo("string", array);

       },

       /**

        * Create a blob from the given ArrayBuffer.

        * @param {ArrayBuffer} buffer the buffer to transform.

        * @return {Blob} the result.

        * @throws {Error} an Error if the browser doesn't support the requested feature.

        */

       arrayBuffer2Blob : function (buffer) {

          JSZip.utils.checkSupport("blob");

          try {

             // Blob constructor

             return new Blob([buffer], { type: "application/zip" });

          }

          catch(e) {}

          try {

             // deprecated, browser only, old way

             var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;

             var builder = new BlobBuilder();

             builder.append(buffer);

             return builder.getBlob('application/zip');

          }

          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) {

       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) {

       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) {

       // Performances notes :

       // --------------------

       // String.fromCharCode.apply(null, array) is the fastest, see

       // see http://jsperf.com/converting-a-uint8array-to-a-string/2

       // but the stack is limited (and we can get huge arrays !).

       //

       // result += String.fromCharCode(array[i]); generate too many strings !

       //

       // 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 canUseApply = true;

       try {

          switch(type) {

             case "uint8array":

                String.fromCharCode.apply(null, new Uint8Array(0));

                break;

             case "nodebuffer":

                String.fromCharCode.apply(null, new Buffer(0));

                break;

          }

       } catch(e) {

          canUseApply = false;

       }

       // no apply : slow and painful algorithm

       // default browser on android 4.*

       if (!canUseApply) {

          var resultStr = "";

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

             resultStr += String.fromCharCode(array[i]);

          }

          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 {

                result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));

             }

             k += chunk;

          } 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) {

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

          arrayTo[i] = arrayFrom[i];

       }

       return arrayTo;

    }

    // a matrix containing functions to transform everything into everything.

    var transform = {};

    // string to ?

    transform["string"] = {

       "string" : identity,

       "array" : function (input) {

          return stringToArrayLike(input, new Array(input.length));

       },

       "arraybuffer" : function (input) {

          return transform["string"]["uint8array"](input).buffer;

       },

       "uint8array" : function (input) {

          return stringToArrayLike(input, new Uint8Array(input.length));

       },

       "nodebuffer" : function (input) {

          return stringToArrayLike(input, new Buffer(input.length));

       }

    };

    // array to ?

    transform["array"] = {

       "string" : arrayLikeToString,

       "array" : identity,

       "arraybuffer" : function (input) {

          return (new Uint8Array(input)).buffer;

       },

       "uint8array" : function (input) {

          return new Uint8Array(input);

       },

       "nodebuffer" : function (input) {

          return new Buffer(input);

       }

    };

    // arraybuffer to ?

    transform["arraybuffer"] = {

       "string" : function (input) {

          return arrayLikeToString(new Uint8Array(input));

       },

       "array" : function (input) {

          return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));

       },

       "arraybuffer" : identity,

       "uint8array" : function (input) {

          return new Uint8Array(input);

       },

       "nodebuffer" : function (input) {

          return new Buffer(new Uint8Array(input));

       }

    };

    // uint8array to ?

    transform["uint8array"] = {

       "string" : arrayLikeToString,

       "array" : function (input) {

          return arrayLikeToArrayLike(input, new Array(input.length));

       },

       "arraybuffer" : function (input) {

          return input.buffer;

       },

       "uint8array" : identity,

       "nodebuffer" : function(input) {

          return new Buffer(input);

       }

    };

    // nodebuffer to ?

    transform["nodebuffer"] = {

       "string" : arrayLikeToString,

       "array" : function (input) {

          return arrayLikeToArrayLike(input, new Array(input.length));

       },

       "arraybuffer" : function (input) {

          return transform["nodebuffer"]["uint8array"](input).buffer;

       },

       "uint8array" : function (input) {

          return arrayLikeToArrayLike(input, new Uint8Array(input.length));

       },

       "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.

     * @param {String} outputType the output type.

     * @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) {

       if (!input) {

          // undefined, null, etc

          // an empty string won't harm.

          input = "";

       }

       if (!outputType) {

          return input;

       }

       JSZip.utils.checkSupport(outputType);

       var inputType = JSZip.utils.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) {

       if (typeof input === "string") {

          return "string";

       }

       if (Object.prototype.toString.call(input) === "[object Array]") {

          return "array";

       }

       if (JSZip.support.nodebuffer && Buffer.isBuffer(input)) {

          return "nodebuffer";

       }

       if (JSZip.support.uint8array && input instanceof Uint8Array) {

          return "uint8array";

       }

       if (JSZip.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) {

       var supported = true;

       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");

       }

    };

 })();

 (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

       }

    };

 })();

 /**

  *

  *  Base64 encode / decode

  *  http://www.webtoolkit.info/

  *

  *  Hacked so that it doesn't utf8 en/decode everything

  **/

 JSZip.base64 = (function() {

    // private property

    var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

    return {

       // public method for encoding

       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

       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;

       }

    };

 }());

 // enforcing Stuk's coding style

 // vim: set shiftwidth=3 softtabstop=3: