1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/bootstrap-source/bootstrap-3.0.3/docs-assets/js/jszip.js Fri Dec 20 22:49:16 2013 +0100
1.3 @@ -0,0 +1,1474 @@
1.4 +/**
1.5 +
1.6 +JSZip - A Javascript class for generating and reading zip files
1.7 +<http://stuartk.com/jszip>
1.8 +
1.9 +(c) 2009-2012 Stuart Knightley <stuart [at] stuartk.com>
1.10 +Dual licenced under the MIT license or GPLv3. See LICENSE.markdown.
1.11 +
1.12 +Usage:
1.13 + zip = new JSZip();
1.14 + zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing");
1.15 + zip.folder("images").file("smile.gif", base64Data, {base64: true});
1.16 + zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")});
1.17 + zip.remove("tempfile");
1.18 +
1.19 + base64zip = zip.generate();
1.20 +
1.21 +**/
1.22 +// We use strict, but it should not be placed outside of a function because
1.23 +// the environment is shared inside the browser.
1.24 +// "use strict";
1.25 +
1.26 +/**
1.27 + * Representation a of zip file in js
1.28 + * @constructor
1.29 + * @param {String=|ArrayBuffer=|Uint8Array=|Buffer=} data the data to load, if any (optional).
1.30 + * @param {Object=} options the options for creating this objects (optional).
1.31 + */
1.32 +var JSZip = function(data, options) {
1.33 + // object containing the files :
1.34 + // {
1.35 + // "folder/" : {...},
1.36 + // "folder/data.txt" : {...}
1.37 + // }
1.38 + this.files = {};
1.39 +
1.40 + // Where we are in the hierarchy
1.41 + this.root = "";
1.42 +
1.43 + if (data) {
1.44 + this.load(data, options);
1.45 + }
1.46 +};
1.47 +
1.48 +JSZip.signature = {
1.49 + LOCAL_FILE_HEADER : "\x50\x4b\x03\x04",
1.50 + CENTRAL_FILE_HEADER : "\x50\x4b\x01\x02",
1.51 + CENTRAL_DIRECTORY_END : "\x50\x4b\x05\x06",
1.52 + ZIP64_CENTRAL_DIRECTORY_LOCATOR : "\x50\x4b\x06\x07",
1.53 + ZIP64_CENTRAL_DIRECTORY_END : "\x50\x4b\x06\x06",
1.54 + DATA_DESCRIPTOR : "\x50\x4b\x07\x08"
1.55 +};
1.56 +
1.57 +// Default properties for a new file
1.58 +JSZip.defaults = {
1.59 + base64: false,
1.60 + binary: false,
1.61 + dir: false,
1.62 + date: null,
1.63 + compression: null
1.64 +};
1.65 +
1.66 +/*
1.67 + * List features that require a modern browser, and if the current browser support them.
1.68 + */
1.69 +JSZip.support = {
1.70 + // contains true if JSZip can read/generate ArrayBuffer, false otherwise.
1.71 + arraybuffer : (function(){
1.72 + return typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
1.73 + })(),
1.74 + // contains true if JSZip can read/generate nodejs Buffer, false otherwise.
1.75 + nodebuffer : (function(){
1.76 + return typeof Buffer !== "undefined";
1.77 + })(),
1.78 + // contains true if JSZip can read/generate Uint8Array, false otherwise.
1.79 + uint8array : (function(){
1.80 + return typeof Uint8Array !== "undefined";
1.81 + })(),
1.82 + // contains true if JSZip can read/generate Blob, false otherwise.
1.83 + blob : (function(){
1.84 + // the spec started with BlobBuilder then replaced it with a construtor for Blob.
1.85 + // Result : we have browsers that :
1.86 + // * know the BlobBuilder (but with prefix)
1.87 + // * know the Blob constructor
1.88 + // * know about Blob but not about how to build them
1.89 + // About the "=== 0" test : if given the wrong type, it may be converted to a string.
1.90 + // Instead of an empty content, we will get "[object Uint8Array]" for example.
1.91 + if (typeof ArrayBuffer === "undefined") {
1.92 + return false;
1.93 + }
1.94 + var buffer = new ArrayBuffer(0);
1.95 + try {
1.96 + return new Blob([buffer], { type: "application/zip" }).size === 0;
1.97 + }
1.98 + catch(e) {}
1.99 +
1.100 + try {
1.101 + var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
1.102 + var builder = new BlobBuilder();
1.103 + builder.append(buffer);
1.104 + return builder.getBlob('application/zip').size === 0;
1.105 + }
1.106 + catch(e) {}
1.107 +
1.108 + return false;
1.109 + })()
1.110 +};
1.111 +
1.112 +JSZip.prototype = (function () {
1.113 + var textEncoder, textDecoder;
1.114 + if (
1.115 + JSZip.support.uint8array &&
1.116 + typeof TextEncoder === "function" &&
1.117 + typeof TextDecoder === "function"
1.118 + ) {
1.119 + textEncoder = new TextEncoder("utf-8");
1.120 + textDecoder = new TextDecoder("utf-8");
1.121 + }
1.122 +
1.123 + /**
1.124 + * Returns the raw data of a ZipObject, decompress the content if necessary.
1.125 + * @param {ZipObject} file the file to use.
1.126 + * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
1.127 + */
1.128 + var getRawData = function (file) {
1.129 + if (file._data instanceof JSZip.CompressedObject) {
1.130 + file._data = file._data.getContent();
1.131 + file.options.binary = true;
1.132 + file.options.base64 = false;
1.133 +
1.134 + if (JSZip.utils.getTypeOf(file._data) === "uint8array") {
1.135 + var copy = file._data;
1.136 + // when reading an arraybuffer, the CompressedObject mechanism will keep it and subarray() a Uint8Array.
1.137 + // if we request a file in the same format, we might get the same Uint8Array or its ArrayBuffer (the original zip file).
1.138 + file._data = new Uint8Array(copy.length);
1.139 + // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
1.140 + if (copy.length !== 0) {
1.141 + file._data.set(copy, 0);
1.142 + }
1.143 + }
1.144 + }
1.145 + return file._data;
1.146 + };
1.147 +
1.148 + /**
1.149 + * Returns the data of a ZipObject in a binary form. If the content is an unicode string, encode it.
1.150 + * @param {ZipObject} file the file to use.
1.151 + * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
1.152 + */
1.153 + var getBinaryData = function (file) {
1.154 + var result = getRawData(file), type = JSZip.utils.getTypeOf(result);
1.155 + if (type === "string") {
1.156 + if (!file.options.binary) {
1.157 + // unicode text !
1.158 + // unicode string => binary string is a painful process, check if we can avoid it.
1.159 + if (textEncoder) {
1.160 + return textEncoder.encode(result);
1.161 + }
1.162 + if (JSZip.support.nodebuffer) {
1.163 + return new Buffer(result, "utf-8");
1.164 + }
1.165 + }
1.166 + return file.asBinary();
1.167 + }
1.168 + return result;
1.169 + };
1.170 +
1.171 + /**
1.172 + * Transform this._data into a string.
1.173 + * @param {function} filter a function String -> String, applied if not null on the result.
1.174 + * @return {String} the string representing this._data.
1.175 + */
1.176 + var dataToString = function (asUTF8) {
1.177 + var result = getRawData(this);
1.178 + if (result === null || typeof result === "undefined") {
1.179 + return "";
1.180 + }
1.181 + // if the data is a base64 string, we decode it before checking the encoding !
1.182 + if (this.options.base64) {
1.183 + result = JSZip.base64.decode(result);
1.184 + }
1.185 + if (asUTF8 && this.options.binary) {
1.186 + // JSZip.prototype.utf8decode supports arrays as input
1.187 + // skip to array => string step, utf8decode will do it.
1.188 + result = JSZip.prototype.utf8decode(result);
1.189 + } else {
1.190 + // no utf8 transformation, do the array => string step.
1.191 + result = JSZip.utils.transformTo("string", result);
1.192 + }
1.193 +
1.194 + if (!asUTF8 && !this.options.binary) {
1.195 + result = JSZip.prototype.utf8encode(result);
1.196 + }
1.197 + return result;
1.198 + };
1.199 + /**
1.200 + * A simple object representing a file in the zip file.
1.201 + * @constructor
1.202 + * @param {string} name the name of the file
1.203 + * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data
1.204 + * @param {Object} options the options of the file
1.205 + */
1.206 + var ZipObject = function (name, data, options) {
1.207 + this.name = name;
1.208 + this._data = data;
1.209 + this.options = options;
1.210 + };
1.211 +
1.212 + ZipObject.prototype = {
1.213 + /**
1.214 + * Return the content as UTF8 string.
1.215 + * @return {string} the UTF8 string.
1.216 + */
1.217 + asText : function () {
1.218 + return dataToString.call(this, true);
1.219 + },
1.220 + /**
1.221 + * Returns the binary content.
1.222 + * @return {string} the content as binary.
1.223 + */
1.224 + asBinary : function () {
1.225 + return dataToString.call(this, false);
1.226 + },
1.227 + /**
1.228 + * Returns the content as a nodejs Buffer.
1.229 + * @return {Buffer} the content as a Buffer.
1.230 + */
1.231 + asNodeBuffer : function () {
1.232 + var result = getBinaryData(this);
1.233 + return JSZip.utils.transformTo("nodebuffer", result);
1.234 + },
1.235 + /**
1.236 + * Returns the content as an Uint8Array.
1.237 + * @return {Uint8Array} the content as an Uint8Array.
1.238 + */
1.239 + asUint8Array : function () {
1.240 + var result = getBinaryData(this);
1.241 + return JSZip.utils.transformTo("uint8array", result);
1.242 + },
1.243 + /**
1.244 + * Returns the content as an ArrayBuffer.
1.245 + * @return {ArrayBuffer} the content as an ArrayBufer.
1.246 + */
1.247 + asArrayBuffer : function () {
1.248 + return this.asUint8Array().buffer;
1.249 + }
1.250 + };
1.251 +
1.252 + /**
1.253 + * Transform an integer into a string in hexadecimal.
1.254 + * @private
1.255 + * @param {number} dec the number to convert.
1.256 + * @param {number} bytes the number of bytes to generate.
1.257 + * @returns {string} the result.
1.258 + */
1.259 + var decToHex = function(dec, bytes) {
1.260 + var hex = "", i;
1.261 + for(i = 0; i < bytes; i++) {
1.262 + hex += String.fromCharCode(dec&0xff);
1.263 + dec=dec>>>8;
1.264 + }
1.265 + return hex;
1.266 + };
1.267 +
1.268 + /**
1.269 + * Merge the objects passed as parameters into a new one.
1.270 + * @private
1.271 + * @param {...Object} var_args All objects to merge.
1.272 + * @return {Object} a new object with the data of the others.
1.273 + */
1.274 + var extend = function () {
1.275 + var result = {}, i, attr;
1.276 + for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
1.277 + for (attr in arguments[i]) {
1.278 + if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
1.279 + result[attr] = arguments[i][attr];
1.280 + }
1.281 + }
1.282 + }
1.283 + return result;
1.284 + };
1.285 +
1.286 + /**
1.287 + * Transforms the (incomplete) options from the user into the complete
1.288 + * set of options to create a file.
1.289 + * @private
1.290 + * @param {Object} o the options from the user.
1.291 + * @return {Object} the complete set of options.
1.292 + */
1.293 + var prepareFileAttrs = function (o) {
1.294 + o = o || {};
1.295 + /*jshint -W041 */
1.296 + if (o.base64 === true && o.binary == null) {
1.297 + o.binary = true;
1.298 + }
1.299 + /*jshint +W041 */
1.300 + o = extend(o, JSZip.defaults);
1.301 + o.date = o.date || new Date();
1.302 + if (o.compression !== null) o.compression = o.compression.toUpperCase();
1.303 +
1.304 + return o;
1.305 + };
1.306 +
1.307 + /**
1.308 + * Add a file in the current folder.
1.309 + * @private
1.310 + * @param {string} name the name of the file
1.311 + * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file
1.312 + * @param {Object} o the options of the file
1.313 + * @return {Object} the new file.
1.314 + */
1.315 + var fileAdd = function (name, data, o) {
1.316 + // be sure sub folders exist
1.317 + var parent = parentFolder(name), dataType = JSZip.utils.getTypeOf(data);
1.318 + if (parent) {
1.319 + folderAdd.call(this, parent);
1.320 + }
1.321 +
1.322 + o = prepareFileAttrs(o);
1.323 +
1.324 + if (o.dir || data === null || typeof data === "undefined") {
1.325 + o.base64 = false;
1.326 + o.binary = false;
1.327 + data = null;
1.328 + } else if (dataType === "string") {
1.329 + if (o.binary && !o.base64) {
1.330 + // optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask
1.331 + if (o.optimizedBinaryString !== true) {
1.332 + // this is a string, not in a base64 format.
1.333 + // Be sure that this is a correct "binary string"
1.334 + data = JSZip.utils.string2binary(data);
1.335 + }
1.336 + }
1.337 + } else { // arraybuffer, uint8array, ...
1.338 + o.base64 = false;
1.339 + o.binary = true;
1.340 +
1.341 + if (!dataType && !(data instanceof JSZip.CompressedObject)) {
1.342 + throw new Error("The data of '" + name + "' is in an unsupported format !");
1.343 + }
1.344 +
1.345 + // special case : it's way easier to work with Uint8Array than with ArrayBuffer
1.346 + if (dataType === "arraybuffer") {
1.347 + data = JSZip.utils.transformTo("uint8array", data);
1.348 + }
1.349 + }
1.350 +
1.351 + var object = new ZipObject(name, data, o);
1.352 + this.files[name] = object;
1.353 + return object;
1.354 + };
1.355 +
1.356 +
1.357 + /**
1.358 + * Find the parent folder of the path.
1.359 + * @private
1.360 + * @param {string} path the path to use
1.361 + * @return {string} the parent folder, or ""
1.362 + */
1.363 + var parentFolder = function (path) {
1.364 + if (path.slice(-1) == '/') {
1.365 + path = path.substring(0, path.length - 1);
1.366 + }
1.367 + var lastSlash = path.lastIndexOf('/');
1.368 + return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
1.369 + };
1.370 +
1.371 + /**
1.372 + * Add a (sub) folder in the current folder.
1.373 + * @private
1.374 + * @param {string} name the folder's name
1.375 + * @return {Object} the new folder.
1.376 + */
1.377 + var folderAdd = function (name) {
1.378 + // Check the name ends with a /
1.379 + if (name.slice(-1) != "/") {
1.380 + name += "/"; // IE doesn't like substr(-1)
1.381 + }
1.382 +
1.383 + // Does this folder already exist?
1.384 + if (!this.files[name]) {
1.385 + fileAdd.call(this, name, null, {dir:true});
1.386 + }
1.387 + return this.files[name];
1.388 + };
1.389 +
1.390 + /**
1.391 + * Generate a JSZip.CompressedObject for a given zipOject.
1.392 + * @param {ZipObject} file the object to read.
1.393 + * @param {JSZip.compression} compression the compression to use.
1.394 + * @return {JSZip.CompressedObject} the compressed result.
1.395 + */
1.396 + var generateCompressedObjectFrom = function (file, compression) {
1.397 + var result = new JSZip.CompressedObject(), content;
1.398 +
1.399 + // the data has not been decompressed, we might reuse things !
1.400 + if (file._data instanceof JSZip.CompressedObject) {
1.401 + result.uncompressedSize = file._data.uncompressedSize;
1.402 + result.crc32 = file._data.crc32;
1.403 +
1.404 + if (result.uncompressedSize === 0 || file.options.dir) {
1.405 + compression = JSZip.compressions['STORE'];
1.406 + result.compressedContent = "";
1.407 + result.crc32 = 0;
1.408 + } else if (file._data.compressionMethod === compression.magic) {
1.409 + result.compressedContent = file._data.getCompressedContent();
1.410 + } else {
1.411 + content = file._data.getContent();
1.412 + // need to decompress / recompress
1.413 + result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content));
1.414 + }
1.415 + } else {
1.416 + // have uncompressed data
1.417 + content = getBinaryData(file);
1.418 + if (!content || content.length === 0 || file.options.dir) {
1.419 + compression = JSZip.compressions['STORE'];
1.420 + content = "";
1.421 + }
1.422 + result.uncompressedSize = content.length;
1.423 + result.crc32 = this.crc32(content);
1.424 + result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content));
1.425 + }
1.426 +
1.427 + result.compressedSize = result.compressedContent.length;
1.428 + result.compressionMethod = compression.magic;
1.429 +
1.430 + return result;
1.431 + };
1.432 +
1.433 + /**
1.434 + * Generate the various parts used in the construction of the final zip file.
1.435 + * @param {string} name the file name.
1.436 + * @param {ZipObject} file the file content.
1.437 + * @param {JSZip.CompressedObject} compressedObject the compressed object.
1.438 + * @param {number} offset the current offset from the start of the zip file.
1.439 + * @return {object} the zip parts.
1.440 + */
1.441 + var generateZipParts = function(name, file, compressedObject, offset) {
1.442 + var data = compressedObject.compressedContent,
1.443 + utfEncodedFileName = this.utf8encode(file.name),
1.444 + useUTF8 = utfEncodedFileName !== file.name,
1.445 + o = file.options,
1.446 + dosTime,
1.447 + dosDate;
1.448 +
1.449 + // date
1.450 + // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html
1.451 + // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html
1.452 + // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html
1.453 +
1.454 + dosTime = o.date.getHours();
1.455 + dosTime = dosTime << 6;
1.456 + dosTime = dosTime | o.date.getMinutes();
1.457 + dosTime = dosTime << 5;
1.458 + dosTime = dosTime | o.date.getSeconds() / 2;
1.459 +
1.460 + dosDate = o.date.getFullYear() - 1980;
1.461 + dosDate = dosDate << 4;
1.462 + dosDate = dosDate | (o.date.getMonth() + 1);
1.463 + dosDate = dosDate << 5;
1.464 + dosDate = dosDate | o.date.getDate();
1.465 +
1.466 +
1.467 + var header = "";
1.468 +
1.469 + // version needed to extract
1.470 + header += "\x0A\x00";
1.471 + // general purpose bit flag
1.472 + // set bit 11 if utf8
1.473 + header += useUTF8 ? "\x00\x08" : "\x00\x00";
1.474 + // compression method
1.475 + header += compressedObject.compressionMethod;
1.476 + // last mod file time
1.477 + header += decToHex(dosTime, 2);
1.478 + // last mod file date
1.479 + header += decToHex(dosDate, 2);
1.480 + // crc-32
1.481 + header += decToHex(compressedObject.crc32, 4);
1.482 + // compressed size
1.483 + header += decToHex(compressedObject.compressedSize, 4);
1.484 + // uncompressed size
1.485 + header += decToHex(compressedObject.uncompressedSize, 4);
1.486 + // file name length
1.487 + header += decToHex(utfEncodedFileName.length, 2);
1.488 + // extra field length
1.489 + header += "\x00\x00";
1.490 +
1.491 +
1.492 + var fileRecord = JSZip.signature.LOCAL_FILE_HEADER + header + utfEncodedFileName;
1.493 +
1.494 + var dirRecord = JSZip.signature.CENTRAL_FILE_HEADER +
1.495 + // version made by (00: DOS)
1.496 + "\x14\x00" +
1.497 + // file header (common to file and central directory)
1.498 + header +
1.499 + // file comment length
1.500 + "\x00\x00" +
1.501 + // disk number start
1.502 + "\x00\x00" +
1.503 + // internal file attributes TODO
1.504 + "\x00\x00" +
1.505 + // external file attributes
1.506 + (file.options.dir===true?"\x10\x00\x00\x00":"\x00\x00\x00\x00")+
1.507 + // relative offset of local header
1.508 + decToHex(offset, 4) +
1.509 + // file name
1.510 + utfEncodedFileName;
1.511 +
1.512 +
1.513 + return {
1.514 + fileRecord : fileRecord,
1.515 + dirRecord : dirRecord,
1.516 + compressedObject : compressedObject
1.517 + };
1.518 + };
1.519 +
1.520 + /**
1.521 + * An object to write any content to a string.
1.522 + * @constructor
1.523 + */
1.524 + var StringWriter = function () {
1.525 + this.data = [];
1.526 + };
1.527 + StringWriter.prototype = {
1.528 + /**
1.529 + * Append any content to the current string.
1.530 + * @param {Object} input the content to add.
1.531 + */
1.532 + append : function (input) {
1.533 + input = JSZip.utils.transformTo("string", input);
1.534 + this.data.push(input);
1.535 + },
1.536 + /**
1.537 + * Finalize the construction an return the result.
1.538 + * @return {string} the generated string.
1.539 + */
1.540 + finalize : function () {
1.541 + return this.data.join("");
1.542 + }
1.543 + };
1.544 + /**
1.545 + * An object to write any content to an Uint8Array.
1.546 + * @constructor
1.547 + * @param {number} length The length of the array.
1.548 + */
1.549 + var Uint8ArrayWriter = function (length) {
1.550 + this.data = new Uint8Array(length);
1.551 + this.index = 0;
1.552 + };
1.553 + Uint8ArrayWriter.prototype = {
1.554 + /**
1.555 + * Append any content to the current array.
1.556 + * @param {Object} input the content to add.
1.557 + */
1.558 + append : function (input) {
1.559 + if (input.length !== 0) {
1.560 + // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
1.561 + input = JSZip.utils.transformTo("uint8array", input);
1.562 + this.data.set(input, this.index);
1.563 + this.index += input.length;
1.564 + }
1.565 + },
1.566 + /**
1.567 + * Finalize the construction an return the result.
1.568 + * @return {Uint8Array} the generated array.
1.569 + */
1.570 + finalize : function () {
1.571 + return this.data;
1.572 + }
1.573 + };
1.574 +
1.575 + // return the actual prototype of JSZip
1.576 + return {
1.577 + /**
1.578 + * Read an existing zip and merge the data in the current JSZip object.
1.579 + * The implementation is in jszip-load.js, don't forget to include it.
1.580 + * @param {String|ArrayBuffer|Uint8Array|Buffer} stream The stream to load
1.581 + * @param {Object} options Options for loading the stream.
1.582 + * options.base64 : is the stream in base64 ? default : false
1.583 + * @return {JSZip} the current JSZip object
1.584 + */
1.585 + load : function (stream, options) {
1.586 + throw new Error("Load method is not defined. Is the file jszip-load.js included ?");
1.587 + },
1.588 +
1.589 + /**
1.590 + * Filter nested files/folders with the specified function.
1.591 + * @param {Function} search the predicate to use :
1.592 + * function (relativePath, file) {...}
1.593 + * It takes 2 arguments : the relative path and the file.
1.594 + * @return {Array} An array of matching elements.
1.595 + */
1.596 + filter : function (search) {
1.597 + var result = [], filename, relativePath, file, fileClone;
1.598 + for (filename in this.files) {
1.599 + if ( !this.files.hasOwnProperty(filename) ) { continue; }
1.600 + file = this.files[filename];
1.601 + // return a new object, don't let the user mess with our internal objects :)
1.602 + fileClone = new ZipObject(file.name, file._data, extend(file.options));
1.603 + relativePath = filename.slice(this.root.length, filename.length);
1.604 + if (filename.slice(0, this.root.length) === this.root && // the file is in the current root
1.605 + search(relativePath, fileClone)) { // and the file matches the function
1.606 + result.push(fileClone);
1.607 + }
1.608 + }
1.609 + return result;
1.610 + },
1.611 +
1.612 + /**
1.613 + * Add a file to the zip file, or search a file.
1.614 + * @param {string|RegExp} name The name of the file to add (if data is defined),
1.615 + * the name of the file to find (if no data) or a regex to match files.
1.616 + * @param {String|ArrayBuffer|Uint8Array|Buffer} data The file data, either raw or base64 encoded
1.617 + * @param {Object} o File options
1.618 + * @return {JSZip|Object|Array} this JSZip object (when adding a file),
1.619 + * a file (when searching by string) or an array of files (when searching by regex).
1.620 + */
1.621 + file : function(name, data, o) {
1.622 + if (arguments.length === 1) {
1.623 + if (JSZip.utils.isRegExp(name)) {
1.624 + var regexp = name;
1.625 + return this.filter(function(relativePath, file) {
1.626 + return !file.options.dir && regexp.test(relativePath);
1.627 + });
1.628 + } else { // text
1.629 + return this.filter(function (relativePath, file) {
1.630 + return !file.options.dir && relativePath === name;
1.631 + })[0]||null;
1.632 + }
1.633 + } else { // more than one argument : we have data !
1.634 + name = this.root+name;
1.635 + fileAdd.call(this, name, data, o);
1.636 + }
1.637 + return this;
1.638 + },
1.639 +
1.640 + /**
1.641 + * Add a directory to the zip file, or search.
1.642 + * @param {String|RegExp} arg The name of the directory to add, or a regex to search folders.
1.643 + * @return {JSZip} an object with the new directory as the root, or an array containing matching folders.
1.644 + */
1.645 + folder : function(arg) {
1.646 + if (!arg) {
1.647 + return this;
1.648 + }
1.649 +
1.650 + if (JSZip.utils.isRegExp(arg)) {
1.651 + return this.filter(function(relativePath, file) {
1.652 + return file.options.dir && arg.test(relativePath);
1.653 + });
1.654 + }
1.655 +
1.656 + // else, name is a new folder
1.657 + var name = this.root + arg;
1.658 + var newFolder = folderAdd.call(this, name);
1.659 +
1.660 + // Allow chaining by returning a new object with this folder as the root
1.661 + var ret = this.clone();
1.662 + ret.root = newFolder.name;
1.663 + return ret;
1.664 + },
1.665 +
1.666 + /**
1.667 + * Delete a file, or a directory and all sub-files, from the zip
1.668 + * @param {string} name the name of the file to delete
1.669 + * @return {JSZip} this JSZip object
1.670 + */
1.671 + remove : function(name) {
1.672 + name = this.root + name;
1.673 + var file = this.files[name];
1.674 + if (!file) {
1.675 + // Look for any folders
1.676 + if (name.slice(-1) != "/") {
1.677 + name += "/";
1.678 + }
1.679 + file = this.files[name];
1.680 + }
1.681 +
1.682 + if (file) {
1.683 + if (!file.options.dir) {
1.684 + // file
1.685 + delete this.files[name];
1.686 + } else {
1.687 + // folder
1.688 + var kids = this.filter(function (relativePath, file) {
1.689 + return file.name.slice(0, name.length) === name;
1.690 + });
1.691 + for (var i = 0; i < kids.length; i++) {
1.692 + delete this.files[kids[i].name];
1.693 + }
1.694 + }
1.695 + }
1.696 +
1.697 + return this;
1.698 + },
1.699 +
1.700 + /**
1.701 + * Generate the complete zip file
1.702 + * @param {Object} options the options to generate the zip file :
1.703 + * - base64, (deprecated, use type instead) true to generate base64.
1.704 + * - compression, "STORE" by default.
1.705 + * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
1.706 + * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
1.707 + */
1.708 + generate : function(options) {
1.709 + options = extend(options || {}, {
1.710 + base64 : true,
1.711 + compression : "STORE",
1.712 + type : "base64"
1.713 + });
1.714 +
1.715 + JSZip.utils.checkSupport(options.type);
1.716 +
1.717 + var zipData = [], localDirLength = 0, centralDirLength = 0, writer, i;
1.718 +
1.719 +
1.720 + // first, generate all the zip parts.
1.721 + for (var name in this.files) {
1.722 + if ( !this.files.hasOwnProperty(name) ) { continue; }
1.723 + var file = this.files[name];
1.724 +
1.725 + var compressionName = file.options.compression || options.compression.toUpperCase();
1.726 + var compression = JSZip.compressions[compressionName];
1.727 + if (!compression) {
1.728 + throw new Error(compressionName + " is not a valid compression method !");
1.729 + }
1.730 +
1.731 + var compressedObject = generateCompressedObjectFrom.call(this, file, compression);
1.732 +
1.733 + var zipPart = generateZipParts.call(this, name, file, compressedObject, localDirLength);
1.734 + localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize;
1.735 + centralDirLength += zipPart.dirRecord.length;
1.736 + zipData.push(zipPart);
1.737 + }
1.738 +
1.739 + var dirEnd = "";
1.740 +
1.741 + // end of central dir signature
1.742 + dirEnd = JSZip.signature.CENTRAL_DIRECTORY_END +
1.743 + // number of this disk
1.744 + "\x00\x00" +
1.745 + // number of the disk with the start of the central directory
1.746 + "\x00\x00" +
1.747 + // total number of entries in the central directory on this disk
1.748 + decToHex(zipData.length, 2) +
1.749 + // total number of entries in the central directory
1.750 + decToHex(zipData.length, 2) +
1.751 + // size of the central directory 4 bytes
1.752 + decToHex(centralDirLength, 4) +
1.753 + // offset of start of central directory with respect to the starting disk number
1.754 + decToHex(localDirLength, 4) +
1.755 + // .ZIP file comment length
1.756 + "\x00\x00";
1.757 +
1.758 +
1.759 + // we have all the parts (and the total length)
1.760 + // time to create a writer !
1.761 + switch(options.type.toLowerCase()) {
1.762 + case "uint8array" :
1.763 + case "arraybuffer" :
1.764 + case "blob" :
1.765 + case "nodebuffer" :
1.766 + writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length);
1.767 + break;
1.768 + // case "base64" :
1.769 + // case "string" :
1.770 + default :
1.771 + writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length);
1.772 + break;
1.773 + }
1.774 +
1.775 + for (i = 0; i < zipData.length; i++) {
1.776 + writer.append(zipData[i].fileRecord);
1.777 + writer.append(zipData[i].compressedObject.compressedContent);
1.778 + }
1.779 + for (i = 0; i < zipData.length; i++) {
1.780 + writer.append(zipData[i].dirRecord);
1.781 + }
1.782 +
1.783 + writer.append(dirEnd);
1.784 +
1.785 + var zip = writer.finalize();
1.786 +
1.787 +
1.788 +
1.789 + switch(options.type.toLowerCase()) {
1.790 + // case "zip is an Uint8Array"
1.791 + case "uint8array" :
1.792 + case "arraybuffer" :
1.793 + case "nodebuffer" :
1.794 + return JSZip.utils.transformTo(options.type.toLowerCase(), zip);
1.795 + case "blob" :
1.796 + return JSZip.utils.arrayBuffer2Blob(JSZip.utils.transformTo("arraybuffer", zip));
1.797 +
1.798 + // case "zip is a string"
1.799 + case "base64" :
1.800 + return (options.base64) ? JSZip.base64.encode(zip) : zip;
1.801 + default : // case "string" :
1.802 + return zip;
1.803 + }
1.804 + },
1.805 +
1.806 + /**
1.807 + *
1.808 + * Javascript crc32
1.809 + * http://www.webtoolkit.info/
1.810 + *
1.811 + */
1.812 + crc32 : function crc32(input, crc) {
1.813 + if (typeof input === "undefined" || !input.length) {
1.814 + return 0;
1.815 + }
1.816 +
1.817 + var isArray = JSZip.utils.getTypeOf(input) !== "string";
1.818 +
1.819 + var table = [
1.820 + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
1.821 + 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
1.822 + 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
1.823 + 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
1.824 + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
1.825 + 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
1.826 + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
1.827 + 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
1.828 + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
1.829 + 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
1.830 + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
1.831 + 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
1.832 + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
1.833 + 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
1.834 + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
1.835 + 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
1.836 + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
1.837 + 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
1.838 + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
1.839 + 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
1.840 + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
1.841 + 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
1.842 + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
1.843 + 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
1.844 + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
1.845 + 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
1.846 + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
1.847 + 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
1.848 + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
1.849 + 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
1.850 + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
1.851 + 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
1.852 + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
1.853 + 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
1.854 + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
1.855 + 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
1.856 + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
1.857 + 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
1.858 + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
1.859 + 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
1.860 + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
1.861 + 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
1.862 + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
1.863 + 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
1.864 + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
1.865 + 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
1.866 + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
1.867 + 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
1.868 + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
1.869 + 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
1.870 + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
1.871 + 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
1.872 + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
1.873 + 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
1.874 + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
1.875 + 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
1.876 + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
1.877 + 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
1.878 + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
1.879 + 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
1.880 + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
1.881 + 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
1.882 + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
1.883 + 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
1.884 + ];
1.885 +
1.886 + if (typeof(crc) == "undefined") { crc = 0; }
1.887 + var x = 0;
1.888 + var y = 0;
1.889 + var byte = 0;
1.890 +
1.891 + crc = crc ^ (-1);
1.892 + for( var i = 0, iTop = input.length; i < iTop; i++ ) {
1.893 + byte = isArray ? input[i] : input.charCodeAt(i);
1.894 + y = ( crc ^ byte ) & 0xFF;
1.895 + x = table[y];
1.896 + crc = ( crc >>> 8 ) ^ x;
1.897 + }
1.898 +
1.899 + return crc ^ (-1);
1.900 + },
1.901 +
1.902 + // Inspired by http://my.opera.com/GreyWyvern/blog/show.dml/1725165
1.903 + clone : function() {
1.904 + var newObj = new JSZip();
1.905 + for (var i in this) {
1.906 + if (typeof this[i] !== "function") {
1.907 + newObj[i] = this[i];
1.908 + }
1.909 + }
1.910 + return newObj;
1.911 + },
1.912 +
1.913 +
1.914 + /**
1.915 + * http://www.webtoolkit.info/javascript-utf8.html
1.916 + */
1.917 + utf8encode : function (string) {
1.918 + // TextEncoder + Uint8Array to binary string is faster than checking every bytes on long strings.
1.919 + // http://jsperf.com/utf8encode-vs-textencoder
1.920 + // On short strings (file names for example), the TextEncoder API is (currently) slower.
1.921 + if (textEncoder) {
1.922 + var u8 = textEncoder.encode(string);
1.923 + return JSZip.utils.transformTo("string", u8);
1.924 + }
1.925 + if (JSZip.support.nodebuffer) {
1.926 + return JSZip.utils.transformTo("string", new Buffer(string, "utf-8"));
1.927 + }
1.928 +
1.929 + // array.join may be slower than string concatenation but generates less objects (less time spent garbage collecting).
1.930 + // See also http://jsperf.com/array-direct-assignment-vs-push/31
1.931 + var result = [], resIndex = 0;
1.932 +
1.933 + for (var n = 0; n < string.length; n++) {
1.934 +
1.935 + var c = string.charCodeAt(n);
1.936 +
1.937 + if (c < 128) {
1.938 + result[resIndex++] = String.fromCharCode(c);
1.939 + } else if ((c > 127) && (c < 2048)) {
1.940 + result[resIndex++] = String.fromCharCode((c >> 6) | 192);
1.941 + result[resIndex++] = String.fromCharCode((c & 63) | 128);
1.942 + } else {
1.943 + result[resIndex++] = String.fromCharCode((c >> 12) | 224);
1.944 + result[resIndex++] = String.fromCharCode(((c >> 6) & 63) | 128);
1.945 + result[resIndex++] = String.fromCharCode((c & 63) | 128);
1.946 + }
1.947 +
1.948 + }
1.949 +
1.950 + return result.join("");
1.951 + },
1.952 +
1.953 + /**
1.954 + * http://www.webtoolkit.info/javascript-utf8.html
1.955 + */
1.956 + utf8decode : function (input) {
1.957 + var result = [], resIndex = 0;
1.958 + var type = JSZip.utils.getTypeOf(input);
1.959 + var isArray = type !== "string";
1.960 + var i = 0;
1.961 + var c = 0, c1 = 0, c2 = 0, c3 = 0;
1.962 +
1.963 + // check if we can use the TextDecoder API
1.964 + // see http://encoding.spec.whatwg.org/#api
1.965 + if (textDecoder) {
1.966 + return textDecoder.decode(
1.967 + JSZip.utils.transformTo("uint8array", input)
1.968 + );
1.969 + }
1.970 + if (JSZip.support.nodebuffer) {
1.971 + return JSZip.utils.transformTo("nodebuffer", input).toString("utf-8");
1.972 + }
1.973 +
1.974 + while ( i < input.length ) {
1.975 +
1.976 + c = isArray ? input[i] : input.charCodeAt(i);
1.977 +
1.978 + if (c < 128) {
1.979 + result[resIndex++] = String.fromCharCode(c);
1.980 + i++;
1.981 + } else if ((c > 191) && (c < 224)) {
1.982 + c2 = isArray ? input[i+1] : input.charCodeAt(i+1);
1.983 + result[resIndex++] = String.fromCharCode(((c & 31) << 6) | (c2 & 63));
1.984 + i += 2;
1.985 + } else {
1.986 + c2 = isArray ? input[i+1] : input.charCodeAt(i+1);
1.987 + c3 = isArray ? input[i+2] : input.charCodeAt(i+2);
1.988 + result[resIndex++] = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
1.989 + i += 3;
1.990 + }
1.991 +
1.992 + }
1.993 +
1.994 + return result.join("");
1.995 + }
1.996 + };
1.997 +}());
1.998 +
1.999 +/*
1.1000 + * Compression methods
1.1001 + * This object is filled in as follow :
1.1002 + * name : {
1.1003 + * magic // the 2 bytes indentifying the compression method
1.1004 + * compress // function, take the uncompressed content and return it compressed.
1.1005 + * uncompress // function, take the compressed content and return it uncompressed.
1.1006 + * compressInputType // string, the type accepted by the compress method. null to accept everything.
1.1007 + * uncompressInputType // string, the type accepted by the uncompress method. null to accept everything.
1.1008 + * }
1.1009 + *
1.1010 + * STORE is the default compression method, so it's included in this file.
1.1011 + * Other methods should go to separated files : the user wants modularity.
1.1012 + */
1.1013 +JSZip.compressions = {
1.1014 + "STORE" : {
1.1015 + magic : "\x00\x00",
1.1016 + compress : function (content) {
1.1017 + return content; // no compression
1.1018 + },
1.1019 + uncompress : function (content) {
1.1020 + return content; // no compression
1.1021 + },
1.1022 + compressInputType : null,
1.1023 + uncompressInputType : null
1.1024 + }
1.1025 +};
1.1026 +
1.1027 +(function () {
1.1028 + JSZip.utils = {
1.1029 + /**
1.1030 + * Convert a string to a "binary string" : a string containing only char codes between 0 and 255.
1.1031 + * @param {string} str the string to transform.
1.1032 + * @return {String} the binary string.
1.1033 + */
1.1034 + string2binary : function (str) {
1.1035 + var result = "";
1.1036 + for (var i = 0; i < str.length; i++) {
1.1037 + result += String.fromCharCode(str.charCodeAt(i) & 0xff);
1.1038 + }
1.1039 + return result;
1.1040 + },
1.1041 + /**
1.1042 + * Create a Uint8Array from the string.
1.1043 + * @param {string} str the string to transform.
1.1044 + * @return {Uint8Array} the typed array.
1.1045 + * @throws {Error} an Error if the browser doesn't support the requested feature.
1.1046 + * @deprecated : use JSZip.utils.transformTo instead.
1.1047 + */
1.1048 + string2Uint8Array : function (str) {
1.1049 + return JSZip.utils.transformTo("uint8array", str);
1.1050 + },
1.1051 +
1.1052 + /**
1.1053 + * Create a string from the Uint8Array.
1.1054 + * @param {Uint8Array} array the array to transform.
1.1055 + * @return {string} the string.
1.1056 + * @throws {Error} an Error if the browser doesn't support the requested feature.
1.1057 + * @deprecated : use JSZip.utils.transformTo instead.
1.1058 + */
1.1059 + uint8Array2String : function (array) {
1.1060 + return JSZip.utils.transformTo("string", array);
1.1061 + },
1.1062 + /**
1.1063 + * Create a blob from the given ArrayBuffer.
1.1064 + * @param {ArrayBuffer} buffer the buffer to transform.
1.1065 + * @return {Blob} the result.
1.1066 + * @throws {Error} an Error if the browser doesn't support the requested feature.
1.1067 + */
1.1068 + arrayBuffer2Blob : function (buffer) {
1.1069 + JSZip.utils.checkSupport("blob");
1.1070 +
1.1071 + try {
1.1072 + // Blob constructor
1.1073 + return new Blob([buffer], { type: "application/zip" });
1.1074 + }
1.1075 + catch(e) {}
1.1076 +
1.1077 + try {
1.1078 + // deprecated, browser only, old way
1.1079 + var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
1.1080 + var builder = new BlobBuilder();
1.1081 + builder.append(buffer);
1.1082 + return builder.getBlob('application/zip');
1.1083 + }
1.1084 + catch(e) {}
1.1085 +
1.1086 + // well, fuck ?!
1.1087 + throw new Error("Bug : can't construct the Blob.");
1.1088 + },
1.1089 + /**
1.1090 + * Create a blob from the given string.
1.1091 + * @param {string} str the string to transform.
1.1092 + * @return {Blob} the result.
1.1093 + * @throws {Error} an Error if the browser doesn't support the requested feature.
1.1094 + */
1.1095 + string2Blob : function (str) {
1.1096 + var buffer = JSZip.utils.transformTo("arraybuffer", str);
1.1097 + return JSZip.utils.arrayBuffer2Blob(buffer);
1.1098 + }
1.1099 + };
1.1100 +
1.1101 + /**
1.1102 + * The identity function.
1.1103 + * @param {Object} input the input.
1.1104 + * @return {Object} the same input.
1.1105 + */
1.1106 + function identity(input) {
1.1107 + return input;
1.1108 + }
1.1109 +
1.1110 + /**
1.1111 + * Fill in an array with a string.
1.1112 + * @param {String} str the string to use.
1.1113 + * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
1.1114 + * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
1.1115 + */
1.1116 + function stringToArrayLike(str, array) {
1.1117 + for (var i = 0; i < str.length; ++i) {
1.1118 + array[i] = str.charCodeAt(i) & 0xFF;
1.1119 + }
1.1120 + return array;
1.1121 + }
1.1122 +
1.1123 + /**
1.1124 + * Transform an array-like object to a string.
1.1125 + * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
1.1126 + * @return {String} the result.
1.1127 + */
1.1128 + function arrayLikeToString(array) {
1.1129 + // Performances notes :
1.1130 + // --------------------
1.1131 + // String.fromCharCode.apply(null, array) is the fastest, see
1.1132 + // see http://jsperf.com/converting-a-uint8array-to-a-string/2
1.1133 + // but the stack is limited (and we can get huge arrays !).
1.1134 + //
1.1135 + // result += String.fromCharCode(array[i]); generate too many strings !
1.1136 + //
1.1137 + // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2
1.1138 + var chunk = 65536;
1.1139 + var result = [], len = array.length, type = JSZip.utils.getTypeOf(array), k = 0;
1.1140 +
1.1141 + var canUseApply = true;
1.1142 + try {
1.1143 + switch(type) {
1.1144 + case "uint8array":
1.1145 + String.fromCharCode.apply(null, new Uint8Array(0));
1.1146 + break;
1.1147 + case "nodebuffer":
1.1148 + String.fromCharCode.apply(null, new Buffer(0));
1.1149 + break;
1.1150 + }
1.1151 + } catch(e) {
1.1152 + canUseApply = false;
1.1153 + }
1.1154 +
1.1155 + // no apply : slow and painful algorithm
1.1156 + // default browser on android 4.*
1.1157 + if (!canUseApply) {
1.1158 + var resultStr = "";
1.1159 + for(var i = 0; i < array.length;i++) {
1.1160 + resultStr += String.fromCharCode(array[i]);
1.1161 + }
1.1162 + return resultStr;
1.1163 + }
1.1164 +
1.1165 + while (k < len && chunk > 1) {
1.1166 + try {
1.1167 + if (type === "array" || type === "nodebuffer") {
1.1168 + result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
1.1169 + } else {
1.1170 + result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
1.1171 + }
1.1172 + k += chunk;
1.1173 + } catch (e) {
1.1174 + chunk = Math.floor(chunk / 2);
1.1175 + }
1.1176 + }
1.1177 + return result.join("");
1.1178 + }
1.1179 +
1.1180 + /**
1.1181 + * Copy the data from an array-like to an other array-like.
1.1182 + * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
1.1183 + * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
1.1184 + * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
1.1185 + */
1.1186 + function arrayLikeToArrayLike(arrayFrom, arrayTo) {
1.1187 + for(var i = 0; i < arrayFrom.length; i++) {
1.1188 + arrayTo[i] = arrayFrom[i];
1.1189 + }
1.1190 + return arrayTo;
1.1191 + }
1.1192 +
1.1193 + // a matrix containing functions to transform everything into everything.
1.1194 + var transform = {};
1.1195 +
1.1196 + // string to ?
1.1197 + transform["string"] = {
1.1198 + "string" : identity,
1.1199 + "array" : function (input) {
1.1200 + return stringToArrayLike(input, new Array(input.length));
1.1201 + },
1.1202 + "arraybuffer" : function (input) {
1.1203 + return transform["string"]["uint8array"](input).buffer;
1.1204 + },
1.1205 + "uint8array" : function (input) {
1.1206 + return stringToArrayLike(input, new Uint8Array(input.length));
1.1207 + },
1.1208 + "nodebuffer" : function (input) {
1.1209 + return stringToArrayLike(input, new Buffer(input.length));
1.1210 + }
1.1211 + };
1.1212 +
1.1213 + // array to ?
1.1214 + transform["array"] = {
1.1215 + "string" : arrayLikeToString,
1.1216 + "array" : identity,
1.1217 + "arraybuffer" : function (input) {
1.1218 + return (new Uint8Array(input)).buffer;
1.1219 + },
1.1220 + "uint8array" : function (input) {
1.1221 + return new Uint8Array(input);
1.1222 + },
1.1223 + "nodebuffer" : function (input) {
1.1224 + return new Buffer(input);
1.1225 + }
1.1226 + };
1.1227 +
1.1228 + // arraybuffer to ?
1.1229 + transform["arraybuffer"] = {
1.1230 + "string" : function (input) {
1.1231 + return arrayLikeToString(new Uint8Array(input));
1.1232 + },
1.1233 + "array" : function (input) {
1.1234 + return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
1.1235 + },
1.1236 + "arraybuffer" : identity,
1.1237 + "uint8array" : function (input) {
1.1238 + return new Uint8Array(input);
1.1239 + },
1.1240 + "nodebuffer" : function (input) {
1.1241 + return new Buffer(new Uint8Array(input));
1.1242 + }
1.1243 + };
1.1244 +
1.1245 + // uint8array to ?
1.1246 + transform["uint8array"] = {
1.1247 + "string" : arrayLikeToString,
1.1248 + "array" : function (input) {
1.1249 + return arrayLikeToArrayLike(input, new Array(input.length));
1.1250 + },
1.1251 + "arraybuffer" : function (input) {
1.1252 + return input.buffer;
1.1253 + },
1.1254 + "uint8array" : identity,
1.1255 + "nodebuffer" : function(input) {
1.1256 + return new Buffer(input);
1.1257 + }
1.1258 + };
1.1259 +
1.1260 + // nodebuffer to ?
1.1261 + transform["nodebuffer"] = {
1.1262 + "string" : arrayLikeToString,
1.1263 + "array" : function (input) {
1.1264 + return arrayLikeToArrayLike(input, new Array(input.length));
1.1265 + },
1.1266 + "arraybuffer" : function (input) {
1.1267 + return transform["nodebuffer"]["uint8array"](input).buffer;
1.1268 + },
1.1269 + "uint8array" : function (input) {
1.1270 + return arrayLikeToArrayLike(input, new Uint8Array(input.length));
1.1271 + },
1.1272 + "nodebuffer" : identity
1.1273 + };
1.1274 +
1.1275 + /**
1.1276 + * Transform an input into any type.
1.1277 + * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer.
1.1278 + * If no output type is specified, the unmodified input will be returned.
1.1279 + * @param {String} outputType the output type.
1.1280 + * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
1.1281 + * @throws {Error} an Error if the browser doesn't support the requested output type.
1.1282 + */
1.1283 + JSZip.utils.transformTo = function (outputType, input) {
1.1284 + if (!input) {
1.1285 + // undefined, null, etc
1.1286 + // an empty string won't harm.
1.1287 + input = "";
1.1288 + }
1.1289 + if (!outputType) {
1.1290 + return input;
1.1291 + }
1.1292 + JSZip.utils.checkSupport(outputType);
1.1293 + var inputType = JSZip.utils.getTypeOf(input);
1.1294 + var result = transform[inputType][outputType](input);
1.1295 + return result;
1.1296 + };
1.1297 +
1.1298 + /**
1.1299 + * Return the type of the input.
1.1300 + * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
1.1301 + * @param {Object} input the input to identify.
1.1302 + * @return {String} the (lowercase) type of the input.
1.1303 + */
1.1304 + JSZip.utils.getTypeOf = function (input) {
1.1305 + if (typeof input === "string") {
1.1306 + return "string";
1.1307 + }
1.1308 + if (Object.prototype.toString.call(input) === "[object Array]") {
1.1309 + return "array";
1.1310 + }
1.1311 + if (JSZip.support.nodebuffer && Buffer.isBuffer(input)) {
1.1312 + return "nodebuffer";
1.1313 + }
1.1314 + if (JSZip.support.uint8array && input instanceof Uint8Array) {
1.1315 + return "uint8array";
1.1316 + }
1.1317 + if (JSZip.support.arraybuffer && input instanceof ArrayBuffer) {
1.1318 + return "arraybuffer";
1.1319 + }
1.1320 + };
1.1321 +
1.1322 + /**
1.1323 + * Cross-window, cross-Node-context regular expression detection
1.1324 + * @param {Object} object Anything
1.1325 + * @return {Boolean} true if the object is a regular expression,
1.1326 + * false otherwise
1.1327 + */
1.1328 + JSZip.utils.isRegExp = function (object) {
1.1329 + return Object.prototype.toString.call(object) === "[object RegExp]";
1.1330 + };
1.1331 +
1.1332 + /**
1.1333 + * Throw an exception if the type is not supported.
1.1334 + * @param {String} type the type to check.
1.1335 + * @throws {Error} an Error if the browser doesn't support the requested type.
1.1336 + */
1.1337 + JSZip.utils.checkSupport = function (type) {
1.1338 + var supported = true;
1.1339 + switch (type.toLowerCase()) {
1.1340 + case "uint8array":
1.1341 + supported = JSZip.support.uint8array;
1.1342 + break;
1.1343 + case "arraybuffer":
1.1344 + supported = JSZip.support.arraybuffer;
1.1345 + break;
1.1346 + case "nodebuffer":
1.1347 + supported = JSZip.support.nodebuffer;
1.1348 + break;
1.1349 + case "blob":
1.1350 + supported = JSZip.support.blob;
1.1351 + break;
1.1352 + }
1.1353 + if (!supported) {
1.1354 + throw new Error(type + " is not supported by this browser");
1.1355 + }
1.1356 + };
1.1357 +
1.1358 +
1.1359 +})();
1.1360 +
1.1361 +(function (){
1.1362 + /**
1.1363 + * Represents an entry in the zip.
1.1364 + * The content may or may not be compressed.
1.1365 + * @constructor
1.1366 + */
1.1367 + JSZip.CompressedObject = function () {
1.1368 + this.compressedSize = 0;
1.1369 + this.uncompressedSize = 0;
1.1370 + this.crc32 = 0;
1.1371 + this.compressionMethod = null;
1.1372 + this.compressedContent = null;
1.1373 + };
1.1374 +
1.1375 + JSZip.CompressedObject.prototype = {
1.1376 + /**
1.1377 + * Return the decompressed content in an unspecified format.
1.1378 + * The format will depend on the decompressor.
1.1379 + * @return {Object} the decompressed content.
1.1380 + */
1.1381 + getContent : function () {
1.1382 + return null; // see implementation
1.1383 + },
1.1384 + /**
1.1385 + * Return the compressed content in an unspecified format.
1.1386 + * The format will depend on the compressed conten source.
1.1387 + * @return {Object} the compressed content.
1.1388 + */
1.1389 + getCompressedContent : function () {
1.1390 + return null; // see implementation
1.1391 + }
1.1392 + };
1.1393 +})();
1.1394 +
1.1395 +/**
1.1396 + *
1.1397 + * Base64 encode / decode
1.1398 + * http://www.webtoolkit.info/
1.1399 + *
1.1400 + * Hacked so that it doesn't utf8 en/decode everything
1.1401 + **/
1.1402 +JSZip.base64 = (function() {
1.1403 + // private property
1.1404 + var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
1.1405 +
1.1406 + return {
1.1407 + // public method for encoding
1.1408 + encode : function(input, utf8) {
1.1409 + var output = "";
1.1410 + var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
1.1411 + var i = 0;
1.1412 +
1.1413 + while (i < input.length) {
1.1414 +
1.1415 + chr1 = input.charCodeAt(i++);
1.1416 + chr2 = input.charCodeAt(i++);
1.1417 + chr3 = input.charCodeAt(i++);
1.1418 +
1.1419 + enc1 = chr1 >> 2;
1.1420 + enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
1.1421 + enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
1.1422 + enc4 = chr3 & 63;
1.1423 +
1.1424 + if (isNaN(chr2)) {
1.1425 + enc3 = enc4 = 64;
1.1426 + } else if (isNaN(chr3)) {
1.1427 + enc4 = 64;
1.1428 + }
1.1429 +
1.1430 + output = output +
1.1431 + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) +
1.1432 + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
1.1433 +
1.1434 + }
1.1435 +
1.1436 + return output;
1.1437 + },
1.1438 +
1.1439 + // public method for decoding
1.1440 + decode : function(input, utf8) {
1.1441 + var output = "";
1.1442 + var chr1, chr2, chr3;
1.1443 + var enc1, enc2, enc3, enc4;
1.1444 + var i = 0;
1.1445 +
1.1446 + input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
1.1447 +
1.1448 + while (i < input.length) {
1.1449 +
1.1450 + enc1 = _keyStr.indexOf(input.charAt(i++));
1.1451 + enc2 = _keyStr.indexOf(input.charAt(i++));
1.1452 + enc3 = _keyStr.indexOf(input.charAt(i++));
1.1453 + enc4 = _keyStr.indexOf(input.charAt(i++));
1.1454 +
1.1455 + chr1 = (enc1 << 2) | (enc2 >> 4);
1.1456 + chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
1.1457 + chr3 = ((enc3 & 3) << 6) | enc4;
1.1458 +
1.1459 + output = output + String.fromCharCode(chr1);
1.1460 +
1.1461 + if (enc3 != 64) {
1.1462 + output = output + String.fromCharCode(chr2);
1.1463 + }
1.1464 + if (enc4 != 64) {
1.1465 + output = output + String.fromCharCode(chr3);
1.1466 + }
1.1467 +
1.1468 + }
1.1469 +
1.1470 + return output;
1.1471 +
1.1472 + }
1.1473 + };
1.1474 +}());
1.1475 +
1.1476 +// enforcing Stuk's coding style
1.1477 +// vim: set shiftwidth=3 softtabstop=3: