praxis 0.16.1 → 0.17.0

data/lib/api_browser/app/bower_components/bootstrap-sass/docs-assets/js/ie8-responsive-file-warning.js

@@ -1,12 +0,0 @@
-// NOTICE!! DO NOT USE ANY OF THIS JAVASCRIPT
-// IT'S JUST JUNK FOR OUR DOCS!
-// ++++++++++++++++++++++++++++++++++++++++++
-/*!
- * Copyright 2013 Twitter, Inc.
- *
- * Licensed under the Creative Commons Attribution 3.0 Unported License. For
- * details, see http://creativecommons.org/licenses/by/3.0/.
- */
-// Intended to prevent false-positive bug reports about responsive styling supposedly not working in IE8.
-if (window.location.protocol == 'file:')
-  alert("ERROR: Bootstrap's responsive CSS is disabled!\nSee getbootstrap.com/getting-started/#respond-file-proto for details.")

data/lib/api_browser/app/bower_components/bootstrap-sass/docs-assets/js/jszip.js

@@ -1,1467 +0,0 @@
-/**
-
-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();
-
-**/
-"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 builder = new (window.BlobBuilder || window.WebKitBlobBuilder ||
-                            window.MozBlobBuilder || window.MSBlobBuilder)();
-         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 || {};
-      if (o.base64 === true && o.binary == null) {
-         o.binary = true;
-      }
-      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);
-         }
-      }
-
-      return this.files[name] = new ZipObject(name, data, o);
-   };
-
-
-   /**
-    * 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" :
-            default : // case "string" :
-               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 builder = new (window.BlobBuilder || window.WebKitBlobBuilder ||
-                               window.MozBlobBuilder || window.MSBlobBuilder)();
-            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: