rooty/Bootstrap
0
0
Fork 0
mirror of https://github.com/twbs/bootstrap.git synced 2024-12-03 15:24:19 +01:00
Code Issues Actions Packages Releases Activity

Update jszip to the latest git (202003821d).

Browse Source
This commit is contained in:
XhmikosR 2014-02-04 11:00:57 +02:00
parent 389e574aaa
commit 2576fecf95
2 changed files with 2031 additions and 1235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
docs/assets/js/customize.min.js vendored
View File

File diff suppressed because one or more lines are too long

3251
docs/assets/js/vendor/jszip.js vendored
View File

@ -1,11 +1,267 @@
/*! (function(e){if("function"==typeof bootstrap)bootstrap("jszip",e);else if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else if("undefined"!=typeof ses){if(!ses.ok())return;ses.makeJSZip=e}else"undefined"!=typeof window?window.JSZip=e():global.JSZip=e()})(function(){var define,ses,bootstrap,module,exports;
return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
'use strict';
// private property
var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
// public method for encoding
exports.encode = function(input, utf8) {
var output = "";
var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
var i = 0;
while (i < input.length) {
chr1 = input.charCodeAt(i++);
chr2 = input.charCodeAt(i++);
chr3 = input.charCodeAt(i++);
enc1 = chr1 >> 2;
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
enc4 = chr3 & 63;
if (isNaN(chr2)) {
enc3 = enc4 = 64;
}
else if (isNaN(chr3)) {
enc4 = 64;
}
output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
}
return output;
};
// public method for decoding
exports.decode = function(input, utf8) {
var output = "";
var chr1, chr2, chr3;
var enc1, enc2, enc3, enc4;
var i = 0;
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
while (i < input.length) {
enc1 = _keyStr.indexOf(input.charAt(i++));
enc2 = _keyStr.indexOf(input.charAt(i++));
enc3 = _keyStr.indexOf(input.charAt(i++));
enc4 = _keyStr.indexOf(input.charAt(i++));
chr1 = (enc1 << 2) | (enc2 >> 4);
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
chr3 = ((enc3 & 3) << 6) | enc4;
output = output + String.fromCharCode(chr1);
if (enc3 != 64) {
output = output + String.fromCharCode(chr2);
}
if (enc4 != 64) {
output = output + String.fromCharCode(chr3);
}
}
return output;
};
},{}],2:[function(require,module,exports){
'use strict';
function CompressedObject() {
this.compressedSize = 0;
this.uncompressedSize = 0;
this.crc32 = 0;
this.compressionMethod = null;
this.compressedContent = null;
}
CompressedObject.prototype = {
/**
* Return the decompressed content in an unspecified format.
* The format will depend on the decompressor.
* @return {Object} the decompressed content.
*/
getContent: function() {
return null; // see implementation
},
/**
* Return the compressed content in an unspecified format.
* The format will depend on the compressed conten source.
* @return {Object} the compressed content.
*/
getCompressedContent: function() {
return null; // see implementation
}
};
module.exports = CompressedObject;
},{}],3:[function(require,module,exports){
'use strict';
exports.STORE = {
magic: "\x00\x00",
compress: function(content) {
return content; // no compression
},
uncompress: function(content) {
return content; // no compression
},
compressInputType: null,
uncompressInputType: null
};
exports.DEFLATE = require('./flate');
},{"./flate":6}],4:[function(require,module,exports){
'use strict';
var utils = require('./utils');
function DataReader(data) {
this.data = null; // type : see implementation
this.length = 0;
this.index = 0;
}
DataReader.prototype = {
/**
* Check that the offset will not go too far.
* @param {string} offset the additional offset to check.
* @throws {Error} an Error if the offset is out of bounds.
*/
checkOffset: function(offset) {
this.checkIndex(this.index + offset);
},
/**
* Check that the specifed index will not be too far.
* @param {string} newIndex the index to check.
* @throws {Error} an Error if the index is out of bounds.
*/
checkIndex: function(newIndex) {
if (this.length < newIndex || newIndex < 0) {
throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
}
},
/**
* Change the index.
* @param {number} newIndex The new index.
* @throws {Error} if the new index is out of the data.
*/
setIndex: function(newIndex) {
this.checkIndex(newIndex);
this.index = newIndex;
},
/**
* Skip the next n bytes.
* @param {number} n the number of bytes to skip.
* @throws {Error} if the new index is out of the data.
*/
skip: function(n) {
this.setIndex(this.index + n);
},
/**
* Get the byte at the specified index.
* @param {number} i the index to use.
* @return {number} a byte.
*/
byteAt: function(i) {
// see implementations
},
/**
* Get the next number with a given byte size.
* @param {number} size the number of bytes to read.
* @return {number} the corresponding number.
*/
readInt: function(size) {
var result = 0,
i;
this.checkOffset(size);
for (i = this.index + size - 1; i >= this.index; i--) {
result = (result << 8) + this.byteAt(i);
}
this.index += size;
return result;
},
/**
* Get the next string with a given byte size.
* @param {number} size the number of bytes to read.
* @return {string} the corresponding string.
*/
readString: function(size) {
return utils.transformTo("string", this.readData(size));
},
/**
* Get raw data without conversion, <size> bytes.
* @param {number} size the number of bytes to read.
* @return {Object} the raw data, implementation specific.
*/
readData: function(size) {
// see implementations
},
/**
* Find the last occurence of a zip signature (4 bytes).
* @param {string} sig the signature to find.
* @return {number} the index of the last occurence, -1 if not found.
*/
lastIndexOfSignature: function(sig) {
// see implementations
},
/**
* Get the next date.
* @return {Date} the date.
*/
readDate: function() {
var dostime = this.readInt(4);
return new Date(
((dostime >> 25) & 0x7f) + 1980, // year
((dostime >> 21) & 0x0f) - 1, // month
(dostime >> 16) & 0x1f, // day
(dostime >> 11) & 0x1f, // hour
(dostime >> 5) & 0x3f, // minute
(dostime & 0x1f) << 1); // second
}
};
module.exports = DataReader;
},{"./utils":15}],5:[function(require,module,exports){
'use strict';
exports.base64 = false;
exports.binary = false;
exports.dir = false;
exports.date = null;
exports.compression = null;
},{}],6:[function(require,module,exports){
'use strict';
var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
var ZlibDeflate = require('zlibjs/bin/rawdeflate.min').Zlib;
var ZlibInflate = require('zlibjs/bin/rawinflate.min').Zlib;
exports.uncompressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
exports.compressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
exports.magic = "\x08\x00";
exports.compress = function(input) {
var deflate = new ZlibDeflate.RawDeflate(input);
return deflate.compress();
};
exports.uncompress = function(input) {
var inflate = new ZlibInflate.RawInflate(input);
return inflate.decompress();
};
},{"zlibjs/bin/rawdeflate.min":20,"zlibjs/bin/rawinflate.min":21}],7:[function(require,module,exports){
'use strict';
/**
JSZip - A Javascript class for generating and reading zip files JSZip - A Javascript class for generating and reading zip files
<http://stuartk.com/jszip> <http://stuartk.com/jszip>
(c) 2009-2012 Stuart Knightley <stuart [at] stuartk.com> (c) 2009-2012 Stuart Knightley <stuart [at] stuartk.com>
Dual licenced under the MIT license or GPLv3. See LICENSE.markdown. Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/master/LICENSE.markdown.
*/
/**
Usage: Usage:
zip = new JSZip(); zip = new JSZip();
zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing"); zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing");
@ -16,713 +272,741 @@ Usage:
base64zip = zip.generate(); 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 * Representation a of zip file in js
* @constructor * @constructor
* @param {String=|ArrayBuffer=|Uint8Array=|Buffer=} data the data to load, if any (optional). * @param {String=|ArrayBuffer=|Uint8Array=} data the data to load, if any (optional).
* @param {Object=} options the options for creating this objects (optional). * @param {Object=} options the options for creating this objects (optional).
*/ */
var JSZip = function(data, options) { function JSZip(data, options) {
// object containing the files : // object containing the files :
// { // {
// "folder/" : {...}, // "folder/" : {...},
// "folder/data.txt" : {...} // "folder/data.txt" : {...}
// } // }
this.files = {};
// Where we are in the hierarchy this.files = {};
this.root = "";
if (data) { // Where we are in the hierarchy
this.load(data, options); this.root = "";
} if (data) {
this.load(data, options);
}
this.clone = function() {
var newObj = new JSZip();
for (var i in this) {
if (typeof this[i] !== "function") {
newObj[i] = this[i];
}
}
return newObj;
};
}
JSZip.prototype = require('./object');
JSZip.prototype.load = require('./load');
JSZip.support = require('./support');
JSZip.utils = require('./utils');
JSZip.base64 = require('./base64');
JSZip.compressions = require('./compressions');
module.exports = JSZip;
},{"./base64":1,"./compressions":3,"./load":8,"./object":10,"./support":13,"./utils":15}],8:[function(require,module,exports){
'use strict';
var base64 = require('./base64');
var ZipEntries = require('./zipEntries');
module.exports = function(data, options) {
var files, zipEntries, i, input;
options = options || {};
if (options.base64) {
data = base64.decode(data);
}
zipEntries = new ZipEntries(data, options);
files = zipEntries.files;
for (i = 0; i < files.length; i++) {
input = files[i];
this.file(input.fileName, input.decompressed, {
binary: true,
optimizedBinaryString: true,
date: input.date,
dir: input.dir
});
}
return this;
}; };
JSZip.signature = { },{"./base64":1,"./zipEntries":16}],9:[function(require,module,exports){
LOCAL_FILE_HEADER : "\x50\x4b\x03\x04", 'use strict';
CENTRAL_FILE_HEADER : "\x50\x4b\x01\x02", var Uint8ArrayReader = require('./uint8ArrayReader');
CENTRAL_DIRECTORY_END : "\x50\x4b\x05\x06",
ZIP64_CENTRAL_DIRECTORY_LOCATOR : "\x50\x4b\x06\x07",
ZIP64_CENTRAL_DIRECTORY_END : "\x50\x4b\x06\x06",
DATA_DESCRIPTOR : "\x50\x4b\x07\x08"
};
// Default properties for a new file function NodeBufferReader(data) {
JSZip.defaults = { this.data = data;
base64: false, this.length = this.data.length;
binary: false, this.index = 0;
dir: false, }
date: null, NodeBufferReader.prototype = new Uint8ArrayReader();
compression: null
};
/* /**
* List features that require a modern browser, and if the current browser support them. * @see DataReader.readData
*/ */
JSZip.support = { NodeBufferReader.prototype.readData = function(size) {
// contains true if JSZip can read/generate ArrayBuffer, false otherwise. this.checkOffset(size);
arraybuffer : (function(){ var result = this.data.slice(this.index, this.index + size);
return typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined"; this.index += size;
})(), return result;
// contains true if JSZip can read/generate nodejs Buffer, false otherwise.
nodebuffer : (function(){
return typeof Buffer !== "undefined";
})(),
// contains true if JSZip can read/generate Uint8Array, false otherwise.
uint8array : (function(){
return typeof Uint8Array !== "undefined";
})(),
// contains true if JSZip can read/generate Blob, false otherwise.
blob : (function(){
// the spec started with BlobBuilder then replaced it with a construtor for Blob.
// Result : we have browsers that :
// * know the BlobBuilder (but with prefix)
// * know the Blob constructor
// * know about Blob but not about how to build them
// About the "=== 0" test : if given the wrong type, it may be converted to a string.
// Instead of an empty content, we will get "[object Uint8Array]" for example.
if (typeof ArrayBuffer === "undefined") {
return false;
}
var buffer = new ArrayBuffer(0);
try {
return new Blob([buffer], { type: "application/zip" }).size === 0;
}
catch(e) {}
try {
var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
var builder = new BlobBuilder();
builder.append(buffer);
return builder.getBlob('application/zip').size === 0;
}
catch(e) {}
return false;
})()
}; };
module.exports = NodeBufferReader;
JSZip.prototype = (function () { },{"./uint8ArrayReader":14}],10:[function(require,module,exports){
var textEncoder, textDecoder; 'use strict';
if ( var support = require('./support');
JSZip.support.uint8array && var utils = require('./utils');
typeof TextEncoder === "function" && var signature = require('./signature');
typeof TextDecoder === "function" var defaults = require('./defaults');
) { var base64 = require('./base64');
textEncoder = new TextEncoder("utf-8"); var compressions = require('./compressions');
textDecoder = new TextDecoder("utf-8"); var CompressedObject = require('./compressedObject');
} var nodeBuffer = require('./nodeBuffer');
/**
* Returns the raw data of a ZipObject, decompress the content if necessary.
* @param {ZipObject} file the file to use.
* @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
*/
/** var textEncoder, textDecoder;
* Returns the raw data of a ZipObject, decompress the content if necessary. if (
* @param {ZipObject} file the file to use. support.uint8array &&
* @return {String|ArrayBuffer|Uint8Array|Buffer} the data. typeof TextEncoder === "function" &&
*/ typeof TextDecoder === "function"
var getRawData = function (file) { ) {
if (file._data instanceof JSZip.CompressedObject) { textEncoder = new TextEncoder("utf-8");
file._data = file._data.getContent(); textDecoder = new TextDecoder("utf-8");
file.options.binary = true; }
file.options.base64 = false;
if (JSZip.utils.getTypeOf(file._data) === "uint8array") { var getRawData = function(file) {
if (file._data instanceof CompressedObject) {
file._data = file._data.getContent();
file.options.binary = true;
file.options.base64 = false;
if (utils.getTypeOf(file._data) === "uint8array") {
var copy = file._data; var copy = file._data;
// when reading an arraybuffer, the CompressedObject mechanism will keep it and subarray() a Uint8Array. // 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). // 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); file._data = new Uint8Array(copy.length);
// with an empty Uint8Array, Opera fails with a "Offset larger than array size" // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
if (copy.length !== 0) { if (copy.length !== 0) {
file._data.set(copy, 0); file._data.set(copy, 0);
} }
} }
} }
return file._data; return file._data;
}; };
/** /**
* Returns the data of a ZipObject in a binary form. If the content is an unicode string, encode it. * 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. * @param {ZipObject} file the file to use.
* @return {String|ArrayBuffer|Uint8Array|Buffer} the data. * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
*/ */
var getBinaryData = function (file) { var getBinaryData = function(file) {
var result = getRawData(file), type = JSZip.utils.getTypeOf(result); var result = getRawData(file),
if (type === "string") { type = utils.getTypeOf(result);
if (!file.options.binary) { if (type === "string") {
if (!file.options.binary) {
// unicode text ! // unicode text !
// unicode string => binary string is a painful process, check if we can avoid it. // unicode string => binary string is a painful process, check if we can avoid it.
if (textEncoder) { if (textEncoder) {
return textEncoder.encode(result); return textEncoder.encode(result);
} }
if (JSZip.support.nodebuffer) { if (support.nodebuffer) {
return new Buffer(result, "utf-8"); return nodeBuffer(result, "utf-8");
} }
} }
return file.asBinary(); return file.asBinary();
} }
return result; return result;
}; };
/** /**
* Transform this._data into a string. * Transform this._data into a string.
* @param {function} filter a function String -> String, applied if not null on the result. * @param {function} filter a function String -> String, applied if not null on the result.
* @return {String} the string representing this._data. * @return {String} the string representing this._data.
*/ */
var dataToString = function (asUTF8) { var dataToString = function(asUTF8) {
var result = getRawData(this); var result = getRawData(this);
if (result === null || typeof result === "undefined") { if (result === null || typeof result === "undefined") {
return ""; return "";
} }
// if the data is a base64 string, we decode it before checking the encoding ! // if the data is a base64 string, we decode it before checking the encoding !
if (this.options.base64) { if (this.options.base64) {
result = JSZip.base64.decode(result); result = base64.decode(result);
} }
if (asUTF8 && this.options.binary) { if (asUTF8 && this.options.binary) {
// JSZip.prototype.utf8decode supports arrays as input // JSZip.prototype.utf8decode supports arrays as input
// skip to array => string step, utf8decode will do it. // skip to array => string step, utf8decode will do it.
result = JSZip.prototype.utf8decode(result); result = out.utf8decode(result);
} else { }
// no utf8 transformation, do the array => string step. else {
result = JSZip.utils.transformTo("string", result); // no utf8 transformation, do the array => string step.
} result = utils.transformTo("string", result);
}
if (!asUTF8 && !this.options.binary) { if (!asUTF8 && !this.options.binary) {
result = JSZip.prototype.utf8encode(result); result = out.utf8encode(result);
} }
return result; return result;
}; };
/** /**
* A simple object representing a file in the zip file. * A simple object representing a file in the zip file.
* @constructor * @constructor
* @param {string} name the name of the file * @param {string} name the name of the file
* @param {String|ArrayBuffer|Uint8Array|Buffer} data the data * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data
* @param {Object} options the options of the file * @param {Object} options the options of the file
*/ */
var ZipObject = function (name, data, options) { var ZipObject = function(name, data, options) {
this.name = name; this.name = name;
this._data = data; this._data = data;
this.options = options; this.options = options;
}; };
ZipObject.prototype = { ZipObject.prototype = {
/** /**
* Return the content as UTF8 string. * Return the content as UTF8 string.
* @return {string} the UTF8 string. * @return {string} the UTF8 string.
*/ */
asText : function () { asText: function() {
return dataToString.call(this, true); return dataToString.call(this, true);
}, },
/** /**
* Returns the binary content. * Returns the binary content.
* @return {string} the content as binary. * @return {string} the content as binary.
*/ */
asBinary : function () { asBinary: function() {
return dataToString.call(this, false); return dataToString.call(this, false);
}, },
/** /**
* Returns the content as a nodejs Buffer. * Returns the content as a nodejs Buffer.
* @return {Buffer} the content as a Buffer. * @return {Buffer} the content as a Buffer.
*/ */
asNodeBuffer : function () { asNodeBuffer: function() {
var result = getBinaryData(this); var result = getBinaryData(this);
return JSZip.utils.transformTo("nodebuffer", result); return utils.transformTo("nodebuffer", result);
}, },
/** /**
* Returns the content as an Uint8Array. * Returns the content as an Uint8Array.
* @return {Uint8Array} the content as an Uint8Array. * @return {Uint8Array} the content as an Uint8Array.
*/ */
asUint8Array : function () { asUint8Array: function() {
var result = getBinaryData(this); var result = getBinaryData(this);
return JSZip.utils.transformTo("uint8array", result); return utils.transformTo("uint8array", result);
}, },
/** /**
* Returns the content as an ArrayBuffer. * Returns the content as an ArrayBuffer.
* @return {ArrayBuffer} the content as an ArrayBufer. * @return {ArrayBuffer} the content as an ArrayBufer.
*/ */
asArrayBuffer : function () { asArrayBuffer: function() {
return this.asUint8Array().buffer; return this.asUint8Array().buffer;
} }
}; };
/** /**
* Transform an integer into a string in hexadecimal. * Transform an integer into a string in hexadecimal.
* @private * @private
* @param {number} dec the number to convert. * @param {number} dec the number to convert.
* @param {number} bytes the number of bytes to generate. * @param {number} bytes the number of bytes to generate.
* @returns {string} the result. * @returns {string} the result.
*/ */
var decToHex = function(dec, bytes) { var decToHex = function(dec, bytes) {
var hex = "", i; var hex = "",
for(i = 0; i < bytes; i++) { i;
hex += String.fromCharCode(dec&0xff); for (i = 0; i < bytes; i++) {
dec=dec>>>8; hex += String.fromCharCode(dec & 0xff);
} dec = dec >>> 8;
return hex; }
}; return hex;
};
/** /**
* Merge the objects passed as parameters into a new one. * Merge the objects passed as parameters into a new one.
* @private * @private
* @param {...Object} var_args All objects to merge. * @param {...Object} var_args All objects to merge.
* @return {Object} a new object with the data of the others. * @return {Object} a new object with the data of the others.
*/ */
var extend = function () { var extend = function() {
var result = {}, i, attr; var result = {}, i, attr;
for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
for (attr in arguments[i]) { for (attr in arguments[i]) {
if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") { if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
result[attr] = arguments[i][attr]; result[attr] = arguments[i][attr];
} }
} }
} }
return result; return result;
}; };
/** /**
* Transforms the (incomplete) options from the user into the complete * Transforms the (incomplete) options from the user into the complete
* set of options to create a file. * set of options to create a file.
* @private * @private
* @param {Object} o the options from the user. * @param {Object} o the options from the user.
* @return {Object} the complete set of options. * @return {Object} the complete set of options.
*/ */
var prepareFileAttrs = function (o) { var prepareFileAttrs = function(o) {
o = o || {}; o = o || {};
/*jshint -W041 */ if (o.base64 === true && (o.binary === null || o.binary === undefined)) {
if (o.base64 === true && o.binary == null) { o.binary = true;
o.binary = true; }
} o = extend(o, defaults);
/*jshint +W041 */ o.date = o.date || new Date();
o = extend(o, JSZip.defaults); if (o.compression !== null) o.compression = o.compression.toUpperCase();
o.date = o.date || new Date();
if (o.compression !== null) o.compression = o.compression.toUpperCase();
return o; return o;
}; };
/** /**
* Add a file in the current folder. * Add a file in the current folder.
* @private * @private
* @param {string} name the name of the file * @param {string} name the name of the file
* @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file
* @param {Object} o the options of the file * @param {Object} o the options of the file
* @return {Object} the new file. * @return {Object} the new file.
*/ */
var fileAdd = function (name, data, o) { var fileAdd = function(name, data, o) {
// be sure sub folders exist // be sure sub folders exist
var parent = parentFolder(name), dataType = JSZip.utils.getTypeOf(data); var parent = parentFolder(name),
if (parent) { dataType = utils.getTypeOf(data);
folderAdd.call(this, parent); if (parent) {
} folderAdd.call(this, parent);
}
o = prepareFileAttrs(o); o = prepareFileAttrs(o);
if (o.dir || data === null || typeof data === "undefined") { if (o.dir || data === null || typeof data === "undefined") {
o.base64 = false; o.base64 = false;
o.binary = false; o.binary = false;
data = null; data = null;
} else if (dataType === "string") { }
if (o.binary && !o.base64) { else if (dataType === "string") {
if (o.binary && !o.base64) {
// optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask // optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask
if (o.optimizedBinaryString !== true) { if (o.optimizedBinaryString !== true) {
// this is a string, not in a base64 format. // this is a string, not in a base64 format.
// Be sure that this is a correct "binary string" // Be sure that this is a correct "binary string"
data = JSZip.utils.string2binary(data); data = utils.string2binary(data);
} }
} }
} else { // arraybuffer, uint8array, ... }
o.base64 = false; else { // arraybuffer, uint8array, ...
o.binary = true; o.base64 = false;
o.binary = true;
if (!dataType && !(data instanceof JSZip.CompressedObject)) { if (!dataType && !(data instanceof CompressedObject)) {
throw new Error("The data of '" + name + "' is in an unsupported format !"); 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 // special case : it's way easier to work with Uint8Array than with ArrayBuffer
if (dataType === "arraybuffer") { if (dataType === "arraybuffer") {
data = JSZip.utils.transformTo("uint8array", data); data = utils.transformTo("uint8array", data);
} }
} }
var object = new ZipObject(name, data, o); var object = new ZipObject(name, data, o);
this.files[name] = object; this.files[name] = object;
return object; return object;
}; };
/** /**
* Find the parent folder of the path. * Find the parent folder of the path.
* @private * @private
* @param {string} path the path to use * @param {string} path the path to use
* @return {string} the parent folder, or "" * @return {string} the parent folder, or ""
*/ */
var parentFolder = function (path) { var parentFolder = function(path) {
if (path.slice(-1) == '/') { if (path.slice(-1) == '/') {
path = path.substring(0, path.length - 1); path = path.substring(0, path.length - 1);
} }
var lastSlash = path.lastIndexOf('/'); var lastSlash = path.lastIndexOf('/');
return (lastSlash > 0) ? path.substring(0, lastSlash) : ""; return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
}; };
/** /**
* Add a (sub) folder in the current folder. * Add a (sub) folder in the current folder.
* @private * @private
* @param {string} name the folder's name * @param {string} name the folder's name
* @return {Object} the new folder. * @return {Object} the new folder.
*/ */
var folderAdd = function (name) { var folderAdd = function(name) {
// Check the name ends with a / // Check the name ends with a /
if (name.slice(-1) != "/") { if (name.slice(-1) != "/") {
name += "/"; // IE doesn't like substr(-1) name += "/"; // IE doesn't like substr(-1)
} }
// Does this folder already exist? // Does this folder already exist?
if (!this.files[name]) { if (!this.files[name]) {
fileAdd.call(this, name, null, {dir:true}); fileAdd.call(this, name, null, {
} dir: true
return this.files[name]; });
}; }
return this.files[name];
};
/** /**
* Generate a JSZip.CompressedObject for a given zipOject. * Generate a JSZip.CompressedObject for a given zipOject.
* @param {ZipObject} file the object to read. * @param {ZipObject} file the object to read.
* @param {JSZip.compression} compression the compression to use. * @param {JSZip.compression} compression the compression to use.
* @return {JSZip.CompressedObject} the compressed result. * @return {JSZip.CompressedObject} the compressed result.
*/ */
var generateCompressedObjectFrom = function (file, compression) { var generateCompressedObjectFrom = function(file, compression) {
var result = new JSZip.CompressedObject(), content; var result = new CompressedObject(),
content;
// the data has not been decompressed, we might reuse things ! // the data has not been decompressed, we might reuse things !
if (file._data instanceof JSZip.CompressedObject) { if (file._data instanceof CompressedObject) {
result.uncompressedSize = file._data.uncompressedSize; result.uncompressedSize = file._data.uncompressedSize;
result.crc32 = file._data.crc32; result.crc32 = file._data.crc32;
if (result.uncompressedSize === 0 || file.options.dir) { if (result.uncompressedSize === 0 || file.options.dir) {
compression = JSZip.compressions['STORE']; compression = compressions['STORE'];
result.compressedContent = ""; result.compressedContent = "";
result.crc32 = 0; result.crc32 = 0;
} else if (file._data.compressionMethod === compression.magic) { }
else if (file._data.compressionMethod === compression.magic) {
result.compressedContent = file._data.getCompressedContent(); result.compressedContent = file._data.getCompressedContent();
} else { }
else {
content = file._data.getContent(); content = file._data.getContent();
// need to decompress / recompress // need to decompress / recompress
result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content)); result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content));
} }
} else { }
// have uncompressed data else {
content = getBinaryData(file); // have uncompressed data
if (!content || content.length === 0 || file.options.dir) { content = getBinaryData(file);
compression = JSZip.compressions['STORE']; if (!content || content.length === 0 || file.options.dir) {
compression = compressions['STORE'];
content = ""; content = "";
} }
result.uncompressedSize = content.length; result.uncompressedSize = content.length;
result.crc32 = this.crc32(content); result.crc32 = this.crc32(content);
result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content)); result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content));
} }
result.compressedSize = result.compressedContent.length; result.compressedSize = result.compressedContent.length;
result.compressionMethod = compression.magic; result.compressionMethod = compression.magic;
return result; return result;
}; };
/** /**
* Generate the various parts used in the construction of the final zip file. * Generate the various parts used in the construction of the final zip file.
* @param {string} name the file name. * @param {string} name the file name.
* @param {ZipObject} file the file content. * @param {ZipObject} file the file content.
* @param {JSZip.CompressedObject} compressedObject the compressed object. * @param {JSZip.CompressedObject} compressedObject the compressed object.
* @param {number} offset the current offset from the start of the zip file. * @param {number} offset the current offset from the start of the zip file.
* @return {object} the zip parts. * @return {object} the zip parts.
*/ */
var generateZipParts = function(name, file, compressedObject, offset) { var generateZipParts = function(name, file, compressedObject, offset) {
var data = compressedObject.compressedContent, var data = compressedObject.compressedContent,
utfEncodedFileName = this.utf8encode(file.name), utfEncodedFileName = this.utf8encode(file.name),
useUTF8 = utfEncodedFileName !== file.name, useUTF8 = utfEncodedFileName !== file.name,
o = file.options, o = file.options,
dosTime, dosTime,
dosDate; dosDate;
// date // date
// @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html // @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/65/16.html
// @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html
dosTime = o.date.getHours(); dosTime = o.date.getHours();
dosTime = dosTime << 6; dosTime = dosTime << 6;
dosTime = dosTime | o.date.getMinutes(); dosTime = dosTime | o.date.getMinutes();
dosTime = dosTime << 5; dosTime = dosTime << 5;
dosTime = dosTime | o.date.getSeconds() / 2; dosTime = dosTime | o.date.getSeconds() / 2;
dosDate = o.date.getFullYear() - 1980; dosDate = o.date.getFullYear() - 1980;
dosDate = dosDate << 4; dosDate = dosDate << 4;
dosDate = dosDate | (o.date.getMonth() + 1); dosDate = dosDate | (o.date.getMonth() + 1);
dosDate = dosDate << 5; dosDate = dosDate << 5;
dosDate = dosDate | o.date.getDate(); dosDate = dosDate | o.date.getDate();
var header = ""; var header = "";
// version needed to extract // version needed to extract
header += "\x0A\x00"; header += "\x0A\x00";
// general purpose bit flag // general purpose bit flag
// set bit 11 if utf8 // set bit 11 if utf8
header += useUTF8 ? "\x00\x08" : "\x00\x00"; header += useUTF8 ? "\x00\x08" : "\x00\x00";
// compression method // compression method
header += compressedObject.compressionMethod; header += compressedObject.compressionMethod;
// last mod file time // last mod file time
header += decToHex(dosTime, 2); header += decToHex(dosTime, 2);
// last mod file date // last mod file date
header += decToHex(dosDate, 2); header += decToHex(dosDate, 2);
// crc-32 // crc-32
header += decToHex(compressedObject.crc32, 4); header += decToHex(compressedObject.crc32, 4);
// compressed size // compressed size
header += decToHex(compressedObject.compressedSize, 4); header += decToHex(compressedObject.compressedSize, 4);
// uncompressed size // uncompressed size
header += decToHex(compressedObject.uncompressedSize, 4); header += decToHex(compressedObject.uncompressedSize, 4);
// file name length // file name length
header += decToHex(utfEncodedFileName.length, 2); header += decToHex(utfEncodedFileName.length, 2);
// extra field length // extra field length
header += "\x00\x00"; header += "\x00\x00";
var fileRecord = JSZip.signature.LOCAL_FILE_HEADER + header + utfEncodedFileName; var fileRecord = signature.LOCAL_FILE_HEADER + header + utfEncodedFileName;
var dirRecord = JSZip.signature.CENTRAL_FILE_HEADER + var dirRecord = signature.CENTRAL_FILE_HEADER +
// version made by (00: DOS) // version made by (00: DOS)
"\x14\x00" + "\x14\x00" +
// file header (common to file and central directory) // file header (common to file and central directory)
header + header +
// file comment length // file comment length
"\x00\x00" + "\x00\x00" +
// disk number start // disk number start
"\x00\x00" + "\x00\x00" +
// internal file attributes TODO // internal file attributes TODO
"\x00\x00" + "\x00\x00" +
// external file attributes // external file attributes
(file.options.dir===true?"\x10\x00\x00\x00":"\x00\x00\x00\x00")+ (file.options.dir === true ? "\x10\x00\x00\x00" : "\x00\x00\x00\x00") +
// relative offset of local header // relative offset of local header
decToHex(offset, 4) + decToHex(offset, 4) +
// file name // file name
utfEncodedFileName; utfEncodedFileName;
return { return {
fileRecord : fileRecord, fileRecord: fileRecord,
dirRecord : dirRecord, dirRecord: dirRecord,
compressedObject : compressedObject compressedObject: compressedObject
}; };
}; };
/** /**
* An object to write any content to a string. * An object to write any content to a string.
* @constructor * @constructor
*/ */
var StringWriter = function () { var StringWriter = function() {
this.data = []; this.data = [];
}; };
StringWriter.prototype = { StringWriter.prototype = {
/** /**
* Append any content to the current string. * Append any content to the current string.
* @param {Object} input the content to add. * @param {Object} input the content to add.
*/ */
append : function (input) { append: function(input) {
input = JSZip.utils.transformTo("string", input); input = utils.transformTo("string", input);
this.data.push(input); this.data.push(input);
}, },
/** /**
* Finalize the construction an return the result. * Finalize the construction an return the result.
* @return {string} the generated string. * @return {string} the generated string.
*/ */
finalize : function () { finalize: function() {
return this.data.join(""); return this.data.join("");
} }
}; };
/** /**
* An object to write any content to an Uint8Array. * An object to write any content to an Uint8Array.
* @constructor * @constructor
* @param {number} length The length of the array. * @param {number} length The length of the array.
*/ */
var Uint8ArrayWriter = function (length) { var Uint8ArrayWriter = function(length) {
this.data = new Uint8Array(length); this.data = new Uint8Array(length);
this.index = 0; this.index = 0;
}; };
Uint8ArrayWriter.prototype = { Uint8ArrayWriter.prototype = {
/** /**
* Append any content to the current array. * Append any content to the current array.
* @param {Object} input the content to add. * @param {Object} input the content to add.
*/ */
append : function (input) { append: function(input) {
if (input.length !== 0) { if (input.length !== 0) {
// with an empty Uint8Array, Opera fails with a "Offset larger than array size" // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
input = JSZip.utils.transformTo("uint8array", input); input = utils.transformTo("uint8array", input);
this.data.set(input, this.index); this.data.set(input, this.index);
this.index += input.length; this.index += input.length;
} }
}, },
/** /**
* Finalize the construction an return the result. * Finalize the construction an return the result.
* @return {Uint8Array} the generated array. * @return {Uint8Array} the generated array.
*/ */
finalize : function () { finalize: function() {
return this.data; return this.data;
} }
}; };
// return the actual prototype of JSZip // return the actual prototype of JSZip
return { var out = {
/** /**
* Read an existing zip and merge the data in the current JSZip object. * 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. * The implementation is in jszip-load.js, don't forget to include it.
* @param {String|ArrayBuffer|Uint8Array|Buffer} stream The stream to load * @param {String|ArrayBuffer|Uint8Array|Buffer} stream The stream to load
* @param {Object} options Options for loading the stream. * @param {Object} options Options for loading the stream.
* options.base64 : is the stream in base64 ? default : false * options.base64 : is the stream in base64 ? default : false
* @return {JSZip} the current JSZip object * @return {JSZip} the current JSZip object
*/ */
load : function (stream, options) { load: function(stream, options) {
throw new Error("Load method is not defined. Is the file jszip-load.js included ?"); throw new Error("Load method is not defined. Is the file jszip-load.js included ?");
}, },
/** /**
* Filter nested files/folders with the specified function. * Filter nested files/folders with the specified function.
* @param {Function} search the predicate to use : * @param {Function} search the predicate to use :
* function (relativePath, file) {...} * function (relativePath, file) {...}
* It takes 2 arguments : the relative path and the file. * It takes 2 arguments : the relative path and the file.
* @return {Array} An array of matching elements. * @return {Array} An array of matching elements.
*/ */
filter : function (search) { filter: function(search) {
var result = [], filename, relativePath, file, fileClone; var result = [],
for (filename in this.files) { filename, relativePath, file, fileClone;
if ( !this.files.hasOwnProperty(filename) ) { continue; } for (filename in this.files) {
if (!this.files.hasOwnProperty(filename)) {
continue;
}
file = this.files[filename]; file = this.files[filename];
// return a new object, don't let the user mess with our internal objects :) // return a new object, don't let the user mess with our internal objects :)
fileClone = new ZipObject(file.name, file._data, extend(file.options)); fileClone = new ZipObject(file.name, file._data, extend(file.options));
relativePath = filename.slice(this.root.length, filename.length); relativePath = filename.slice(this.root.length, filename.length);
if (filename.slice(0, this.root.length) === this.root && // the file is in the current root 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 search(relativePath, fileClone)) { // and the file matches the function
result.push(fileClone); result.push(fileClone);
} }
} }
return result; return result;
}, },
/** /**
* Add a file to the zip file, or search a file. * 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), * @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. * 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 {String|ArrayBuffer|Uint8Array|Buffer} data The file data, either raw or base64 encoded
* @param {Object} o File options * @param {Object} o File options
* @return {JSZip|Object|Array} this JSZip object (when adding a file), * @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). * a file (when searching by string) or an array of files (when searching by regex).
*/ */
file : function(name, data, o) { file: function(name, data, o) {
if (arguments.length === 1) { if (arguments.length === 1) {
if (JSZip.utils.isRegExp(name)) { if (utils.isRegExp(name)) {
var regexp = name; var regexp = name;
return this.filter(function(relativePath, file) { return this.filter(function(relativePath, file) {
return !file.options.dir && regexp.test(relativePath); return !file.options.dir && regexp.test(relativePath);
}); });
} else { // text
return this.filter(function (relativePath, file) {
return !file.options.dir && relativePath === name;
})[0]||null;
} }
} else { // more than one argument : we have data ! else { // text
name = this.root+name; return this.filter(function(relativePath, file) {
return !file.options.dir && relativePath === name;
})[0] || null;
}
}
else { // more than one argument : we have data !
name = this.root + name;
fileAdd.call(this, name, data, o); fileAdd.call(this, name, data, o);
} }
return this; return this;
}, },
/** /**
* Add a directory to the zip file, or search. * 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. * @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. * @return {JSZip} an object with the new directory as the root, or an array containing matching folders.
*/ */
folder : function(arg) { folder: function(arg) {
if (!arg) { if (!arg) {
return this; return this;
} }
if (JSZip.utils.isRegExp(arg)) { if (utils.isRegExp(arg)) {
return this.filter(function(relativePath, file) { return this.filter(function(relativePath, file) {
return file.options.dir && arg.test(relativePath); return file.options.dir && arg.test(relativePath);
}); });
} }
// else, name is a new folder // else, name is a new folder
var name = this.root + arg; var name = this.root + arg;
var newFolder = folderAdd.call(this, name); var newFolder = folderAdd.call(this, name);
// Allow chaining by returning a new object with this folder as the root // Allow chaining by returning a new object with this folder as the root
var ret = this.clone(); var ret = this.clone();
ret.root = newFolder.name; ret.root = newFolder.name;
return ret; return ret;
}, },
/** /**
* Delete a file, or a directory and all sub-files, from the zip * Delete a file, or a directory and all sub-files, from the zip
* @param {string} name the name of the file to delete * @param {string} name the name of the file to delete
* @return {JSZip} this JSZip object * @return {JSZip} this JSZip object
*/ */
remove : function(name) { remove: function(name) {
name = this.root + name; name = this.root + name;
var file = this.files[name]; var file = this.files[name];
if (!file) { if (!file) {
// Look for any folders // Look for any folders
if (name.slice(-1) != "/") { if (name.slice(-1) != "/") {
name += "/"; name += "/";
} }
file = this.files[name]; file = this.files[name];
} }
if (file) { if (file) {
if (!file.options.dir) { if (!file.options.dir) {
// file // file
delete this.files[name]; 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];
}
} }
} 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; return this;
}, },
/** /**
* Generate the complete zip file * Generate the complete zip file
* @param {Object} options the options to generate the zip file : * @param {Object} options the options to generate the zip file :
* - base64, (deprecated, use type instead) true to generate base64. * - base64, (deprecated, use type instead) true to generate base64.
* - compression, "STORE" by default. * - compression, "STORE" by default.
* - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob. * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
* @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
*/ */
generate : function(options) { generate: function(options) {
options = extend(options || {}, { options = extend(options || {}, {
base64 : true, base64: true,
compression : "STORE", compression: "STORE",
type : "base64" type: "base64"
}); });
JSZip.utils.checkSupport(options.type); utils.checkSupport(options.type);
var zipData = [], localDirLength = 0, centralDirLength = 0, writer, i; var zipData = [],
localDirLength = 0,
centralDirLength = 0,
writer, i;
// first, generate all the zip parts. // first, generate all the zip parts.
for (var name in this.files) { for (var name in this.files) {
if ( !this.files.hasOwnProperty(name) ) { continue; } if (!this.files.hasOwnProperty(name)) {
continue;
}
var file = this.files[name]; var file = this.files[name];
var compressionName = file.options.compression || options.compression.toUpperCase(); var compressionName = file.options.compression || options.compression.toUpperCase();
var compression = JSZip.compressions[compressionName]; var compression = compressions[compressionName];
if (!compression) { if (!compression) {
throw new Error(compressionName + " is not a valid compression method !"); throw new Error(compressionName + " is not a valid compression method !");
} }
var compressedObject = generateCompressedObjectFrom.call(this, file, compression); var compressedObject = generateCompressedObjectFrom.call(this, file, compression);
@ -731,418 +1015,510 @@ JSZip.prototype = (function () {
localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize; localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize;
centralDirLength += zipPart.dirRecord.length; centralDirLength += zipPart.dirRecord.length;
zipData.push(zipPart); zipData.push(zipPart);
} }
var dirEnd = ""; var dirEnd = "";
// end of central dir signature // end of central dir signature
dirEnd = JSZip.signature.CENTRAL_DIRECTORY_END + dirEnd = signature.CENTRAL_DIRECTORY_END +
// number of this disk // number of this disk
"\x00\x00" + "\x00\x00" +
// number of the disk with the start of the central directory // number of the disk with the start of the central directory
"\x00\x00" + "\x00\x00" +
// total number of entries in the central directory on this disk // total number of entries in the central directory on this disk
decToHex(zipData.length, 2) + decToHex(zipData.length, 2) +
// total number of entries in the central directory // total number of entries in the central directory
decToHex(zipData.length, 2) + decToHex(zipData.length, 2) +
// size of the central directory 4 bytes // size of the central directory 4 bytes
decToHex(centralDirLength, 4) + decToHex(centralDirLength, 4) +
// offset of start of central directory with respect to the starting disk number // offset of start of central directory with respect to the starting disk number
decToHex(localDirLength, 4) + decToHex(localDirLength, 4) +
// .ZIP file comment length // .ZIP file comment length
"\x00\x00"; "\x00\x00";
// we have all the parts (and the total length) // we have all the parts (and the total length)
// time to create a writer ! // time to create a writer !
switch(options.type.toLowerCase()) { var typeName = options.type.toLowerCase();
case "uint8array" : if(typeName==="uint8array"||typeName==="arraybuffer"||typeName==="blob"||typeName==="nodebuffer") {
case "arraybuffer" : writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length);
case "blob" : }else{
case "nodebuffer" : writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length);
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++) { for (i = 0; i < zipData.length; i++) {
writer.append(zipData[i].fileRecord); writer.append(zipData[i].fileRecord);
writer.append(zipData[i].compressedObject.compressedContent); writer.append(zipData[i].compressedObject.compressedContent);
} }
for (i = 0; i < zipData.length; i++) { for (i = 0; i < zipData.length; i++) {
writer.append(zipData[i].dirRecord); writer.append(zipData[i].dirRecord);
} }
writer.append(dirEnd); writer.append(dirEnd);
var zip = writer.finalize(); var zip = writer.finalize();
switch(options.type.toLowerCase()) { switch(options.type.toLowerCase()) {
// case "zip is an Uint8Array" // case "zip is an Uint8Array"
case "uint8array" : case "uint8array" :
case "arraybuffer" : case "arraybuffer" :
case "nodebuffer" : case "nodebuffer" :
return JSZip.utils.transformTo(options.type.toLowerCase(), zip); return utils.transformTo(options.type.toLowerCase(), zip);
case "blob" : case "blob" :
return JSZip.utils.arrayBuffer2Blob(JSZip.utils.transformTo("arraybuffer", zip)); return utils.arrayBuffer2Blob(utils.transformTo("arraybuffer", zip));
// case "zip is a string" // case "zip is a string"
case "base64" : case "base64" :
return (options.base64) ? JSZip.base64.encode(zip) : zip; return (options.base64) ? base64.encode(zip) : zip;
default : // case "string" : default : // case "string" :
return zip; return zip;
} }
},
/** },
*
* Javascript crc32 /**
* http://www.webtoolkit.info/ *
* * Javascript crc32
*/ * http://www.webtoolkit.info/
crc32 : function crc32(input, crc) { *
if (typeof input === "undefined" || !input.length) { */
crc32: function crc32(input, crc) {
if (typeof input === "undefined" || !input.length) {
return 0; return 0;
} }
var isArray = JSZip.utils.getTypeOf(input) !== "string"; var isArray = utils.getTypeOf(input) !== "string";
var table = [ var table = [
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D];
];
if (typeof(crc) == "undefined") { crc = 0; } if (typeof(crc) == "undefined") {
var x = 0; crc = 0;
var y = 0; }
var byte = 0; var x = 0;
var y = 0;
var b = 0;
crc = crc ^ (-1); crc = crc ^ (-1);
for( var i = 0, iTop = input.length; i < iTop; i++ ) { for (var i = 0, iTop = input.length; i < iTop; i++) {
byte = isArray ? input[i] : input.charCodeAt(i); b = isArray ? input[i] : input.charCodeAt(i);
y = ( crc ^ byte ) & 0xFF; y = (crc ^ b) & 0xFF;
x = table[y]; x = table[y];
crc = ( crc >>> 8 ) ^ x; crc = (crc >>> 8) ^ x;
} }
return crc ^ (-1); return crc ^ (-1);
}, },
// Inspired by http://my.opera.com/GreyWyvern/blog/show.dml/1725165 // 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
* http://www.webtoolkit.info/javascript-utf8.html */
*/ utf8encode: function(string) {
utf8encode : function (string) { // TextEncoder + Uint8Array to binary string is faster than checking every bytes on long strings.
// TextEncoder + Uint8Array to binary string is faster than checking every bytes on long strings. // http://jsperf.com/utf8encode-vs-textencoder
// http://jsperf.com/utf8encode-vs-textencoder // On short strings (file names for example), the TextEncoder API is (currently) slower.
// On short strings (file names for example), the TextEncoder API is (currently) slower. if (textEncoder) {
if (textEncoder) {
var u8 = textEncoder.encode(string); var u8 = textEncoder.encode(string);
return JSZip.utils.transformTo("string", u8); return utils.transformTo("string", u8);
} }
if (JSZip.support.nodebuffer) { if (support.nodebuffer) {
return JSZip.utils.transformTo("string", new Buffer(string, "utf-8")); return utils.transformTo("string", nodeBuffer(string, "utf-8"));
} }
// array.join may be slower than string concatenation but generates less objects (less time spent garbage collecting). // 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 // See also http://jsperf.com/array-direct-assignment-vs-push/31
var result = [], resIndex = 0; var result = [],
resIndex = 0;
for (var n = 0; n < string.length; n++) { for (var n = 0; n < string.length; n++) {
var c = string.charCodeAt(n); var c = string.charCodeAt(n);
if (c < 128) { if (c < 128) {
result[resIndex++] = String.fromCharCode(c); result[resIndex++] = String.fromCharCode(c);
} else if ((c > 127) && (c < 2048)) { }
result[resIndex++] = String.fromCharCode((c >> 6) | 192); else if ((c > 127) && (c < 2048)) {
result[resIndex++] = String.fromCharCode((c & 63) | 128); result[resIndex++] = String.fromCharCode((c >> 6) | 192);
} else { result[resIndex++] = String.fromCharCode((c & 63) | 128);
result[resIndex++] = String.fromCharCode((c >> 12) | 224); }
result[resIndex++] = String.fromCharCode(((c >> 6) & 63) | 128); else {
result[resIndex++] = String.fromCharCode((c & 63) | 128); 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(""); return result.join("");
}, },
/** /**
* http://www.webtoolkit.info/javascript-utf8.html * http://www.webtoolkit.info/javascript-utf8.html
*/ */
utf8decode : function (input) { utf8decode: function(input) {
var result = [], resIndex = 0; var result = [],
var type = JSZip.utils.getTypeOf(input); resIndex = 0;
var isArray = type !== "string"; var type = utils.getTypeOf(input);
var i = 0; var isArray = type !== "string";
var c = 0, c1 = 0, c2 = 0, c3 = 0; var i = 0;
var c = 0,
c1 = 0,
c2 = 0,
c3 = 0;
// check if we can use the TextDecoder API // check if we can use the TextDecoder API
// see http://encoding.spec.whatwg.org/#api // see http://encoding.spec.whatwg.org/#api
if (textDecoder) { if (textDecoder) {
return textDecoder.decode( return textDecoder.decode(
JSZip.utils.transformTo("uint8array", input) utils.transformTo("uint8array", input)
); );
} }
if (JSZip.support.nodebuffer) { if (support.nodebuffer) {
return JSZip.utils.transformTo("nodebuffer", input).toString("utf-8"); return utils.transformTo("nodebuffer", input).toString("utf-8");
} }
while ( i < input.length ) { while (i < input.length) {
c = isArray ? input[i] : input.charCodeAt(i); c = isArray ? input[i] : input.charCodeAt(i);
if (c < 128) { if (c < 128) {
result[resIndex++] = String.fromCharCode(c); result[resIndex++] = String.fromCharCode(c);
i++; i++;
} else if ((c > 191) && (c < 224)) { }
c2 = isArray ? input[i+1] : input.charCodeAt(i+1); else if ((c > 191) && (c < 224)) {
result[resIndex++] = String.fromCharCode(((c & 31) << 6) | (c2 & 63)); c2 = isArray ? input[i + 1] : input.charCodeAt(i + 1);
i += 2; result[resIndex++] = String.fromCharCode(((c & 31) << 6) | (c2 & 63));
} else { i += 2;
c2 = isArray ? input[i+1] : input.charCodeAt(i+1); }
c3 = isArray ? input[i+2] : input.charCodeAt(i+2); else {
result[resIndex++] = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)); c2 = isArray ? input[i + 1] : input.charCodeAt(i + 1);
i += 3; 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(""); return result.join("");
} }
}; };
}()); module.exports = out;
/* },{"./base64":1,"./compressedObject":2,"./compressions":3,"./defaults":5,"./nodeBuffer":18,"./signature":11,"./support":13,"./utils":15}],11:[function(require,module,exports){
* Compression methods 'use strict';
* This object is filled in as follow : exports.LOCAL_FILE_HEADER = "PK\x03\x04";
* name : { exports.CENTRAL_FILE_HEADER = "PK\x01\x02";
* magic // the 2 bytes indentifying the compression method exports.CENTRAL_DIRECTORY_END = "PK\x05\x06";
* compress // function, take the uncompressed content and return it compressed. exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
* uncompress // function, take the compressed content and return it uncompressed. exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
* compressInputType // string, the type accepted by the compress method. null to accept everything. exports.DATA_DESCRIPTOR = "PK\x07\x08";
* uncompressInputType // string, the type accepted by the uncompress method. null to accept everything.
* } },{}],12:[function(require,module,exports){
* 'use strict';
* STORE is the default compression method, so it's included in this file. var DataReader = require('./dataReader');
* Other methods should go to separated files : the user wants modularity. var utils = require('./utils');
function StringReader(data, optimizedBinaryString) {
this.data = data;
if (!optimizedBinaryString) {
this.data = utils.string2binary(this.data);
}
this.length = this.data.length;
this.index = 0;
}
StringReader.prototype = new DataReader();
/**
* @see DataReader.byteAt
*/ */
JSZip.compressions = { StringReader.prototype.byteAt = function(i) {
"STORE" : { return this.data.charCodeAt(i);
magic : "\x00\x00", };
compress : function (content) { /**
return content; // no compression * @see DataReader.lastIndexOfSignature
}, */
uncompress : function (content) { StringReader.prototype.lastIndexOfSignature = function(sig) {
return content; // no compression return this.data.lastIndexOf(sig);
}, };
compressInputType : null, /**
uncompressInputType : null * @see DataReader.readData
} */
StringReader.prototype.readData = function(size) {
this.checkOffset(size);
// this will work because the constructor applied the "& 0xff" mask.
var result = this.data.slice(this.index, this.index + size);
this.index += size;
return result;
};
module.exports = StringReader;
},{"./dataReader":4,"./utils":15}],13:[function(require,module,exports){
var process=require("__browserify_process");'use strict';
exports.base64 = true;
exports.array = true;
exports.string = true;
exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
// contains true if JSZip can read/generate nodejs Buffer, false otherwise, aka checks if we arn't in a browser.
exports.nodebuffer = !process.browser;
// contains true if JSZip can read/generate Uint8Array, false otherwise.
exports.uint8array = typeof Uint8Array !== "undefined";
if (typeof ArrayBuffer === "undefined") {
exports.blob = false;
}
else {
var buffer = new ArrayBuffer(0);
try {
exports.blob = new Blob([buffer], {
type: "application/zip"
}).size === 0;
}
catch (e) {
try {
var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
var builder = new Builder();
builder.append(buffer);
exports.blob = builder.getBlob('application/zip').size === 0;
}
catch (e) {
exports.blob = false;
}
}
}
},{"__browserify_process":19}],14:[function(require,module,exports){
'use strict';
var DataReader = require('./dataReader');
function Uint8ArrayReader(data) {
if (data) {
this.data = data;
this.length = this.data.length;
this.index = 0;
}
}
Uint8ArrayReader.prototype = new DataReader();
/**
* @see DataReader.byteAt
*/
Uint8ArrayReader.prototype.byteAt = function(i) {
return this.data[i];
};
/**
* @see DataReader.lastIndexOfSignature
*/
Uint8ArrayReader.prototype.lastIndexOfSignature = function(sig) {
var sig0 = sig.charCodeAt(0),
sig1 = sig.charCodeAt(1),
sig2 = sig.charCodeAt(2),
sig3 = sig.charCodeAt(3);
for (var i = this.length - 4; i >= 0; --i) {
if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
return i;
}
}
return -1;
};
/**
* @see DataReader.readData
*/
Uint8ArrayReader.prototype.readData = function(size) {
this.checkOffset(size);
var result = this.data.subarray(this.index, this.index + size);
this.index += size;
return result;
};
module.exports = Uint8ArrayReader;
},{"./dataReader":4}],15:[function(require,module,exports){
'use strict';
var support = require('./support');
var compressions = require('./compressions');
var nodeBuffer = require('./nodeBuffer');
/**
* Convert a string to a "binary string" : a string containing only char codes between 0 and 255.
* @param {string} str the string to transform.
* @return {String} the binary string.
*/
exports.string2binary = function(str) {
var result = "";
for (var i = 0; i < str.length; i++) {
result += String.fromCharCode(str.charCodeAt(i) & 0xff);
}
return result;
};
/**
* Create a Uint8Array from the string.
* @param {string} str the string to transform.
* @return {Uint8Array} the typed array.
* @throws {Error} an Error if the browser doesn't support the requested feature.
*/
exports.string2Uint8Array = function(str) {
return exports.transformTo("uint8array", str);
}; };
(function () { /**
JSZip.utils = { * Create a string from the Uint8Array.
/** * @param {Uint8Array} array the array to transform.
* Convert a string to a "binary string" : a string containing only char codes between 0 and 255. * @return {string} the string.
* @param {string} str the string to transform. * @throws {Error} an Error if the browser doesn't support the requested feature.
* @return {String} the binary string. */
*/ exports.uint8Array2String = function(array) {
string2binary : function (str) { return exports.transformTo("string", array);
var result = ""; };
for (var i = 0; i < str.length; i++) { /**
result += String.fromCharCode(str.charCodeAt(i) & 0xff); * Create a blob from the given string.
} * @param {string} str the string to transform.
return result; * @return {Blob} the string.
}, * @throws {Error} an Error if the browser doesn't support the requested feature.
/** */
* Create a Uint8Array from the string. exports.string2Blob = function(str) {
* @param {string} str the string to transform. var buffer = exports.transformTo("arraybuffer", str);
* @return {Uint8Array} the typed array. return exports.arrayBuffer2Blob(buffer);
* @throws {Error} an Error if the browser doesn't support the requested feature. };
* @deprecated : use JSZip.utils.transformTo instead. exports.arrayBuffer2Blob = function(buffer) {
*/ exports.checkSupport("blob");
string2Uint8Array : function (str) {
return JSZip.utils.transformTo("uint8array", str);
},
/** try {
* Create a string from the Uint8Array. // Blob constructor
* @param {Uint8Array} array the array to transform. return new Blob([buffer], {
* @return {string} the string. type: "application/zip"
* @throws {Error} an Error if the browser doesn't support the requested feature. });
* @deprecated : use JSZip.utils.transformTo instead. }
*/ catch (e) {
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 { try {
// Blob constructor
return new Blob([buffer], { type: "application/zip" });
}
catch(e) {}
try {
// deprecated, browser only, old way // deprecated, browser only, old way
var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder; var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
var builder = new BlobBuilder(); var builder = new Builder();
builder.append(buffer); builder.append(buffer);
return builder.getBlob('application/zip'); return builder.getBlob('application/zip');
} }
catch(e) {} catch (e) {
// well, fuck ?! // well, fuck ?!
throw new Error("Bug : can't construct the Blob."); 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. * The identity function.
* @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated). * @param {Object} input the input.
* @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array. * @return {Object} the same input.
*/ */
function stringToArrayLike(str, array) { function identity(input) {
for (var i = 0; i < str.length; ++i) { return input;
array[i] = str.charCodeAt(i) & 0xFF; }
}
return array;
}
/** /**
* Transform an array-like object to a string. * Fill in an array with a string.
* @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform. * @param {String} str the string to use.
* @return {String} the result. * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
*/ * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
function arrayLikeToString(array) { */
// Performances notes : function stringToArrayLike(str, array) {
// -------------------- for (var i = 0; i < str.length; ++i) {
// String.fromCharCode.apply(null, array) is the fastest, see array[i] = str.charCodeAt(i) & 0xFF;
// see http://jsperf.com/converting-a-uint8array-to-a-string/2 }
// but the stack is limited (and we can get huge arrays !). return array;
// }
// 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; /**
* 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 = exports.getTypeOf(array),
k = 0,
canUseApply = true;
try { try {
switch(type) { switch(type) {
case "uint8array": case "uint8array":
String.fromCharCode.apply(null, new Uint8Array(0)); String.fromCharCode.apply(null, new Uint8Array(0));
break; break;
case "nodebuffer": case "nodebuffer":
String.fromCharCode.apply(null, new Buffer(0)); String.fromCharCode.apply(null, nodeBuffer(0));
break; break;
} }
} catch(e) { } catch(e) {
@ -1156,319 +1532,744 @@ JSZip.compressions = {
for(var i = 0; i < array.length;i++) { for(var i = 0; i < array.length;i++) {
resultStr += String.fromCharCode(array[i]); resultStr += String.fromCharCode(array[i]);
} }
return resultStr; return resultStr;
} }
while (k < len && chunk > 1) {
while (k < len && chunk > 1) { try {
try {
if (type === "array" || type === "nodebuffer") { if (type === "array" || type === "nodebuffer") {
result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len)))); 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)))); else {
result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
} }
k += chunk; k += chunk;
} catch (e) { }
catch (e) {
chunk = Math.floor(chunk / 2); chunk = Math.floor(chunk / 2);
} }
} }
return result.join(""); 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
}
};
})();
/** /**
* * Copy the data from an array-like to an other array-like.
* Base64 encode / decode * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
* http://www.webtoolkit.info/ * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
* * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
* Hacked so that it doesn't utf8 en/decode everything */
**/ function arrayLikeToArrayLike(arrayFrom, arrayTo) {
JSZip.base64 = (function() { for (var i = 0; i < arrayFrom.length; i++) {
// private property arrayTo[i] = arrayFrom[i];
var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; }
return arrayTo;
}
return { // a matrix containing functions to transform everything into everything.
// public method for encoding var transform = {};
encode : function(input, utf8) {
var output = "";
var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
var i = 0;
while (i < input.length) { // 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, nodeBuffer(input.length));
}
};
chr1 = input.charCodeAt(i++); // array to ?
chr2 = input.charCodeAt(i++); transform["array"] = {
chr3 = input.charCodeAt(i++); "string": arrayLikeToString,
"array": identity,
"arraybuffer": function(input) {
return (new Uint8Array(input)).buffer;
},
"uint8array": function(input) {
return new Uint8Array(input);
},
"nodebuffer": function(input) {
return nodeBuffer(input);
}
};
enc1 = chr1 >> 2; // arraybuffer to ?
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4); transform["arraybuffer"] = {
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6); "string": function(input) {
enc4 = chr3 & 63; 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 nodeBuffer(new Uint8Array(input));
}
};
if (isNaN(chr2)) { // uint8array to ?
enc3 = enc4 = 64; transform["uint8array"] = {
} else if (isNaN(chr3)) { "string": arrayLikeToString,
enc4 = 64; "array": function(input) {
return arrayLikeToArrayLike(input, new Array(input.length));
},
"arraybuffer": function(input) {
return input.buffer;
},
"uint8array": identity,
"nodebuffer": function(input) {
return nodeBuffer(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.
*/
exports.transformTo = function(outputType, input) {
if (!input) {
// undefined, null, etc
// an empty string won't harm.
input = "";
}
if (!outputType) {
return input;
}
exports.checkSupport(outputType);
var inputType = exports.getTypeOf(input);
var result = transform[inputType][outputType](input);
return result;
};
/**
* Return the type of the input.
* The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
* @param {Object} input the input to identify.
* @return {String} the (lowercase) type of the input.
*/
exports.getTypeOf = function(input) {
if (typeof input === "string") {
return "string";
}
if (Object.prototype.toString.call(input) === "[object Array]") {
return "array";
}
if (support.nodebuffer && nodeBuffer.test(input)) {
return "nodebuffer";
}
if (support.uint8array && input instanceof Uint8Array) {
return "uint8array";
}
if (support.arraybuffer && input instanceof ArrayBuffer) {
return "arraybuffer";
}
};
/**
* 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.
*/
exports.checkSupport = function(type) {
var supported = support[type.toLowerCase()];
if (!supported) {
throw new Error(type + " is not supported by this browser");
}
};
exports.MAX_VALUE_16BITS = 65535;
exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1
/**
* Prettify a string read as binary.
* @param {string} str the string to prettify.
* @return {string} a pretty string.
*/
exports.pretty = function(str) {
var res = '',
code, i;
for (i = 0; i < (str || "").length; i++) {
code = str.charCodeAt(i);
res += '\\x' + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
}
return res;
};
/**
* Find a compression registered in JSZip.
* @param {string} compressionMethod the method magic to find.
* @return {Object|null} the JSZip compression object, null if none found.
*/
exports.findCompression = function(compressionMethod) {
for (var method in compressions) {
if (!compressions.hasOwnProperty(method)) {
continue;
}
if (compressions[method].magic === compressionMethod) {
return compressions[method];
}
}
return null;
};
/**
* Cross-window, cross-Node-context regular expression detection
* @param {Object} object Anything
* @return {Boolean} true if the object is a regular expression,
* false otherwise
*/
exports.isRegExp = function (object) {
return Object.prototype.toString.call(object) === "[object RegExp]";
};
},{"./compressions":3,"./nodeBuffer":18,"./support":13}],16:[function(require,module,exports){
'use strict';
var StringReader = require('./stringReader');
var NodeBufferReader = require('./nodeBufferReader');
var Uint8ArrayReader = require('./uint8ArrayReader');
var utils = require('./utils');
var sig = require('./signature');
var ZipEntry = require('./zipEntry');
var support = require('./support');
// class ZipEntries {{{
/**
* All the entries in the zip file.
* @constructor
* @param {String|ArrayBuffer|Uint8Array} data the binary stream to load.
* @param {Object} loadOptions Options for loading the stream.
*/
function ZipEntries(data, loadOptions) {
this.files = [];
this.loadOptions = loadOptions;
if (data) {
this.load(data);
}
}
ZipEntries.prototype = {
/**
* Check that the reader is on the speficied signature.
* @param {string} expectedSignature the expected signature.
* @throws {Error} if it is an other signature.
*/
checkSignature: function(expectedSignature) {
var signature = this.reader.readString(4);
if (signature !== expectedSignature) {
throw new Error("Corrupted zip or bug : unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
}
},
/**
* Read the end of the central directory.
*/
readBlockEndOfCentral: function() {
this.diskNumber = this.reader.readInt(2);
this.diskWithCentralDirStart = this.reader.readInt(2);
this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
this.centralDirRecords = this.reader.readInt(2);
this.centralDirSize = this.reader.readInt(4);
this.centralDirOffset = this.reader.readInt(4);
this.zipCommentLength = this.reader.readInt(2);
this.zipComment = this.reader.readString(this.zipCommentLength);
},
/**
* Read the end of the Zip 64 central directory.
* Not merged with the method readEndOfCentral :
* The end of central can coexist with its Zip64 brother,
* I don't want to read the wrong number of bytes !
*/
readBlockZip64EndOfCentral: function() {
this.zip64EndOfCentralSize = this.reader.readInt(8);
this.versionMadeBy = this.reader.readString(2);
this.versionNeeded = this.reader.readInt(2);
this.diskNumber = this.reader.readInt(4);
this.diskWithCentralDirStart = this.reader.readInt(4);
this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
this.centralDirRecords = this.reader.readInt(8);
this.centralDirSize = this.reader.readInt(8);
this.centralDirOffset = this.reader.readInt(8);
this.zip64ExtensibleData = {};
var extraDataSize = this.zip64EndOfCentralSize - 44,
index = 0,
extraFieldId,
extraFieldLength,
extraFieldValue;
while (index < extraDataSize) {
extraFieldId = this.reader.readInt(2);
extraFieldLength = this.reader.readInt(4);
extraFieldValue = this.reader.readString(extraFieldLength);
this.zip64ExtensibleData[extraFieldId] = {
id: extraFieldId,
length: extraFieldLength,
value: extraFieldValue
};
}
},
/**
* Read the end of the Zip 64 central directory locator.
*/
readBlockZip64EndOfCentralLocator: function() {
this.diskWithZip64CentralDirStart = this.reader.readInt(4);
this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
this.disksCount = this.reader.readInt(4);
if (this.disksCount > 1) {
throw new Error("Multi-volumes zip are not supported");
}
},
/**
* Read the local files, based on the offset read in the central part.
*/
readLocalFiles: function() {
var i, file;
for (i = 0; i < this.files.length; i++) {
file = this.files[i];
this.reader.setIndex(file.localHeaderOffset);
this.checkSignature(sig.LOCAL_FILE_HEADER);
file.readLocalPart(this.reader);
file.handleUTF8();
}
},
/**
* Read the central directory.
*/
readCentralDir: function() {
var file;
this.reader.setIndex(this.centralDirOffset);
while (this.reader.readString(4) === sig.CENTRAL_FILE_HEADER) {
file = new ZipEntry({
zip64: this.zip64
}, this.loadOptions);
file.readCentralPart(this.reader);
this.files.push(file);
}
},
/**
* Read the end of central directory.
*/
readEndOfCentral: function() {
var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
if (offset === -1) {
throw new Error("Corrupted zip : can't find end of central directory");
}
this.reader.setIndex(offset);
this.checkSignature(sig.CENTRAL_DIRECTORY_END);
this.readBlockEndOfCentral();
/* extract from the zip spec :
4) If one of the fields in the end of central directory
record is too small to hold required data, the field
should be set to -1 (0xFFFF or 0xFFFFFFFF) and the
ZIP64 format record should be created.
5) The end of central directory record and the
Zip64 end of central directory locator record must
reside on the same disk when splitting or spanning
an archive.
*/
if (this.diskNumber === utils.MAX_VALUE_16BITS || this.diskWithCentralDirStart === utils.MAX_VALUE_16BITS || this.centralDirRecordsOnThisDisk === utils.MAX_VALUE_16BITS || this.centralDirRecords === utils.MAX_VALUE_16BITS || this.centralDirSize === utils.MAX_VALUE_32BITS || this.centralDirOffset === utils.MAX_VALUE_32BITS) {
this.zip64 = true;
/*
Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from
the zip file can fit into a 32bits integer. This cannot be solved : Javascript represents
all numbers as 64-bit double precision IEEE 754 floating point numbers.
So, we have 53bits for integers and bitwise operations treat everything as 32bits.
see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators
and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5
*/
// should look for a zip64 EOCD locator
offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
if (offset === -1) {
throw new Error("Corrupted zip : can't find the ZIP64 end of central directory locator");
}
this.reader.setIndex(offset);
this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
this.readBlockZip64EndOfCentralLocator();
// now the zip64 EOCD record
this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
this.readBlockZip64EndOfCentral();
}
},
prepareReader: function(data) {
var type = utils.getTypeOf(data);
if (type === "string" && !support.uint8array) {
this.reader = new StringReader(data, this.loadOptions.optimizedBinaryString);
}
else if (type === "nodebuffer") {
this.reader = new NodeBufferReader(data);
}
else {
this.reader = new Uint8ArrayReader(utils.transformTo("uint8array", data));
}
},
/**
* Read a zip file and create ZipEntries.
* @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
*/
load: function(data) {
this.prepareReader(data);
this.readEndOfCentral();
this.readCentralDir();
this.readLocalFiles();
}
};
// }}} end of ZipEntries
module.exports = ZipEntries;
},{"./nodeBufferReader":9,"./signature":11,"./stringReader":12,"./support":13,"./uint8ArrayReader":14,"./utils":15,"./zipEntry":17}],17:[function(require,module,exports){
'use strict';
var StringReader = require('./stringReader');
var utils = require('./utils');
var CompressedObject = require('./compressedObject');
var jszipProto = require('./object');
// class ZipEntry {{{
/**
* An entry in the zip file.
* @constructor
* @param {Object} options Options of the current file.
* @param {Object} loadOptions Options for loading the stream.
*/
function ZipEntry(options, loadOptions) {
this.options = options;
this.loadOptions = loadOptions;
}
ZipEntry.prototype = {
/**
* say if the file is encrypted.
* @return {boolean} true if the file is encrypted, false otherwise.
*/
isEncrypted: function() {
// bit 1 is set
return (this.bitFlag & 0x0001) === 0x0001;
},
/**
* say if the file has utf-8 filename/comment.
* @return {boolean} true if the filename/comment is in utf-8, false otherwise.
*/
useUTF8: function() {
// bit 11 is set
return (this.bitFlag & 0x0800) === 0x0800;
},
/**
* Prepare the function used to generate the compressed content from this ZipFile.
* @param {DataReader} reader the reader to use.
* @param {number} from the offset from where we should read the data.
* @param {number} length the length of the data to read.
* @return {Function} the callback to get the compressed content (the type depends of the DataReader class).
*/
prepareCompressedContent: function(reader, from, length) {
return function() {
var previousIndex = reader.index;
reader.setIndex(from);
var compressedFileData = reader.readData(length);
reader.setIndex(previousIndex);
return compressedFileData;
};
},
/**
* Prepare the function used to generate the uncompressed content from this ZipFile.
* @param {DataReader} reader the reader to use.
* @param {number} from the offset from where we should read the data.
* @param {number} length the length of the data to read.
* @param {JSZip.compression} compression the compression used on this file.
* @param {number} uncompressedSize the uncompressed size to expect.
* @return {Function} the callback to get the uncompressed content (the type depends of the DataReader class).
*/
prepareContent: function(reader, from, length, compression, uncompressedSize) {
return function() {
var compressedFileData = utils.transformTo(compression.uncompressInputType, this.getCompressedContent());
var uncompressedFileData = compression.uncompress(compressedFileData);
if (uncompressedFileData.length !== uncompressedSize) {
throw new Error("Bug : uncompressed data size mismatch");
} }
output = output + return uncompressedFileData;
_keyStr.charAt(enc1) + _keyStr.charAt(enc2) + };
_keyStr.charAt(enc3) + _keyStr.charAt(enc4); },
/**
* Read the local part of a zip file and add the info in this object.
* @param {DataReader} reader the reader to use.
*/
readLocalPart: function(reader) {
var compression, localExtraFieldsLength;
} // we already know everything from the central dir !
// If the central dir data are false, we are doomed.
// On the bright side, the local part is scary : zip64, data descriptors, both, etc.
// The less data we get here, the more reliable this should be.
// Let's skip the whole header and dash to the data !
reader.skip(22);
// in some zip created on windows, the filename stored in the central dir contains \ instead of /.
// Strangely, the filename here is OK.
// I would love to treat these zip files as corrupted (see http://www.info-zip.org/FAQ.html#backslashes
// or APPNOTE#4.4.17.1, "All slashes MUST be forward slashes '/'") but there are a lot of bad zip generators...
// Search "unzip mismatching "local" filename continuing with "central" filename version" on
// the internet.
//
// I think I see the logic here : the central directory is used to display
// content and the local directory is used to extract the files. Mixing / and \
// may be used to display \ to windows users and use / when extracting the files.
// Unfortunately, this lead also to some issues : http://seclists.org/fulldisclosure/2009/Sep/394
this.fileNameLength = reader.readInt(2);
localExtraFieldsLength = reader.readInt(2); // can't be sure this will be the same as the central dir
this.fileName = reader.readString(this.fileNameLength);
reader.skip(localExtraFieldsLength);
return output; if (this.compressedSize == -1 || this.uncompressedSize == -1) {
}, throw new Error("Bug or corrupted zip : didn't get enough informations from the central directory " + "(compressedSize == -1 || uncompressedSize == -1)");
}
// public method for decoding compression = utils.findCompression(this.compressionMethod);
decode : function(input, utf8) { if (compression === null) { // no compression found
var output = ""; throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + this.fileName + ")");
var chr1, chr2, chr3; }
var enc1, enc2, enc3, enc4; this.decompressed = new CompressedObject();
var i = 0; this.decompressed.compressedSize = this.compressedSize;
this.decompressed.uncompressedSize = this.uncompressedSize;
this.decompressed.crc32 = this.crc32;
this.decompressed.compressionMethod = this.compressionMethod;
this.decompressed.getCompressedContent = this.prepareCompressedContent(reader, reader.index, this.compressedSize, compression);
this.decompressed.getContent = this.prepareContent(reader, reader.index, this.compressedSize, compression, this.uncompressedSize);
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, ""); // we need to compute the crc32...
if (this.loadOptions.checkCRC32) {
while (i < input.length) { this.decompressed = utils.transformTo("string", this.decompressed.getContent());
if (jszipProto.crc32(this.decompressed) !== this.crc32) {
enc1 = _keyStr.indexOf(input.charAt(i++)); throw new Error("Corrupted zip : CRC32 mismatch");
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); },
/**
* Read the central part of a zip file and add the info in this object.
* @param {DataReader} reader the reader to use.
*/
readCentralPart: function(reader) {
this.versionMadeBy = reader.readString(2);
this.versionNeeded = reader.readInt(2);
this.bitFlag = reader.readInt(2);
this.compressionMethod = reader.readString(2);
this.date = reader.readDate();
this.crc32 = reader.readInt(4);
this.compressedSize = reader.readInt(4);
this.uncompressedSize = reader.readInt(4);
this.fileNameLength = reader.readInt(2);
this.extraFieldsLength = reader.readInt(2);
this.fileCommentLength = reader.readInt(2);
this.diskNumberStart = reader.readInt(2);
this.internalFileAttributes = reader.readInt(2);
this.externalFileAttributes = reader.readInt(4);
this.localHeaderOffset = reader.readInt(4);
if (this.isEncrypted()) {
throw new Error("Encrypted zip are not supported");
}
this.fileName = reader.readString(this.fileNameLength);
this.readExtraFields(reader);
this.parseZIP64ExtraField(reader);
this.fileComment = reader.readString(this.fileCommentLength);
// warning, this is true only for zip with madeBy == DOS (plateform dependent feature)
this.dir = this.externalFileAttributes & 0x00000010 ? true : false;
},
/**
* Parse the ZIP64 extra field and merge the info in the current ZipEntry.
* @param {DataReader} reader the reader to use.
*/
parseZIP64ExtraField: function(reader) {
if (!this.extraFields[0x0001]) {
return;
}
// should be something, preparing the extra reader
var extraReader = new StringReader(this.extraFields[0x0001].value);
// I really hope that these 64bits integer can fit in 32 bits integer, because js
// won't let us have more.
if (this.uncompressedSize === utils.MAX_VALUE_32BITS) {
this.uncompressedSize = extraReader.readInt(8);
}
if (this.compressedSize === utils.MAX_VALUE_32BITS) {
this.compressedSize = extraReader.readInt(8);
}
if (this.localHeaderOffset === utils.MAX_VALUE_32BITS) {
this.localHeaderOffset = extraReader.readInt(8);
}
if (this.diskNumberStart === utils.MAX_VALUE_32BITS) {
this.diskNumberStart = extraReader.readInt(4);
}
},
/**
* Read the central part of a zip file and add the info in this object.
* @param {DataReader} reader the reader to use.
*/
readExtraFields: function(reader) {
var start = reader.index,
extraFieldId,
extraFieldLength,
extraFieldValue;
this.extraFields = this.extraFields || {};
while (reader.index < start + this.extraFieldsLength) {
extraFieldId = reader.readInt(2);
extraFieldLength = reader.readInt(2);
extraFieldValue = reader.readString(extraFieldLength);
this.extraFields[extraFieldId] = {
id: extraFieldId,
length: extraFieldLength,
value: extraFieldValue
};
}
},
/**
* Apply an UTF8 transformation if needed.
*/
handleUTF8: function() {
if (this.useUTF8()) {
this.fileName = jszipProto.utf8decode(this.fileName);
this.fileComment = jszipProto.utf8decode(this.fileComment);
}
}
};
module.exports = ZipEntry;
},{"./compressedObject":2,"./object":10,"./stringReader":12,"./utils":15}],18:[function(require,module,exports){
},{}],19:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};
process.nextTick = (function () {
var canSetImmediate = typeof window !== 'undefined'
&& window.setImmediate;
var canPost = typeof window !== 'undefined'
&& window.postMessage && window.addEventListener
;
if (canSetImmediate) {
return function (f) { return window.setImmediate(f) };
}
if (canPost) {
var queue = [];
window.addEventListener('message', function (ev) {
if (ev.source === window && ev.data === 'process-tick') {
ev.stopPropagation();
if (queue.length > 0) {
var fn = queue.shift();
fn();
}
} }
}, true);
} return function nextTick(fn) {
queue.push(fn);
window.postMessage('process-tick', '*');
};
}
return output; return function nextTick(fn) {
setTimeout(fn, 0);
};
})();
} process.title = 'browser';
}; process.browser = true;
}()); process.env = {};
process.argv = [];
// enforcing Stuk's coding style process.binding = function (name) {
// vim: set shiftwidth=3 softtabstop=3: throw new Error('process.binding is not supported');
}
// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
},{}],20:[function(require,module,exports){
/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var n=void 0,u=!0,aa=this;function ba(e,d){var c=e.split("."),f=aa;!(c[0]in f)&&f.execScript&&f.execScript("var "+c[0]);for(var a;c.length&&(a=c.shift());)!c.length&&d!==n?f[a]=d:f=f[a]?f[a]:f[a]={}};var C="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array;function K(e,d){this.index="number"===typeof d?d:0;this.d=0;this.buffer=e instanceof(C?Uint8Array:Array)?e:new (C?Uint8Array:Array)(32768);if(2*this.buffer.length<=this.index)throw Error("invalid index");this.buffer.length<=this.index&&ca(this)}function ca(e){var d=e.buffer,c,f=d.length,a=new (C?Uint8Array:Array)(f<<1);if(C)a.set(d);else for(c=0;c<f;++c)a[c]=d[c];return e.buffer=a}
K.prototype.a=function(e,d,c){var f=this.buffer,a=this.index,b=this.d,k=f[a],m;c&&1<d&&(e=8<d?(L[e&255]<<24|L[e>>>8&255]<<16|L[e>>>16&255]<<8|L[e>>>24&255])>>32-d:L[e]>>8-d);if(8>d+b)k=k<<d|e,b+=d;else for(m=0;m<d;++m)k=k<<1|e>>d-m-1&1,8===++b&&(b=0,f[a++]=L[k],k=0,a===f.length&&(f=ca(this)));f[a]=k;this.buffer=f;this.d=b;this.index=a};K.prototype.finish=function(){var e=this.buffer,d=this.index,c;0<this.d&&(e[d]<<=8-this.d,e[d]=L[e[d]],d++);C?c=e.subarray(0,d):(e.length=d,c=e);return c};
var ga=new (C?Uint8Array:Array)(256),M;for(M=0;256>M;++M){for(var R=M,S=R,ha=7,R=R>>>1;R;R>>>=1)S<<=1,S|=R&1,--ha;ga[M]=(S<<ha&255)>>>0}var L=ga;function ja(e){this.buffer=new (C?Uint16Array:Array)(2*e);this.length=0}ja.prototype.getParent=function(e){return 2*((e-2)/4|0)};ja.prototype.push=function(e,d){var c,f,a=this.buffer,b;c=this.length;a[this.length++]=d;for(a[this.length++]=e;0<c;)if(f=this.getParent(c),a[c]>a[f])b=a[c],a[c]=a[f],a[f]=b,b=a[c+1],a[c+1]=a[f+1],a[f+1]=b,c=f;else break;return this.length};
ja.prototype.pop=function(){var e,d,c=this.buffer,f,a,b;d=c[0];e=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(b=0;;){a=2*b+2;if(a>=this.length)break;a+2<this.length&&c[a+2]>c[a]&&(a+=2);if(c[a]>c[b])f=c[b],c[b]=c[a],c[a]=f,f=c[b+1],c[b+1]=c[a+1],c[a+1]=f;else break;b=a}return{index:e,value:d,length:this.length}};function ka(e,d){this.e=ma;this.f=0;this.input=C&&e instanceof Array?new Uint8Array(e):e;this.c=0;d&&(d.lazy&&(this.f=d.lazy),"number"===typeof d.compressionType&&(this.e=d.compressionType),d.outputBuffer&&(this.b=C&&d.outputBuffer instanceof Array?new Uint8Array(d.outputBuffer):d.outputBuffer),"number"===typeof d.outputIndex&&(this.c=d.outputIndex));this.b||(this.b=new (C?Uint8Array:Array)(32768))}var ma=2,T=[],U;
for(U=0;288>U;U++)switch(u){case 143>=U:T.push([U+48,8]);break;case 255>=U:T.push([U-144+400,9]);break;case 279>=U:T.push([U-256+0,7]);break;case 287>=U:T.push([U-280+192,8]);break;default:throw"invalid literal: "+U;}
ka.prototype.h=function(){var e,d,c,f,a=this.input;switch(this.e){case 0:c=0;for(f=a.length;c<f;){d=C?a.subarray(c,c+65535):a.slice(c,c+65535);c+=d.length;var b=d,k=c===f,m=n,g=n,p=n,v=n,x=n,l=this.b,h=this.c;if(C){for(l=new Uint8Array(this.b.buffer);l.length<=h+b.length+5;)l=new Uint8Array(l.length<<1);l.set(this.b)}m=k?1:0;l[h++]=m|0;g=b.length;p=~g+65536&65535;l[h++]=g&255;l[h++]=g>>>8&255;l[h++]=p&255;l[h++]=p>>>8&255;if(C)l.set(b,h),h+=b.length,l=l.subarray(0,h);else{v=0;for(x=b.length;v<x;++v)l[h++]=
b[v];l.length=h}this.c=h;this.b=l}break;case 1:var q=new K(C?new Uint8Array(this.b.buffer):this.b,this.c);q.a(1,1,u);q.a(1,2,u);var t=na(this,a),w,da,z;w=0;for(da=t.length;w<da;w++)if(z=t[w],K.prototype.a.apply(q,T[z]),256<z)q.a(t[++w],t[++w],u),q.a(t[++w],5),q.a(t[++w],t[++w],u);else if(256===z)break;this.b=q.finish();this.c=this.b.length;break;case ma:var B=new K(C?new Uint8Array(this.b.buffer):this.b,this.c),ra,J,N,O,P,Ia=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],W,sa,X,ta,ea,ia=Array(19),
ua,Q,fa,y,va;ra=ma;B.a(1,1,u);B.a(ra,2,u);J=na(this,a);W=oa(this.j,15);sa=pa(W);X=oa(this.i,7);ta=pa(X);for(N=286;257<N&&0===W[N-1];N--);for(O=30;1<O&&0===X[O-1];O--);var wa=N,xa=O,F=new (C?Uint32Array:Array)(wa+xa),r,G,s,Y,E=new (C?Uint32Array:Array)(316),D,A,H=new (C?Uint8Array:Array)(19);for(r=G=0;r<wa;r++)F[G++]=W[r];for(r=0;r<xa;r++)F[G++]=X[r];if(!C){r=0;for(Y=H.length;r<Y;++r)H[r]=0}r=D=0;for(Y=F.length;r<Y;r+=G){for(G=1;r+G<Y&&F[r+G]===F[r];++G);s=G;if(0===F[r])if(3>s)for(;0<s--;)E[D++]=0,
H[0]++;else for(;0<s;)A=138>s?s:138,A>s-3&&A<s&&(A=s-3),10>=A?(E[D++]=17,E[D++]=A-3,H[17]++):(E[D++]=18,E[D++]=A-11,H[18]++),s-=A;else if(E[D++]=F[r],H[F[r]]++,s--,3>s)for(;0<s--;)E[D++]=F[r],H[F[r]]++;else for(;0<s;)A=6>s?s:6,A>s-3&&A<s&&(A=s-3),E[D++]=16,E[D++]=A-3,H[16]++,s-=A}e=C?E.subarray(0,D):E.slice(0,D);ea=oa(H,7);for(y=0;19>y;y++)ia[y]=ea[Ia[y]];for(P=19;4<P&&0===ia[P-1];P--);ua=pa(ea);B.a(N-257,5,u);B.a(O-1,5,u);B.a(P-4,4,u);for(y=0;y<P;y++)B.a(ia[y],3,u);y=0;for(va=e.length;y<va;y++)if(Q=
e[y],B.a(ua[Q],ea[Q],u),16<=Q){y++;switch(Q){case 16:fa=2;break;case 17:fa=3;break;case 18:fa=7;break;default:throw"invalid code: "+Q;}B.a(e[y],fa,u)}var ya=[sa,W],za=[ta,X],I,Aa,Z,la,Ba,Ca,Da,Ea;Ba=ya[0];Ca=ya[1];Da=za[0];Ea=za[1];I=0;for(Aa=J.length;I<Aa;++I)if(Z=J[I],B.a(Ba[Z],Ca[Z],u),256<Z)B.a(J[++I],J[++I],u),la=J[++I],B.a(Da[la],Ea[la],u),B.a(J[++I],J[++I],u);else if(256===Z)break;this.b=B.finish();this.c=this.b.length;break;default:throw"invalid compression type";}return this.b};
function qa(e,d){this.length=e;this.g=d}
var Fa=function(){function e(a){switch(u){case 3===a:return[257,a-3,0];case 4===a:return[258,a-4,0];case 5===a:return[259,a-5,0];case 6===a:return[260,a-6,0];case 7===a:return[261,a-7,0];case 8===a:return[262,a-8,0];case 9===a:return[263,a-9,0];case 10===a:return[264,a-10,0];case 12>=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272,
a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:throw"invalid length: "+a;}}var d=[],c,f;for(c=3;258>=c;c++)f=e(c),d[c]=f[2]<<24|
f[1]<<16|f[0];return d}(),Ga=C?new Uint32Array(Fa):Fa;
function na(e,d){function c(a,c){var b=a.g,d=[],f=0,e;e=Ga[a.length];d[f++]=e&65535;d[f++]=e>>16&255;d[f++]=e>>24;var g;switch(u){case 1===b:g=[0,b-1,0];break;case 2===b:g=[1,b-2,0];break;case 3===b:g=[2,b-3,0];break;case 4===b:g=[3,b-4,0];break;case 6>=b:g=[4,b-5,1];break;case 8>=b:g=[5,b-7,1];break;case 12>=b:g=[6,b-9,2];break;case 16>=b:g=[7,b-13,2];break;case 24>=b:g=[8,b-17,3];break;case 32>=b:g=[9,b-25,3];break;case 48>=b:g=[10,b-33,4];break;case 64>=b:g=[11,b-49,4];break;case 96>=b:g=[12,b-
65,5];break;case 128>=b:g=[13,b-97,5];break;case 192>=b:g=[14,b-129,6];break;case 256>=b:g=[15,b-193,6];break;case 384>=b:g=[16,b-257,7];break;case 512>=b:g=[17,b-385,7];break;case 768>=b:g=[18,b-513,8];break;case 1024>=b:g=[19,b-769,8];break;case 1536>=b:g=[20,b-1025,9];break;case 2048>=b:g=[21,b-1537,9];break;case 3072>=b:g=[22,b-2049,10];break;case 4096>=b:g=[23,b-3073,10];break;case 6144>=b:g=[24,b-4097,11];break;case 8192>=b:g=[25,b-6145,11];break;case 12288>=b:g=[26,b-8193,12];break;case 16384>=
b:g=[27,b-12289,12];break;case 24576>=b:g=[28,b-16385,13];break;case 32768>=b:g=[29,b-24577,13];break;default:throw"invalid distance";}e=g;d[f++]=e[0];d[f++]=e[1];d[f++]=e[2];var k,m;k=0;for(m=d.length;k<m;++k)l[h++]=d[k];t[d[0]]++;w[d[3]]++;q=a.length+c-1;x=null}var f,a,b,k,m,g={},p,v,x,l=C?new Uint16Array(2*d.length):[],h=0,q=0,t=new (C?Uint32Array:Array)(286),w=new (C?Uint32Array:Array)(30),da=e.f,z;if(!C){for(b=0;285>=b;)t[b++]=0;for(b=0;29>=b;)w[b++]=0}t[256]=1;f=0;for(a=d.length;f<a;++f){b=
m=0;for(k=3;b<k&&f+b!==a;++b)m=m<<8|d[f+b];g[m]===n&&(g[m]=[]);p=g[m];if(!(0<q--)){for(;0<p.length&&32768<f-p[0];)p.shift();if(f+3>=a){x&&c(x,-1);b=0;for(k=a-f;b<k;++b)z=d[f+b],l[h++]=z,++t[z];break}0<p.length?(v=Ha(d,f,p),x?x.length<v.length?(z=d[f-1],l[h++]=z,++t[z],c(v,0)):c(x,-1):v.length<da?x=v:c(v,0)):x?c(x,-1):(z=d[f],l[h++]=z,++t[z])}p.push(f)}l[h++]=256;t[256]++;e.j=t;e.i=w;return C?l.subarray(0,h):l}
function Ha(e,d,c){var f,a,b=0,k,m,g,p,v=e.length;m=0;p=c.length;a:for(;m<p;m++){f=c[p-m-1];k=3;if(3<b){for(g=b;3<g;g--)if(e[f+g-1]!==e[d+g-1])continue a;k=b}for(;258>k&&d+k<v&&e[f+k]===e[d+k];)++k;k>b&&(a=f,b=k);if(258===k)break}return new qa(b,d-a)}
function oa(e,d){var c=e.length,f=new ja(572),a=new (C?Uint8Array:Array)(c),b,k,m,g,p;if(!C)for(g=0;g<c;g++)a[g]=0;for(g=0;g<c;++g)0<e[g]&&f.push(g,e[g]);b=Array(f.length/2);k=new (C?Uint32Array:Array)(f.length/2);if(1===b.length)return a[f.pop().index]=1,a;g=0;for(p=f.length/2;g<p;++g)b[g]=f.pop(),k[g]=b[g].value;m=Ja(k,k.length,d);g=0;for(p=b.length;g<p;++g)a[b[g].index]=m[g];return a}
function Ja(e,d,c){function f(a){var b=g[a][p[a]];b===d?(f(a+1),f(a+1)):--k[b];++p[a]}var a=new (C?Uint16Array:Array)(c),b=new (C?Uint8Array:Array)(c),k=new (C?Uint8Array:Array)(d),m=Array(c),g=Array(c),p=Array(c),v=(1<<c)-d,x=1<<c-1,l,h,q,t,w;a[c-1]=d;for(h=0;h<c;++h)v<x?b[h]=0:(b[h]=1,v-=x),v<<=1,a[c-2-h]=(a[c-1-h]/2|0)+d;a[0]=b[0];m[0]=Array(a[0]);g[0]=Array(a[0]);for(h=1;h<c;++h)a[h]>2*a[h-1]+b[h]&&(a[h]=2*a[h-1]+b[h]),m[h]=Array(a[h]),g[h]=Array(a[h]);for(l=0;l<d;++l)k[l]=c;for(q=0;q<a[c-1];++q)m[c-
1][q]=e[q],g[c-1][q]=q;for(l=0;l<c;++l)p[l]=0;1===b[c-1]&&(--k[0],++p[c-1]);for(h=c-2;0<=h;--h){t=l=0;w=p[h+1];for(q=0;q<a[h];q++)t=m[h+1][w]+m[h+1][w+1],t>e[l]?(m[h][q]=t,g[h][q]=d,w+=2):(m[h][q]=e[l],g[h][q]=l,++l);p[h]=0;1===b[h]&&f(h)}return k}
function pa(e){var d=new (C?Uint16Array:Array)(e.length),c=[],f=[],a=0,b,k,m,g;b=0;for(k=e.length;b<k;b++)c[e[b]]=(c[e[b]]|0)+1;b=1;for(k=16;b<=k;b++)f[b]=a,a+=c[b]|0,a<<=1;b=0;for(k=e.length;b<k;b++){a=f[e[b]];f[e[b]]+=1;m=d[b]=0;for(g=e[b];m<g;m++)d[b]=d[b]<<1|a&1,a>>>=1}return d};ba("Zlib.RawDeflate",ka);ba("Zlib.RawDeflate.prototype.compress",ka.prototype.h);var Ka={NONE:0,FIXED:1,DYNAMIC:ma},V,La,$,Ma;if(Object.keys)V=Object.keys(Ka);else for(La in V=[],$=0,Ka)V[$++]=La;$=0;for(Ma=V.length;$<Ma;++$)La=V[$],ba("Zlib.RawDeflate.CompressionType."+La,Ka[La]);}).call(this); //@ sourceMappingURL=rawdeflate.min.js.map
},{}],21:[function(require,module,exports){
/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var l=void 0,p=this;function q(c,d){var a=c.split("."),b=p;!(a[0]in b)&&b.execScript&&b.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)!a.length&&d!==l?b[e]=d:b=b[e]?b[e]:b[e]={}};var r="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array;function u(c){var d=c.length,a=0,b=Number.POSITIVE_INFINITY,e,f,g,h,k,m,s,n,t;for(n=0;n<d;++n)c[n]>a&&(a=c[n]),c[n]<b&&(b=c[n]);e=1<<a;f=new (r?Uint32Array:Array)(e);g=1;h=0;for(k=2;g<=a;){for(n=0;n<d;++n)if(c[n]===g){m=0;s=h;for(t=0;t<g;++t)m=m<<1|s&1,s>>=1;for(t=m;t<e;t+=k)f[t]=g<<16|n;++h}++g;h<<=1;k<<=1}return[f,a,b]};function v(c,d){this.g=[];this.h=32768;this.c=this.f=this.d=this.k=0;this.input=r?new Uint8Array(c):c;this.l=!1;this.i=w;this.p=!1;if(d||!(d={}))d.index&&(this.d=d.index),d.bufferSize&&(this.h=d.bufferSize),d.bufferType&&(this.i=d.bufferType),d.resize&&(this.p=d.resize);switch(this.i){case x:this.a=32768;this.b=new (r?Uint8Array:Array)(32768+this.h+258);break;case w:this.a=0;this.b=new (r?Uint8Array:Array)(this.h);this.e=this.u;this.m=this.r;this.j=this.s;break;default:throw Error("invalid inflate mode");
}}var x=0,w=1;
v.prototype.t=function(){for(;!this.l;){var c=y(this,3);c&1&&(this.l=!0);c>>>=1;switch(c){case 0:var d=this.input,a=this.d,b=this.b,e=this.a,f=l,g=l,h=l,k=b.length,m=l;this.c=this.f=0;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: LEN (first byte)");g=f;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: LEN (second byte)");g|=f<<8;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: NLEN (first byte)");h=f;f=d[a++];if(f===l)throw Error("invalid uncompressed block header: NLEN (second byte)");h|=
f<<8;if(g===~h)throw Error("invalid uncompressed block header: length verify");if(a+g>d.length)throw Error("input buffer is broken");switch(this.i){case x:for(;e+g>b.length;){m=k-e;g-=m;if(r)b.set(d.subarray(a,a+m),e),e+=m,a+=m;else for(;m--;)b[e++]=d[a++];this.a=e;b=this.e();e=this.a}break;case w:for(;e+g>b.length;)b=this.e({o:2});break;default:throw Error("invalid inflate mode");}if(r)b.set(d.subarray(a,a+g),e),e+=g,a+=g;else for(;g--;)b[e++]=d[a++];this.d=a;this.a=e;this.b=b;break;case 1:this.j(z,
A);break;case 2:B(this);break;default:throw Error("unknown BTYPE: "+c);}}return this.m()};
var C=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],D=r?new Uint16Array(C):C,E=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258],F=r?new Uint16Array(E):E,G=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0],H=r?new Uint8Array(G):G,I=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],J=r?new Uint16Array(I):I,K=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,
13],L=r?new Uint8Array(K):K,M=new (r?Uint8Array:Array)(288),N,O;N=0;for(O=M.length;N<O;++N)M[N]=143>=N?8:255>=N?9:279>=N?7:8;var z=u(M),P=new (r?Uint8Array:Array)(30),Q,R;Q=0;for(R=P.length;Q<R;++Q)P[Q]=5;var A=u(P);function y(c,d){for(var a=c.f,b=c.c,e=c.input,f=c.d,g;b<d;){g=e[f++];if(g===l)throw Error("input buffer is broken");a|=g<<b;b+=8}g=a&(1<<d)-1;c.f=a>>>d;c.c=b-d;c.d=f;return g}
function S(c,d){for(var a=c.f,b=c.c,e=c.input,f=c.d,g=d[0],h=d[1],k,m,s;b<h;){k=e[f++];if(k===l)break;a|=k<<b;b+=8}m=g[a&(1<<h)-1];s=m>>>16;c.f=a>>s;c.c=b-s;c.d=f;return m&65535}
function B(c){function d(a,c,b){var d,f,e,g;for(g=0;g<a;)switch(d=S(this,c),d){case 16:for(e=3+y(this,2);e--;)b[g++]=f;break;case 17:for(e=3+y(this,3);e--;)b[g++]=0;f=0;break;case 18:for(e=11+y(this,7);e--;)b[g++]=0;f=0;break;default:f=b[g++]=d}return b}var a=y(c,5)+257,b=y(c,5)+1,e=y(c,4)+4,f=new (r?Uint8Array:Array)(D.length),g,h,k,m;for(m=0;m<e;++m)f[D[m]]=y(c,3);g=u(f);h=new (r?Uint8Array:Array)(a);k=new (r?Uint8Array:Array)(b);c.j(u(d.call(c,a,g,h)),u(d.call(c,b,g,k)))}
v.prototype.j=function(c,d){var a=this.b,b=this.a;this.n=c;for(var e=a.length-258,f,g,h,k;256!==(f=S(this,c));)if(256>f)b>=e&&(this.a=b,a=this.e(),b=this.a),a[b++]=f;else{g=f-257;k=F[g];0<H[g]&&(k+=y(this,H[g]));f=S(this,d);h=J[f];0<L[f]&&(h+=y(this,L[f]));b>=e&&(this.a=b,a=this.e(),b=this.a);for(;k--;)a[b]=a[b++-h]}for(;8<=this.c;)this.c-=8,this.d--;this.a=b};
v.prototype.s=function(c,d){var a=this.b,b=this.a;this.n=c;for(var e=a.length,f,g,h,k;256!==(f=S(this,c));)if(256>f)b>=e&&(a=this.e(),e=a.length),a[b++]=f;else{g=f-257;k=F[g];0<H[g]&&(k+=y(this,H[g]));f=S(this,d);h=J[f];0<L[f]&&(h+=y(this,L[f]));b+k>e&&(a=this.e(),e=a.length);for(;k--;)a[b]=a[b++-h]}for(;8<=this.c;)this.c-=8,this.d--;this.a=b};
v.prototype.e=function(){var c=new (r?Uint8Array:Array)(this.a-32768),d=this.a-32768,a,b,e=this.b;if(r)c.set(e.subarray(32768,c.length));else{a=0;for(b=c.length;a<b;++a)c[a]=e[a+32768]}this.g.push(c);this.k+=c.length;if(r)e.set(e.subarray(d,d+32768));else for(a=0;32768>a;++a)e[a]=e[d+a];this.a=32768;return e};
v.prototype.u=function(c){var d,a=this.input.length/this.d+1|0,b,e,f,g=this.input,h=this.b;c&&("number"===typeof c.o&&(a=c.o),"number"===typeof c.q&&(a+=c.q));2>a?(b=(g.length-this.d)/this.n[2],f=258*(b/2)|0,e=f<h.length?h.length+f:h.length<<1):e=h.length*a;r?(d=new Uint8Array(e),d.set(h)):d=h;return this.b=d};
v.prototype.m=function(){var c=0,d=this.b,a=this.g,b,e=new (r?Uint8Array:Array)(this.k+(this.a-32768)),f,g,h,k;if(0===a.length)return r?this.b.subarray(32768,this.a):this.b.slice(32768,this.a);f=0;for(g=a.length;f<g;++f){b=a[f];h=0;for(k=b.length;h<k;++h)e[c++]=b[h]}f=32768;for(g=this.a;f<g;++f)e[c++]=d[f];this.g=[];return this.buffer=e};
v.prototype.r=function(){var c,d=this.a;r?this.p?(c=new Uint8Array(d),c.set(this.b.subarray(0,d))):c=this.b.subarray(0,d):(this.b.length>d&&(this.b.length=d),c=this.b);return this.buffer=c};q("Zlib.RawInflate",v);q("Zlib.RawInflate.prototype.decompress",v.prototype.t);var T={ADAPTIVE:w,BLOCK:x},U,V,W,X;if(Object.keys)U=Object.keys(T);else for(V in U=[],W=0,T)U[W++]=V;W=0;for(X=U.length;W<X;++W)V=U[W],q("Zlib.RawInflate.BufferType."+V,T[V]);}).call(this); //@ sourceMappingURL=rawinflate.min.js.map
},{}]},{},[7])
(7)
});
;