| /** |
| |
| JSZip - A Javascript class for generating and reading zip files |
| <http://stuartk.com/jszip> |
| |
| (c) 2009-2012 Stuart Knightley <stuart [at] stuartk.com> |
| Dual licenced under the MIT license or GPLv3. See LICENSE.markdown. |
| |
| Usage: |
| zip = new JSZip(); |
| zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing"); |
| zip.folder("images").file("smile.gif", base64Data, {base64: true}); |
| zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")}); |
| zip.remove("tempfile"); |
| |
| base64zip = zip.generate(); |
| |
| **/ |
| "use strict"; |
| |
| /** |
| * Representation a of zip file in js |
| * @constructor |
| * @param {String=|ArrayBuffer=|Uint8Array=|Buffer=} data the data to load, if any (optional). |
| * @param {Object=} options the options for creating this objects (optional). |
| */ |
| var JSZip = function(data, options) { |
| // object containing the files : |
| // { |
| // "folder/" : {...}, |
| // "folder/data.txt" : {...} |
| // } |
| this.files = {}; |
| |
| // Where we are in the hierarchy |
| this.root = ""; |
| |
| if (data) { |
| this.load(data, options); |
| } |
| }; |
| |
| JSZip.signature = { |
| LOCAL_FILE_HEADER : "\x50\x4b\x03\x04", |
| CENTRAL_FILE_HEADER : "\x50\x4b\x01\x02", |
| CENTRAL_DIRECTORY_END : "\x50\x4b\x05\x06", |
| ZIP64_CENTRAL_DIRECTORY_LOCATOR : "\x50\x4b\x06\x07", |
| ZIP64_CENTRAL_DIRECTORY_END : "\x50\x4b\x06\x06", |
| DATA_DESCRIPTOR : "\x50\x4b\x07\x08" |
| }; |
| |
| // Default properties for a new file |
| JSZip.defaults = { |
| base64: false, |
| binary: false, |
| dir: false, |
| date: null, |
| compression: null |
| }; |
| |
| |
| JSZip.prototype = (function () { |
| |
| /** |
| * Returns the raw data of a ZipObject, decompress the content if necessary. |
| * @param {ZipObject} file the file to use. |
| * @return {String|ArrayBuffer|Uint8Array|Buffer} the data. |
| */ |
| var getRawData = function (file) { |
| if (file._data instanceof JSZip.CompressedObject) { |
| file._data = file._data.getContent(); |
| file.options.binary = true; |
| file.options.base64 = false; |
| |
| if (JSZip.utils.getTypeOf(file._data) === "uint8array") { |
| var copy = file._data; |
| // when reading an arraybuffer, the CompressedObject mechanism will keep it and subarray() a Uint8Array. |
| // if we request a file in the same format, we might get the same Uint8Array or its ArrayBuffer (the original zip file). |
| file._data = new Uint8Array(copy.length); |
| // with an empty Uint8Array, Opera fails with a "Offset larger than array size" |
| if (copy.length !== 0) { |
| file._data.set(copy, 0); |
| } |
| } |
| } |
| return file._data; |
| }; |
| |
| /** |
| * Returns the data of a ZipObject in a binary form. If the content is an unicode string, encode it. |
| * @param {ZipObject} file the file to use. |
| * @return {String|ArrayBuffer|Uint8Array|Buffer} the data. |
| */ |
| var getBinaryData = function (file) { |
| var result = getRawData(file), type = JSZip.utils.getTypeOf(result); |
| if (type === "string") { |
| if (!file.options.binary) { |
| // unicode text ! |
| // unicode string => binary string is a painful process, check if we can avoid it. |
| if (JSZip.support.uint8array && typeof TextEncoder === "function") { |
| return TextEncoder("utf-8").encode(result); |
| } |
| if (JSZip.support.nodebuffer) { |
| return new Buffer(result, "utf-8"); |
| } |
| } |
| return file.asBinary(); |
| } |
| return result; |
| } |
| |
| /** |
| * Transform this._data into a string. |
| * @param {function} filter a function String -> String, applied if not null on the result. |
| * @return {String} the string representing this._data. |
| */ |
| var dataToString = function (asUTF8) { |
| var result = getRawData(this); |
| if (result === null || typeof result === "undefined") { |
| return ""; |
| } |
| // if the data is a base64 string, we decode it before checking the encoding ! |
| if (this.options.base64) { |
| result = JSZip.base64.decode(result); |
| } |
| if (asUTF8 && this.options.binary) { |
| // JSZip.prototype.utf8decode supports arrays as input |
| // skip to array => string step, utf8decode will do it. |
| result = JSZip.prototype.utf8decode(result); |
| } else { |
| // no utf8 transformation, do the array => string step. |
| result = JSZip.utils.transformTo("string", result); |
| } |
| |
| if (!asUTF8 && !this.options.binary) { |
| result = JSZip.prototype.utf8encode(result); |
| } |
| return result; |
| }; |
| /** |
| * A simple object representing a file in the zip file. |
| * @constructor |
| * @param {string} name the name of the file |
| * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data |
| * @param {Object} options the options of the file |
| */ |
| var ZipObject = function (name, data, options) { |
| this.name = name; |
| this._data = data; |
| this.options = options; |
| }; |
| |
| ZipObject.prototype = { |
| /** |
| * Return the content as UTF8 string. |
| * @return {string} the UTF8 string. |
| */ |
| asText : function () { |
| return dataToString.call(this, true); |
| }, |
| /** |
| * Returns the binary content. |
| * @return {string} the content as binary. |
| */ |
| asBinary : function () { |
| return dataToString.call(this, false); |
| }, |
| /** |
| * Returns the content as a nodejs Buffer. |
| * @return {Buffer} the content as a Buffer. |
| */ |
| asNodeBuffer : function () { |
| var result = getBinaryData(this); |
| return JSZip.utils.transformTo("nodebuffer", result); |
| }, |
| /** |
| * Returns the content as an Uint8Array. |
| * @return {Uint8Array} the content as an Uint8Array. |
| */ |
| asUint8Array : function () { |
| var result = getBinaryData(this); |
| return JSZip.utils.transformTo("uint8array", result); |
| }, |
| /** |
| * Returns the content as an ArrayBuffer. |
| * @return {ArrayBuffer} the content as an ArrayBufer. |
| */ |
| asArrayBuffer : function () { |
| return this.asUint8Array().buffer; |
| } |
| }; |
| |
| /** |
| * Transform an integer into a string in hexadecimal. |
| * @private |
| * @param {number} dec the number to convert. |
| * @param {number} bytes the number of bytes to generate. |
| * @returns {string} the result. |
| */ |
| var decToHex = function(dec, bytes) { |
| var hex = "", i; |
| for(i = 0; i < bytes; i++) { |
| hex += String.fromCharCode(dec&0xff); |
| dec=dec>>>8; |
| } |
| return hex; |
| }; |
| |
| /** |
| * Merge the objects passed as parameters into a new one. |
| * @private |
| * @param {...Object} var_args All objects to merge. |
| * @return {Object} a new object with the data of the others. |
| */ |
| var extend = function () { |
| var result = {}, i, attr; |
| for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers |
| for (attr in arguments[i]) { |
| if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") { |
| result[attr] = arguments[i][attr]; |
| } |
| } |
| } |
| return result; |
| }; |
| |
| /** |
| * Transforms the (incomplete) options from the user into the complete |
| * set of options to create a file. |
| * @private |
| * @param {Object} o the options from the user. |
| * @return {Object} the complete set of options. |
| */ |
| var prepareFileAttrs = function (o) { |
| o = o || {}; |
| if (o.base64 === true && o.binary == null) { |
| o.binary = true; |
| } |
| o = extend(o, JSZip.defaults); |
| o.date = o.date || new Date(); |
| if (o.compression !== null) o.compression = o.compression.toUpperCase(); |
| |
| return o; |
| }; |
| |
| /** |
| * Add a file in the current folder. |
| * @private |
| * @param {string} name the name of the file |
| * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file |
| * @param {Object} o the options of the file |
| * @return {Object} the new file. |
| */ |
| var fileAdd = function (name, data, o) { |
| // be sure sub folders exist |
| var parent = parentFolder(name), dataType = JSZip.utils.getTypeOf(data); |
| if (parent) { |
| folderAdd.call(this, parent); |
| } |
| |
| o = prepareFileAttrs(o); |
| |
| if (o.dir || data === null || typeof data === "undefined") { |
| o.base64 = false; |
| o.binary = false; |
| data = null; |
| } else if (dataType === "string") { |
| if (o.binary && !o.base64) { |
| // optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask |
| if (o.optimizedBinaryString !== true) { |
| // this is a string, not in a base64 format. |
| // Be sure that this is a correct "binary string" |
| data = JSZip.utils.string2binary(data); |
| } |
| } |
| } else { // arraybuffer, uint8array, ... |
| o.base64 = false; |
| o.binary = true; |
| |
| if (!dataType && !(data instanceof JSZip.CompressedObject)) { |
| throw new Error("The data of '" + name + "' is in an unsupported format !"); |
| } |
| |
| // special case : it's way easier to work with Uint8Array than with ArrayBuffer |
| if (dataType === "arraybuffer") { |
| data = JSZip.utils.transformTo("uint8array", data); |
| } |
| } |
| |
| return this.files[name] = new ZipObject(name, data, o); |
| }; |
| |
| |
| /** |
| * Find the parent folder of the path. |
| * @private |
| * @param {string} path the path to use |
| * @return {string} the parent folder, or "" |
| */ |
| var parentFolder = function (path) { |
| if (path.slice(-1) == '/') { |
| path = path.substring(0, path.length - 1); |
| } |
| var lastSlash = path.lastIndexOf('/'); |
| return (lastSlash > 0) ? path.substring(0, lastSlash) : ""; |
| }; |
| |
| /** |
| * Add a (sub) folder in the current folder. |
| * @private |
| * @param {string} name the folder's name |
| * @return {Object} the new folder. |
| */ |
| var folderAdd = function (name) { |
| // Check the name ends with a / |
| if (name.slice(-1) != "/") { |
| name += "/"; // IE doesn't like substr(-1) |
| } |
| |
| // Does this folder already exist? |
| if (!this.files[name]) { |
| fileAdd.call(this, name, null, {dir:true}); |
| } |
| return this.files[name]; |
| }; |
| |
| /** |
| * Generate a JSZip.CompressedObject for a given zipOject. |
| * @param {ZipObject} file the object to read. |
| * @param {JSZip.compression} compression the compression to use. |
| * @return {JSZip.CompressedObject} the compressed result. |
| */ |
| var generateCompressedObjectFrom = function (file, compression) { |
| var result = new JSZip.CompressedObject(), content; |
| |
| // the data has not been decompressed, we might reuse things ! |
| if (file._data instanceof JSZip.CompressedObject) { |
| result.uncompressedSize = file._data.uncompressedSize; |
| result.crc32 = file._data.crc32; |
| |
| if (result.uncompressedSize === 0 || file.options.dir) { |
| compression = JSZip.compressions['STORE']; |
| result.compressedContent = ""; |
| result.crc32 = 0; |
| } else if (file._data.compressionMethod === compression.magic) { |
| result.compressedContent = file._data.getCompressedContent(); |
| } else { |
| content = file._data.getContent() |
| // need to decompress / recompress |
| result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content)); |
| } |
| } else { |
| // have uncompressed data |
| content = getBinaryData(file); |
| if (!content || content.length === 0 || file.options.dir) { |
| compression = JSZip.compressions['STORE']; |
| content = ""; |
| } |
| result.uncompressedSize = content.length; |
| result.crc32 = this.crc32(content); |
| result.compressedContent = compression.compress(JSZip.utils.transformTo(compression.compressInputType, content)); |
| } |
| |
| result.compressedSize = result.compressedContent.length; |
| result.compressionMethod = compression.magic; |
| |
| return result; |
| }; |
| |
| /** |
| * Generate the various parts used in the construction of the final zip file. |
| * @param {string} name the file name. |
| * @param {ZipObject} file the file content. |
| * @param {JSZip.CompressedObject} compressedObject the compressed object. |
| * @param {number} offset the current offset from the start of the zip file. |
| * @return {object} the zip parts. |
| */ |
| var generateZipParts = function(name, file, compressedObject, offset) { |
| var data = compressedObject.compressedContent, |
| utfEncodedFileName = this.utf8encode(file.name), |
| useUTF8 = utfEncodedFileName !== file.name, |
| o = file.options, |
| dosTime, |
| dosDate; |
| |
| // date |
| // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html |
| // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html |
| // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html |
| |
| dosTime = o.date.getHours(); |
| dosTime = dosTime << 6; |
| dosTime = dosTime | o.date.getMinutes(); |
| dosTime = dosTime << 5; |
| dosTime = dosTime | o.date.getSeconds() / 2; |
| |
| dosDate = o.date.getFullYear() - 1980; |
| dosDate = dosDate << 4; |
| dosDate = dosDate | (o.date.getMonth() + 1); |
| dosDate = dosDate << 5; |
| dosDate = dosDate | o.date.getDate(); |
| |
| |
| var header = ""; |
| |
| // version needed to extract |
| header += "\x0A\x00"; |
| // general purpose bit flag |
| // set bit 11 if utf8 |
| header += useUTF8 ? "\x00\x08" : "\x00\x00"; |
| // compression method |
| header += compressedObject.compressionMethod; |
| // last mod file time |
| header += decToHex(dosTime, 2); |
| // last mod file date |
| header += decToHex(dosDate, 2); |
| // crc-32 |
| header += decToHex(compressedObject.crc32, 4); |
| // compressed size |
| header += decToHex(compressedObject.compressedSize, 4); |
| // uncompressed size |
| header += decToHex(compressedObject.uncompressedSize, 4); |
| // file name length |
| header += decToHex(utfEncodedFileName.length, 2); |
| // extra field length |
| header += "\x00\x00"; |
| |
| |
| var fileRecord = JSZip.signature.LOCAL_FILE_HEADER + header + utfEncodedFileName; |
| |
| var dirRecord = JSZip.signature.CENTRAL_FILE_HEADER + |
| // version made by (00: DOS) |
| "\x14\x00" + |
| // file header (common to file and central directory) |
| header + |
| // file comment length |
| "\x00\x00" + |
| // disk number start |
| "\x00\x00" + |
| // internal file attributes TODO |
| "\x00\x00" + |
| // external file attributes |
| (file.options.dir===true?"\x10\x00\x00\x00":"\x00\x00\x00\x00")+ |
| // relative offset of local header |
| decToHex(offset, 4) + |
| // file name |
| utfEncodedFileName; |
| |
| |
| return { |
| fileRecord : fileRecord, |
| dirRecord : dirRecord, |
| compressedObject : compressedObject |
| }; |
| }; |
| |
| /** |
| * An object to write any content to a string. |
| * @constructor |
| */ |
| var StringWriter = function () { |
| this.data = []; |
| }; |
| StringWriter.prototype = { |
| /** |
| * Append any content to the current string. |
| * @param {Object} input the content to add. |
| */ |
| append : function (input) { |
| input = JSZip.utils.transformTo("string", input); |
| this.data.push(input); |
| }, |
| /** |
| * Finalize the construction an return the result. |
| * @return {string} the generated string. |
| */ |
| finalize : function () { |
| return this.data.join(""); |
| } |
| }; |
| /** |
| * An object to write any content to an Uint8Array. |
| * @constructor |
| * @param {number} length The length of the array. |
| */ |
| var Uint8ArrayWriter = function (length) { |
| this.data = new Uint8Array(length); |
| this.index = 0; |
| }; |
| Uint8ArrayWriter.prototype = { |
| /** |
| * Append any content to the current array. |
| * @param {Object} input the content to add. |
| */ |
| append : function (input) { |
| if (input.length !== 0) { |
| // with an empty Uint8Array, Opera fails with a "Offset larger than array size" |
| input = JSZip.utils.transformTo("uint8array", input); |
| this.data.set(input, this.index); |
| this.index += input.length; |
| } |
| }, |
| /** |
| * Finalize the construction an return the result. |
| * @return {Uint8Array} the generated array. |
| */ |
| finalize : function () { |
| return this.data; |
| } |
| }; |
| |
| // return the actual prototype of JSZip |
| return { |
| /** |
| * Read an existing zip and merge the data in the current JSZip object. |
| * The implementation is in jszip-load.js, don't forget to include it. |
| * @param {String|ArrayBuffer|Uint8Array|Buffer} stream The stream to load |
| * @param {Object} options Options for loading the stream. |
| * options.base64 : is the stream in base64 ? default : false |
| * @return {JSZip} the current JSZip object |
| */ |
| load : function (stream, options) { |
| throw new Error("Load method is not defined. Is the file jszip-load.js included ?"); |
| }, |
| |
| /** |
| * Filter nested files/folders with the specified function. |
| * @param {Function} search the predicate to use : |
| * function (relativePath, file) {...} |
| * It takes 2 arguments : the relative path and the file. |
| * @return {Array} An array of matching elements. |
| */ |
| filter : function (search) { |
| var result = [], filename, relativePath, file, fileClone; |
| for (filename in this.files) { |
| if ( !this.files.hasOwnProperty(filename) ) { continue; } |
| file = this.files[filename]; |
| // return a new object, don't let the user mess with our internal objects :) |
| fileClone = new ZipObject(file.name, file._data, extend(file.options)); |
| relativePath = filename.slice(this.root.length, filename.length); |
| if (filename.slice(0, this.root.length) === this.root && // the file is in the current root |
| search(relativePath, fileClone)) { // and the file matches the function |
| result.push(fileClone); |
| } |
| } |
| return result; |
| }, |
| |
| /** |
| * Add a file to the zip file, or search a file. |
| * @param {string|RegExp} name The name of the file to add (if data is defined), |
| * the name of the file to find (if no data) or a regex to match files. |
| * @param {String|ArrayBuffer|Uint8Array|Buffer} data The file data, either raw or base64 encoded |
| * @param {Object} o File options |
| * @return {JSZip|Object|Array} this JSZip object (when adding a file), |
| * a file (when searching by string) or an array of files (when searching by regex). |
| */ |
| file : function(name, data, o) { |
| if (arguments.length === 1) { |
| if (name instanceof RegExp) { |
| var regexp = name; |
| return this.filter(function(relativePath, file) { |
| return !file.options.dir && regexp.test(relativePath); |
| }); |
| } else { // text |
| return this.filter(function (relativePath, file) { |
| return !file.options.dir && relativePath === name; |
| })[0]||null; |
| } |
| } else { // more than one argument : we have data ! |
| name = this.root+name; |
| fileAdd.call(this, name, data, o); |
| } |
| return this; |
| }, |
| |
| /** |
| * Add a directory to the zip file, or search. |
| * @param {String|RegExp} arg The name of the directory to add, or a regex to search folders. |
| * @return {JSZip} an object with the new directory as the root, or an array containing matching folders. |
| */ |
| folder : function(arg) { |
| if (!arg) { |
| return this; |
| } |
| |
| if (arg instanceof RegExp) { |
| return this.filter(function(relativePath, file) { |
| return file.options.dir && arg.test(relativePath); |
| }); |
| } |
| |
| // else, name is a new folder |
| var name = this.root + arg; |
| var newFolder = folderAdd.call(this, name); |
| |
| // Allow chaining by returning a new object with this folder as the root |
| var ret = this.clone(); |
| ret.root = newFolder.name; |
| return ret; |
| }, |
| |
| /** |
| * Delete a file, or a directory and all sub-files, from the zip |
| * @param {string} name the name of the file to delete |
| * @return {JSZip} this JSZip object |
| */ |
| remove : function(name) { |
| name = this.root + name; |
| var file = this.files[name]; |
| if (!file) { |
| // Look for any folders |
| if (name.slice(-1) != "/") { |
| name += "/"; |
| } |
| file = this.files[name]; |
| } |
| |
| if (file) { |
| if (!file.options.dir) { |
| // file |
| delete this.files[name]; |
| } else { |
| // folder |
| var kids = this.filter(function (relativePath, file) { |
| return file.name.slice(0, name.length) === name; |
| }); |
| for (var i = 0; i < kids.length; i++) { |
| delete this.files[kids[i].name]; |
| } |
| } |
| } |
| |
| return this; |
| }, |
| |
| /** |
| * Generate the complete zip file |
| * @param {Object} options the options to generate the zip file : |
| * - base64, (deprecated, use type instead) true to generate base64. |
| * - compression, "STORE" by default. |
| * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob. |
| * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file |
| */ |
| generate : function(options) { |
| options = extend(options || {}, { |
| base64 : true, |
| compression : "STORE", |
| type : "base64" |
| }); |
| |
| JSZip.utils.checkSupport(options.type); |
| |
| var zipData = [], localDirLength = 0, centralDirLength = 0, writer, i; |
| |
| |
| // first, generate all the zip parts. |
| for (var name in this.files) { |
| if ( !this.files.hasOwnProperty(name) ) { continue; } |
| var file = this.files[name]; |
| |
| var compressionName = file.compression || options.compression.toUpperCase(); |
| var compression = JSZip.compressions[compressionName]; |
| if (!compression) { |
| throw new Error(compressionName + " is not a valid compression method !"); |
| } |
| |
| var compressedObject = generateCompressedObjectFrom.call(this, file, compression); |
| |
| var zipPart = generateZipParts.call(this, name, file, compressedObject, localDirLength); |
| localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize; |
| centralDirLength += zipPart.dirRecord.length; |
| zipData.push(zipPart); |
| } |
| |
| var dirEnd = ""; |
| |
| // end of central dir signature |
| dirEnd = JSZip.signature.CENTRAL_DIRECTORY_END + |
| // number of this disk |
| "\x00\x00" + |
| // number of the disk with the start of the central directory |
| "\x00\x00" + |
| // total number of entries in the central directory on this disk |
| decToHex(zipData.length, 2) + |
| // total number of entries in the central directory |
| decToHex(zipData.length, 2) + |
| // size of the central directory 4 bytes |
| decToHex(centralDirLength, 4) + |
| // offset of start of central directory with respect to the starting disk number |
| decToHex(localDirLength, 4) + |
| // .ZIP file comment length |
| "\x00\x00"; |
| |
| |
| // we have all the parts (and the total length) |
| // time to create a writer ! |
| switch(options.type.toLowerCase()) { |
| case "uint8array" : |
| case "arraybuffer" : |
| case "blob" : |
| case "nodebuffer" : |
| writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length); |
| break; |
| case "base64" : |
| default : // case "string" : |
| writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length); |
| break; |
| } |
| |
| for (i = 0; i < zipData.length; i++) { |
| writer.append(zipData[i].fileRecord); |
| writer.append(zipData[i].compressedObject.compressedContent); |
| } |
| for (i = 0; i < zipData.length; i++) { |
| writer.append(zipData[i].dirRecord); |
| } |
| |
| writer.append(dirEnd); |
| |
| var zip = writer.finalize(); |
| |
| |
| |
| switch(options.type.toLowerCase()) { |
| // case "zip is an Uint8Array" |
| case "uint8array" : |
| case "arraybuffer" : |
| case "nodebuffer" : |
| return JSZip.utils.transformTo(options.type.toLowerCase(), zip); |
| case "blob" : |
| return JSZip.utils.arrayBuffer2Blob(JSZip.utils.transformTo("arraybuffer", zip)); |
| |
| // case "zip is a string" |
| case "base64" : |
| return (options.base64) ? JSZip.base64.encode(zip) : zip; |
| default : // case "string" : |
| return zip; |
| } |
| }, |
| |
| /** |
| * |
| * Javascript crc32 |
| * http://www.webtoolkit.info/ |
| * |
| */ |
| crc32 : function crc32(input, crc) { |
| if (typeof input === "undefined" || !input.length) { |
| return 0; |
| } |
| |
| var isArray = JSZip.utils.getTypeOf(input) !== "string"; |
| |
| var table = [ |
| 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, |
| 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, |
| 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, |
| 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, |
| 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, |
| 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, |
| 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, |
| 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, |
| 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, |
| 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, |
| 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, |
| 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, |
| 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, |
| 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, |
| 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, |
| 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, |
| 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, |
| 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, |
| 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, |
| 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, |
| 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, |
| 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, |
| 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, |
| 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, |
| 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, |
| 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, |
| 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, |
| 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, |
| 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, |
| 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, |
| 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, |
| 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, |
| 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, |
| 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, |
| 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, |
| 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, |
| 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, |
| 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, |
| 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, |
| 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, |
| 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, |
| 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, |
| 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, |
| 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, |
| 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, |
| 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, |
| 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, |
| 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, |
| 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, |
| 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, |
| 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, |
| 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, |
| 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, |
| 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, |
| 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, |
| 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, |
| 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, |
| 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, |
| 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, |
| 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, |
| 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, |
| 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, |
| 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, |
| 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D |
| ]; |
| |
| if (typeof(crc) == "undefined") { crc = 0; } |
| var x = 0; |
| var y = 0; |
| var byte = 0; |
| |
| crc = crc ^ (-1); |
| for( var i = 0, iTop = input.length; i < iTop; i++ ) { |
| byte = isArray ? input[i] : input.charCodeAt(i); |
| y = ( crc ^ byte ) & 0xFF; |
| x = table[y]; |
| crc = ( crc >>> 8 ) ^ x; |
| } |
| |
| return crc ^ (-1); |
| }, |
| |
| // Inspired by http://my.opera.com/GreyWyvern/blog/show.dml/1725165 |
| clone : function() { |
| var newObj = new JSZip(); |
| for (var i in this) { |
| if (typeof this[i] !== "function") { |
| newObj[i] = this[i]; |
| } |
| } |
| return newObj; |
| }, |
| |
| |
| /** |
| * http://www.webtoolkit.info/javascript-utf8.html |
| */ |
| utf8encode : function (string) { |
| // TextEncoder + Uint8Array to binary string is faster than checking every bytes on long strings. |
| // http://jsperf.com/utf8encode-vs-textencoder |
| // On short strings (file names for example), the TextEncoder API is (currently) slower. |
| if (JSZip.support.uint8array && typeof TextEncoder === "function") { |
| var u8 = TextEncoder("utf-8").encode(string); |
| return JSZip.utils.transformTo("string", u8); |
| } |
| if (JSZip.support.nodebuffer) { |
| return JSZip.utils.transformTo("string", new Buffer(string, "utf-8")); |
| } |
| |
| // array.join may be slower than string concatenation but generates less objects (less time spent garbage collecting). |
| // See also http://jsperf.com/array-direct-assignment-vs-push/31 |
| var result = [], resIndex = 0; |
| |
| for (var n = 0; n < string.length; n++) { |
| |
| var c = string.charCodeAt(n); |
| |
| if (c < 128) { |
| result[resIndex++] = String.fromCharCode(c); |
| } else if ((c > 127) && (c < 2048)) { |
| result[resIndex++] = String.fromCharCode((c >> 6) | 192); |
| result[resIndex++] = String.fromCharCode((c & 63) | 128); |
| } else { |
| result[resIndex++] = String.fromCharCode((c >> 12) | 224); |
| result[resIndex++] = String.fromCharCode(((c >> 6) & 63) | 128); |
| result[resIndex++] = String.fromCharCode((c & 63) | 128); |
| } |
| |
| } |
| |
| return result.join(""); |
| }, |
| |
| /** |
| * http://www.webtoolkit.info/javascript-utf8.html |
| */ |
| utf8decode : function (input) { |
| var result = [], resIndex = 0; |
| var type = JSZip.utils.getTypeOf(input); |
| var isArray = type !== "string"; |
| var i = 0; |
| var c = 0, c1 = 0, c2 = 0, c3 = 0; |
| |
| // check if we can use the TextDecoder API |
| // see http://encoding.spec.whatwg.org/#api |
| if (JSZip.support.uint8array && typeof TextDecoder === "function") { |
| return TextDecoder("utf-8").decode( |
| JSZip.utils.transformTo("uint8array", input) |
| ); |
| } |
| if (JSZip.support.nodebuffer) { |
| return JSZip.utils.transformTo("nodebuffer", input).toString("utf-8"); |
| } |
| |
| while ( i < input.length ) { |
| |
| c = isArray ? input[i] : input.charCodeAt(i); |
| |
| if (c < 128) { |
| result[resIndex++] = String.fromCharCode(c); |
| i++; |
| } else if ((c > 191) && (c < 224)) { |
| c2 = isArray ? input[i+1] : input.charCodeAt(i+1); |
| result[resIndex++] = String.fromCharCode(((c & 31) << 6) | (c2 & 63)); |
| i += 2; |
| } else { |
| c2 = isArray ? input[i+1] : input.charCodeAt(i+1); |
| c3 = isArray ? input[i+2] : input.charCodeAt(i+2); |
| result[resIndex++] = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)); |
| i += 3; |
| } |
| |
| } |
| |
| return result.join(""); |
| } |
| }; |
| }()); |
| |
| /* |
| * Compression methods |
| * This object is filled in as follow : |
| * name : { |
| * magic // the 2 bytes indentifying the compression method |
| * compress // function, take the uncompressed content and return it compressed. |
| * uncompress // function, take the compressed content and return it uncompressed. |
| * compressInputType // string, the type accepted by the compress method. null to accept everything. |
| * uncompressInputType // string, the type accepted by the uncompress method. null to accept everything. |
| * } |
| * |
| * STORE is the default compression method, so it's included in this file. |
| * Other methods should go to separated files : the user wants modularity. |
| */ |
| JSZip.compressions = { |
| "STORE" : { |
| magic : "\x00\x00", |
| compress : function (content) { |
| return content; // no compression |
| }, |
| uncompress : function (content) { |
| return content; // no compression |
| }, |
| compressInputType : null, |
| uncompressInputType : null |
| } |
| }; |
| |
| /* |
| * List features that require a modern browser, and if the current browser support them. |
| */ |
| JSZip.support = { |
| // contains true if JSZip can read/generate ArrayBuffer, false otherwise. |
| arraybuffer : (function(){ |
| return typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined"; |
| })(), |
| // contains true if JSZip can read/generate nodejs Buffer, false otherwise. |
| nodebuffer : (function(){ |
| return typeof Buffer !== "undefined"; |
| })(), |
| // contains true if JSZip can read/generate Uint8Array, false otherwise. |
| uint8array : (function(){ |
| return typeof Uint8Array !== "undefined"; |
| })(), |
| // contains true if JSZip can read/generate Blob, false otherwise. |
| blob : (function(){ |
| // the spec started with BlobBuilder then replaced it with a construtor for Blob. |
| // Result : we have browsers that : |
| // * know the BlobBuilder (but with prefix) |
| // * know the Blob constructor |
| // * know about Blob but not about how to build them |
| // About the "=== 0" test : if given the wrong type, it may be converted to a string. |
| // Instead of an empty content, we will get "[object Uint8Array]" for example. |
| if (typeof ArrayBuffer === "undefined") { |
| return false; |
| } |
| var buffer = new ArrayBuffer(0); |
| try { |
| return new Blob([buffer], { type: "application/zip" }).size === 0; |
| } |
| catch(e) {} |
| |
| try { |
| var builder = new (window.BlobBuilder || window.WebKitBlobBuilder || |
| window.MozBlobBuilder || window.MSBlobBuilder)(); |
| builder.append(buffer); |
| return builder.getBlob('application/zip').size === 0; |
| } |
| catch(e) {} |
| |
| return false; |
| })() |
| }; |
| |
| (function () { |
| JSZip.utils = { |
| /** |
| * Convert a string to a "binary string" : a string containing only char codes between 0 and 255. |
| * @param {string} str the string to transform. |
| * @return {String} the binary string. |
| */ |
| string2binary : function (str) { |
| var result = ""; |
| for (var i = 0; i < str.length; i++) { |
| result += String.fromCharCode(str.charCodeAt(i) & 0xff); |
| } |
| return result; |
| }, |
| /** |
| * Create a Uint8Array from the string. |
| * @param {string} str the string to transform. |
| * @return {Uint8Array} the typed array. |
| * @throws {Error} an Error if the browser doesn't support the requested feature. |
| * @deprecated : use JSZip.utils.transformTo instead. |
| */ |
| string2Uint8Array : function (str) { |
| return JSZip.utils.transformTo("uint8array", str); |
| }, |
| |
| /** |
| * Create a string from the Uint8Array. |
| * @param {Uint8Array} array the array to transform. |
| * @return {string} the string. |
| * @throws {Error} an Error if the browser doesn't support the requested feature. |
| * @deprecated : use JSZip.utils.transformTo instead. |
| */ |
| uint8Array2String : function (array) { |
| return JSZip.utils.transformTo("string", array); |
| }, |
| /** |
| * Create a blob from the given ArrayBuffer. |
| * @param {ArrayBuffer} buffer the buffer to transform. |
| * @return {Blob} the result. |
| * @throws {Error} an Error if the browser doesn't support the requested feature. |
| */ |
| arrayBuffer2Blob : function (buffer) { |
| JSZip.utils.checkSupport("blob"); |
| |
| try { |
| // Blob constructor |
| return new Blob([buffer], { type: "application/zip" }); |
| } |
| catch(e) {} |
| |
| try { |
| // deprecated, browser only, old way |
| var builder = new (window.BlobBuilder || window.WebKitBlobBuilder || |
| window.MozBlobBuilder || window.MSBlobBuilder)(); |
| builder.append(buffer); |
| return builder.getBlob('application/zip'); |
| } |
| catch(e) {} |
| |
| // well, fuck ?! |
| throw new Error("Bug : can't construct the Blob."); |
| }, |
| /** |
| * Create a blob from the given string. |
| * @param {string} str the string to transform. |
| * @return {Blob} the result. |
| * @throws {Error} an Error if the browser doesn't support the requested feature. |
| */ |
| string2Blob : function (str) { |
| var buffer = JSZip.utils.transformTo("arraybuffer", str); |
| return JSZip.utils.arrayBuffer2Blob(buffer); |
| } |
| }; |
| |
| /** |
| * The identity function. |
| * @param {Object} input the input. |
| * @return {Object} the same input. |
| */ |
| function identity(input) { |
| return input; |
| }; |
| |
| /** |
| * Fill in an array with a string. |
| * @param {String} str the string to use. |
| * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated). |
| * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array. |
| */ |
| function stringToArrayLike(str, array) { |
| for (var i = 0; i < str.length; ++i) { |
| array[i] = str.charCodeAt(i) & 0xFF; |
| } |
| return array; |
| }; |
| |
| /** |
| * Transform an array-like object to a string. |
| * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform. |
| * @return {String} the result. |
| */ |
| function arrayLikeToString(array) { |
| // Performances notes : |
| // -------------------- |
| // String.fromCharCode.apply(null, array) is the fastest, see |
| // see http://jsperf.com/converting-a-uint8array-to-a-string/2 |
| // but the stack is limited (and we can get huge arrays !). |
| // |
| // result += String.fromCharCode(array[i]); generate too many strings ! |
| // |
| // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2 |
| var chunk = 65536; |
| var result = [], len = array.length, type = JSZip.utils.getTypeOf(array), k = 0; |
| |
| while (k < len && chunk > 1) { |
| try { |
| if (type === "array" || type === "nodebuffer") { |
| result.push(String.fromCharCode.apply(null, array.slice(k, Math.max(k + chunk, len)))); |
| } else { |
| result.push(String.fromCharCode.apply(null, array.subarray(k, k + chunk))); |
| } |
| k += chunk; |
| } catch (e) { |
| chunk = Math.floor(chunk / 2); |
| } |
| } |
| return result.join(""); |
| }; |
| |
| /** |
| * Copy the data from an array-like to an other array-like. |
| * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array. |
| * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated. |
| * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array. |
| */ |
| function arrayLikeToArrayLike(arrayFrom, arrayTo) { |
| for(var i = 0; i < arrayFrom.length; i++) { |
| arrayTo[i] = arrayFrom[i]; |
| } |
| return arrayTo; |
| }; |
| |
| // a matrix containing functions to transform everything into everything. |
| var transform = {}; |
| |
| // string to ? |
| transform["string"] = { |
| "string" : identity, |
| "array" : function (input) { |
| return stringToArrayLike(input, new Array(input.length)); |
| }, |
| "arraybuffer" : function (input) { |
| return transform["string"]["uint8array"](input).buffer; |
| }, |
| "uint8array" : function (input) { |
| return stringToArrayLike(input, new Uint8Array(input.length)); |
| }, |
| "nodebuffer" : function (input) { |
| return stringToArrayLike(input, new Buffer(input.length)); |
| } |
| }; |
| |
| // array to ? |
| transform["array"] = { |
| "string" : arrayLikeToString, |
| "array" : identity, |
| "arraybuffer" : function (input) { |
| return (new Uint8Array(input)).buffer; |
| }, |
| "uint8array" : function (input) { |
| return new Uint8Array(input); |
| }, |
| "nodebuffer" : function (input) { |
| return new Buffer(input); |
| } |
| }; |
| |
| // arraybuffer to ? |
| transform["arraybuffer"] = { |
| "string" : function (input) { |
| return arrayLikeToString(new Uint8Array(input)); |
| }, |
| "array" : function (input) { |
| return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength)); |
| }, |
| "arraybuffer" : identity, |
| "uint8array" : function (input) { |
| return new Uint8Array(input); |
| }, |
| "nodebuffer" : function (input) { |
| return new Buffer(new Uint8Array(input)); |
| } |
| }; |
| |
| // uint8array to ? |
| transform["uint8array"] = { |
| "string" : arrayLikeToString, |
| "array" : function (input) { |
| return arrayLikeToArrayLike(input, new Array(input.length)); |
| }, |
| "arraybuffer" : function (input) { |
| return input.buffer; |
| }, |
| "uint8array" : identity, |
| "nodebuffer" : function(input) { |
| return new Buffer(input); |
| } |
| }; |
| |
| // nodebuffer to ? |
| transform["nodebuffer"] = { |
| "string" : arrayLikeToString, |
| "array" : function (input) { |
| return arrayLikeToArrayLike(input, new Array(input.length)); |
| }, |
| "arraybuffer" : function (input) { |
| return transform["nodebuffer"]["uint8array"](input).buffer; |
| }, |
| "uint8array" : function (input) { |
| return arrayLikeToArrayLike(input, new Uint8Array(input.length)); |
| }, |
| "nodebuffer" : identity |
| }; |
| |
| /** |
| * Transform an input into any type. |
| * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer. |
| * If no output type is specified, the unmodified input will be returned. |
| * @param {String} outputType the output type. |
| * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert. |
| * @throws {Error} an Error if the browser doesn't support the requested output type. |
| */ |
| JSZip.utils.transformTo = function (outputType, input) { |
| if (!input) { |
| // undefined, null, etc |
| // an empty string won't harm. |
| input = ""; |
| } |
| if (!outputType) { |
| return input; |
| } |
| JSZip.utils.checkSupport(outputType); |
| var inputType = JSZip.utils.getTypeOf(input); |
| var result = transform[inputType][outputType](input); |
| return result; |
| }; |
| |
| /** |
| * Return the type of the input. |
| * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer. |
| * @param {Object} input the input to identify. |
| * @return {String} the (lowercase) type of the input. |
| */ |
| JSZip.utils.getTypeOf = function (input) { |
| if (typeof input === "string") { |
| return "string"; |
| } |
| if (input instanceof 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"; |
| } |
| }; |
| |
| /** |
| * Throw an exception if the type is not supported. |
| * @param {String} type the type to check. |
| * @throws {Error} an Error if the browser doesn't support the requested type. |
| */ |
| JSZip.utils.checkSupport = function (type) { |
| var supported = true; |
| switch (type.toLowerCase()) { |
| case "uint8array": |
| supported = JSZip.support.uint8array; |
| break; |
| case "arraybuffer": |
| supported = JSZip.support.arraybuffer; |
| break; |
| case "nodebuffer": |
| supported = JSZip.support.nodebuffer; |
| break; |
| case "blob": |
| supported = JSZip.support.blob; |
| break; |
| } |
| if (!supported) { |
| throw new Error(type + " is not supported by this browser"); |
| } |
| }; |
| |
| |
| })(); |
| |
| (function (){ |
| /** |
| * Represents an entry in the zip. |
| * The content may or may not be compressed. |
| * @constructor |
| */ |
| JSZip.CompressedObject = function () { |
| this.compressedSize = 0; |
| this.uncompressedSize = 0; |
| this.crc32 = 0; |
| this.compressionMethod = null; |
| this.compressedContent = null; |
| }; |
| |
| JSZip.CompressedObject.prototype = { |
| /** |
| * Return the decompressed content in an unspecified format. |
| * The format will depend on the decompressor. |
| * @return {Object} the decompressed content. |
| */ |
| getContent : function () { |
| return null; // see implementation |
| }, |
| /** |
| * Return the compressed content in an unspecified format. |
| * The format will depend on the compressed conten source. |
| * @return {Object} the compressed content. |
| */ |
| getCompressedContent : function () { |
| return null; // see implementation |
| } |
| }; |
| })(); |
| |
| /** |
| * |
| * Base64 encode / decode |
| * http://www.webtoolkit.info/ |
| * |
| * Hacked so that it doesn't utf8 en/decode everything |
| **/ |
| JSZip.base64 = (function() { |
| // private property |
| var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; |
| |
| return { |
| // public method for encoding |
| encode : function(input, utf8) { |
| var output = ""; |
| var chr1, chr2, chr3, enc1, enc2, enc3, enc4; |
| var i = 0; |
| |
| while (i < input.length) { |
| |
| chr1 = input.charCodeAt(i++); |
| chr2 = input.charCodeAt(i++); |
| chr3 = input.charCodeAt(i++); |
| |
| enc1 = chr1 >> 2; |
| enc2 = ((chr1 & 3) << 4) | (chr2 >> 4); |
| enc3 = ((chr2 & 15) << 2) | (chr3 >> 6); |
| enc4 = chr3 & 63; |
| |
| if (isNaN(chr2)) { |
| enc3 = enc4 = 64; |
| } else if (isNaN(chr3)) { |
| enc4 = 64; |
| } |
| |
| output = output + |
| _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + |
| _keyStr.charAt(enc3) + _keyStr.charAt(enc4); |
| |
| } |
| |
| return output; |
| }, |
| |
| // public method for decoding |
| decode : function(input, utf8) { |
| var output = ""; |
| var chr1, chr2, chr3; |
| var enc1, enc2, enc3, enc4; |
| var i = 0; |
| |
| input = input.replace(/[^A-Za-z0-9\+\/\=]/g, ""); |
| |
| while (i < input.length) { |
| |
| enc1 = _keyStr.indexOf(input.charAt(i++)); |
| enc2 = _keyStr.indexOf(input.charAt(i++)); |
| enc3 = _keyStr.indexOf(input.charAt(i++)); |
| enc4 = _keyStr.indexOf(input.charAt(i++)); |
| |
| chr1 = (enc1 << 2) | (enc2 >> 4); |
| chr2 = ((enc2 & 15) << 4) | (enc3 >> 2); |
| chr3 = ((enc3 & 3) << 6) | enc4; |
| |
| output = output + String.fromCharCode(chr1); |
| |
| if (enc3 != 64) { |
| output = output + String.fromCharCode(chr2); |
| } |
| if (enc4 != 64) { |
| output = output + String.fromCharCode(chr3); |
| } |
| |
| } |
| |
| return output; |
| |
| } |
| }; |
| }()); |
| |
| // enforcing Stuk's coding style |
| // vim: set shiftwidth=3 softtabstop=3: |