884 lines
29 KiB
JavaScript
884 lines
29 KiB
JavaScript
|
'use strict';
|
||
|
|
var support = require('./support');
|
||
|
|
var utils = require('./utils');
|
||
|
|
var crc32 = require('./crc32');
|
||
|
|
var signature = require('./signature');
|
||
|
|
var defaults = require('./defaults');
|
||
|
|
var base64 = require('./base64');
|
||
|
|
var compressions = require('./compressions');
|
||
|
|
var CompressedObject = require('./compressedObject');
|
||
|
|
var nodeBuffer = require('./nodeBuffer');
|
||
|
|
var utf8 = require('./utf8');
|
||
|
|
var StringWriter = require('./stringWriter');
|
||
|
|
var Uint8ArrayWriter = require('./uint8ArrayWriter');
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 CompressedObject) {
|
||
|
|
file._data = file._data.getContent();
|
||
|
|
file.options.binary = true;
|
||
|
|
file.options.base64 = false;
|
||
|
|
|
||
|
|
if (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 = 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 (support.nodebuffer) {
|
||
|
|
return nodeBuffer(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 = 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 = out.utf8decode(result);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// no utf8 transformation, do the array => string step.
|
||
|
|
result = utils.transformTo("string", result);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!asUTF8 && !this.options.binary) {
|
||
|
|
result = utils.transformTo("string", out.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.dir = options.dir;
|
||
|
|
this.date = options.date;
|
||
|
|
this.comment = options.comment;
|
||
|
|
this.unixPermissions = options.unixPermissions;
|
||
|
|
this.dosPermissions = options.dosPermissions;
|
||
|
|
|
||
|
|
this._data = data;
|
||
|
|
this.options = options;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This object contains initial values for dir and date.
|
||
|
|
* With them, we can check if the user changed the deprecated metadata in
|
||
|
|
* `ZipObject#options` or not.
|
||
|
|
*/
|
||
|
|
this._initialMetadata = {
|
||
|
|
dir : options.dir,
|
||
|
|
date : options.date
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
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 utils.transformTo("nodebuffer", result);
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Returns the content as an Uint8Array.
|
||
|
|
* @return {Uint8Array} the content as an Uint8Array.
|
||
|
|
*/
|
||
|
|
asUint8Array: function() {
|
||
|
|
var result = getBinaryData(this);
|
||
|
|
return 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 === undefined)) {
|
||
|
|
o.binary = true;
|
||
|
|
}
|
||
|
|
o = extend(o, 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 dataType = utils.getTypeOf(data),
|
||
|
|
parent;
|
||
|
|
|
||
|
|
o = prepareFileAttrs(o);
|
||
|
|
|
||
|
|
if (typeof o.unixPermissions === "string") {
|
||
|
|
o.unixPermissions = parseInt(o.unixPermissions, 8);
|
||
|
|
}
|
||
|
|
|
||
|
|
// UNX_IFDIR 0040000 see zipinfo.c
|
||
|
|
if (o.unixPermissions && (o.unixPermissions & 0x4000)) {
|
||
|
|
o.dir = true;
|
||
|
|
}
|
||
|
|
// Bit 4 Directory
|
||
|
|
if (o.dosPermissions && (o.dosPermissions & 0x0010)) {
|
||
|
|
o.dir = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (o.dir) {
|
||
|
|
name = forceTrailingSlash(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (o.createFolders && (parent = parentFolder(name))) {
|
||
|
|
folderAdd.call(this, parent, true);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (o.dir || data === null || typeof data === "undefined") {
|
||
|
|
o.base64 = false;
|
||
|
|
o.binary = false;
|
||
|
|
data = null;
|
||
|
|
dataType = 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 = utils.string2binary(data);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else { // arraybuffer, uint8array, ...
|
||
|
|
o.base64 = false;
|
||
|
|
o.binary = true;
|
||
|
|
|
||
|
|
if (!dataType && !(data instanceof 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 = utils.transformTo("uint8array", data);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var object = new ZipObject(name, data, o);
|
||
|
|
this.files[name] = object;
|
||
|
|
return object;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find the parent folder of the path.
|
||
|
|
* @private
|
||
|
|
* @param {string} path the path to use
|
||
|
|
* @return {string} the parent folder, or ""
|
||
|
|
*/
|
||
|
|
var parentFolder = function (path) {
|
||
|
|
if (path.slice(-1) == '/') {
|
||
|
|
path = path.substring(0, path.length - 1);
|
||
|
|
}
|
||
|
|
var lastSlash = path.lastIndexOf('/');
|
||
|
|
return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the path with a slash at the end.
|
||
|
|
* @private
|
||
|
|
* @param {String} path the path to check.
|
||
|
|
* @return {String} the path with a trailing slash.
|
||
|
|
*/
|
||
|
|
var forceTrailingSlash = function(path) {
|
||
|
|
// Check the name ends with a /
|
||
|
|
if (path.slice(-1) != "/") {
|
||
|
|
path += "/"; // IE doesn't like substr(-1)
|
||
|
|
}
|
||
|
|
return path;
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* Add a (sub) folder in the current folder.
|
||
|
|
* @private
|
||
|
|
* @param {string} name the folder's name
|
||
|
|
* @param {boolean=} [createFolders] If true, automatically create sub
|
||
|
|
* folders. Defaults to false.
|
||
|
|
* @return {Object} the new folder.
|
||
|
|
*/
|
||
|
|
var folderAdd = function(name, createFolders) {
|
||
|
|
createFolders = (typeof createFolders !== 'undefined') ? createFolders : false;
|
||
|
|
|
||
|
|
name = forceTrailingSlash(name);
|
||
|
|
|
||
|
|
// Does this folder already exist?
|
||
|
|
if (!this.files[name]) {
|
||
|
|
fileAdd.call(this, name, null, {
|
||
|
|
dir: true,
|
||
|
|
createFolders: createFolders
|
||
|
|
});
|
||
|
|
}
|
||
|
|
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.
|
||
|
|
* @param {Object} compressionOptions the options to use when compressing.
|
||
|
|
* @return {JSZip.CompressedObject} the compressed result.
|
||
|
|
*/
|
||
|
|
var generateCompressedObjectFrom = function(file, compression, compressionOptions) {
|
||
|
|
var result = new CompressedObject(),
|
||
|
|
content;
|
||
|
|
|
||
|
|
// the data has not been decompressed, we might reuse things !
|
||
|
|
if (file._data instanceof CompressedObject) {
|
||
|
|
result.uncompressedSize = file._data.uncompressedSize;
|
||
|
|
result.crc32 = file._data.crc32;
|
||
|
|
|
||
|
|
if (result.uncompressedSize === 0 || file.dir) {
|
||
|
|
compression = 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(utils.transformTo(compression.compressInputType, content), compressionOptions);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// have uncompressed data
|
||
|
|
content = getBinaryData(file);
|
||
|
|
if (!content || content.length === 0 || file.dir) {
|
||
|
|
compression = compressions['STORE'];
|
||
|
|
content = "";
|
||
|
|
}
|
||
|
|
result.uncompressedSize = content.length;
|
||
|
|
result.crc32 = crc32(content);
|
||
|
|
result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content), compressionOptions);
|
||
|
|
}
|
||
|
|
|
||
|
|
result.compressedSize = result.compressedContent.length;
|
||
|
|
result.compressionMethod = compression.magic;
|
||
|
|
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Generate the UNIX part of the external file attributes.
|
||
|
|
* @param {Object} unixPermissions the unix permissions or null.
|
||
|
|
* @param {Boolean} isDir true if the entry is a directory, false otherwise.
|
||
|
|
* @return {Number} a 32 bit integer.
|
||
|
|
*
|
||
|
|
* adapted from http://unix.stackexchange.com/questions/14705/the-zip-formats-external-file-attribute :
|
||
|
|
*
|
||
|
|
* TTTTsstrwxrwxrwx0000000000ADVSHR
|
||
|
|
* ^^^^____________________________ file type, see zipinfo.c (UNX_*)
|
||
|
|
* ^^^_________________________ setuid, setgid, sticky
|
||
|
|
* ^^^^^^^^^________________ permissions
|
||
|
|
* ^^^^^^^^^^______ not used ?
|
||
|
|
* ^^^^^^ DOS attribute bits : Archive, Directory, Volume label, System file, Hidden, Read only
|
||
|
|
*/
|
||
|
|
var generateUnixExternalFileAttr = function (unixPermissions, isDir) {
|
||
|
|
|
||
|
|
var result = unixPermissions;
|
||
|
|
if (!unixPermissions) {
|
||
|
|
// I can't use octal values in strict mode, hence the hexa.
|
||
|
|
// 040775 => 0x41fd
|
||
|
|
// 0100664 => 0x81b4
|
||
|
|
result = isDir ? 0x41fd : 0x81b4;
|
||
|
|
}
|
||
|
|
|
||
|
|
return (result & 0xFFFF) << 16;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Generate the DOS part of the external file attributes.
|
||
|
|
* @param {Object} dosPermissions the dos permissions or null.
|
||
|
|
* @param {Boolean} isDir true if the entry is a directory, false otherwise.
|
||
|
|
* @return {Number} a 32 bit integer.
|
||
|
|
*
|
||
|
|
* Bit 0 Read-Only
|
||
|
|
* Bit 1 Hidden
|
||
|
|
* Bit 2 System
|
||
|
|
* Bit 3 Volume Label
|
||
|
|
* Bit 4 Directory
|
||
|
|
* Bit 5 Archive
|
||
|
|
*/
|
||
|
|
var generateDosExternalFileAttr = function (dosPermissions, isDir) {
|
||
|
|
|
||
|
|
// the dir flag is already set for compatibility
|
||
|
|
|
||
|
|
return (dosPermissions || 0) & 0x3F;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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.
|
||
|
|
* @param {String} platform let's pretend we are this platform (change platform dependents fields)
|
||
|
|
* @return {object} the zip parts.
|
||
|
|
*/
|
||
|
|
var generateZipParts = function(name, file, compressedObject, offset, platform) {
|
||
|
|
var data = compressedObject.compressedContent,
|
||
|
|
utfEncodedFileName = utils.transformTo("string", utf8.utf8encode(file.name)),
|
||
|
|
comment = file.comment || "",
|
||
|
|
utfEncodedComment = utils.transformTo("string", utf8.utf8encode(comment)),
|
||
|
|
useUTF8ForFileName = utfEncodedFileName.length !== file.name.length,
|
||
|
|
useUTF8ForComment = utfEncodedComment.length !== comment.length,
|
||
|
|
o = file.options,
|
||
|
|
dosTime,
|
||
|
|
dosDate,
|
||
|
|
extraFields = "",
|
||
|
|
unicodePathExtraField = "",
|
||
|
|
unicodeCommentExtraField = "",
|
||
|
|
dir, date;
|
||
|
|
|
||
|
|
|
||
|
|
// handle the deprecated options.dir
|
||
|
|
if (file._initialMetadata.dir !== file.dir) {
|
||
|
|
dir = file.dir;
|
||
|
|
} else {
|
||
|
|
dir = o.dir;
|
||
|
|
}
|
||
|
|
|
||
|
|
// handle the deprecated options.date
|
||
|
|
if(file._initialMetadata.date !== file.date) {
|
||
|
|
date = file.date;
|
||
|
|
} else {
|
||
|
|
date = o.date;
|
||
|
|
}
|
||
|
|
|
||
|
|
var extFileAttr = 0;
|
||
|
|
var versionMadeBy = 0;
|
||
|
|
if (dir) {
|
||
|
|
// dos or unix, we set the dos dir flag
|
||
|
|
extFileAttr |= 0x00010;
|
||
|
|
}
|
||
|
|
if(platform === "UNIX") {
|
||
|
|
versionMadeBy = 0x031E; // UNIX, version 3.0
|
||
|
|
extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir);
|
||
|
|
} else { // DOS or other, fallback to DOS
|
||
|
|
versionMadeBy = 0x0014; // DOS, version 2.0
|
||
|
|
extFileAttr |= generateDosExternalFileAttr(file.dosPermissions, dir);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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 = date.getHours();
|
||
|
|
dosTime = dosTime << 6;
|
||
|
|
dosTime = dosTime | date.getMinutes();
|
||
|
|
dosTime = dosTime << 5;
|
||
|
|
dosTime = dosTime | date.getSeconds() / 2;
|
||
|
|
|
||
|
|
dosDate = date.getFullYear() - 1980;
|
||
|
|
dosDate = dosDate << 4;
|
||
|
|
dosDate = dosDate | (date.getMonth() + 1);
|
||
|
|
dosDate = dosDate << 5;
|
||
|
|
dosDate = dosDate | date.getDate();
|
||
|
|
|
||
|
|
if (useUTF8ForFileName) {
|
||
|
|
// set the unicode path extra field. unzip needs at least one extra
|
||
|
|
// field to correctly handle unicode path, so using the path is as good
|
||
|
|
// as any other information. This could improve the situation with
|
||
|
|
// other archive managers too.
|
||
|
|
// This field is usually used without the utf8 flag, with a non
|
||
|
|
// unicode path in the header (winrar, winzip). This helps (a bit)
|
||
|
|
// with the messy Windows' default compressed folders feature but
|
||
|
|
// breaks on p7zip which doesn't seek the unicode path extra field.
|
||
|
|
// So for now, UTF-8 everywhere !
|
||
|
|
unicodePathExtraField =
|
||
|
|
// Version
|
||
|
|
decToHex(1, 1) +
|
||
|
|
// NameCRC32
|
||
|
|
decToHex(crc32(utfEncodedFileName), 4) +
|
||
|
|
// UnicodeName
|
||
|
|
utfEncodedFileName;
|
||
|
|
|
||
|
|
extraFields +=
|
||
|
|
// Info-ZIP Unicode Path Extra Field
|
||
|
|
"\x75\x70" +
|
||
|
|
// size
|
||
|
|
decToHex(unicodePathExtraField.length, 2) +
|
||
|
|
// content
|
||
|
|
unicodePathExtraField;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(useUTF8ForComment) {
|
||
|
|
|
||
|
|
unicodeCommentExtraField =
|
||
|
|
// Version
|
||
|
|
decToHex(1, 1) +
|
||
|
|
// CommentCRC32
|
||
|
|
decToHex(this.crc32(utfEncodedComment), 4) +
|
||
|
|
// UnicodeName
|
||
|
|
utfEncodedComment;
|
||
|
|
|
||
|
|
extraFields +=
|
||
|
|
// Info-ZIP Unicode Path Extra Field
|
||
|
|
"\x75\x63" +
|
||
|
|
// size
|
||
|
|
decToHex(unicodeCommentExtraField.length, 2) +
|
||
|
|
// content
|
||
|
|
unicodeCommentExtraField;
|
||
|
|
}
|
||
|
|
|
||
|
|
var header = "";
|
||
|
|
|
||
|
|
// version needed to extract
|
||
|
|
header += "\x0A\x00";
|
||
|
|
// general purpose bit flag
|
||
|
|
// set bit 11 if utf8
|
||
|
|
header += (useUTF8ForFileName || useUTF8ForComment) ? "\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 += decToHex(extraFields.length, 2);
|
||
|
|
|
||
|
|
|
||
|
|
var fileRecord = signature.LOCAL_FILE_HEADER + header + utfEncodedFileName + extraFields;
|
||
|
|
|
||
|
|
var dirRecord = signature.CENTRAL_FILE_HEADER +
|
||
|
|
// version made by (00: DOS)
|
||
|
|
decToHex(versionMadeBy, 2) +
|
||
|
|
// file header (common to file and central directory)
|
||
|
|
header +
|
||
|
|
// file comment length
|
||
|
|
decToHex(utfEncodedComment.length, 2) +
|
||
|
|
// disk number start
|
||
|
|
"\x00\x00" +
|
||
|
|
// internal file attributes TODO
|
||
|
|
"\x00\x00" +
|
||
|
|
// external file attributes
|
||
|
|
decToHex(extFileAttr, 4) +
|
||
|
|
// relative offset of local header
|
||
|
|
decToHex(offset, 4) +
|
||
|
|
// file name
|
||
|
|
utfEncodedFileName +
|
||
|
|
// extra field
|
||
|
|
extraFields +
|
||
|
|
// file comment
|
||
|
|
utfEncodedComment;
|
||
|
|
|
||
|
|
return {
|
||
|
|
fileRecord: fileRecord,
|
||
|
|
dirRecord: dirRecord,
|
||
|
|
compressedObject: compressedObject
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// return the actual prototype of JSZip
|
||
|
|
var out = {
|
||
|
|
/**
|
||
|
|
* 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 (utils.isRegExp(name)) {
|
||
|
|
var regexp = name;
|
||
|
|
return this.filter(function(relativePath, file) {
|
||
|
|
return !file.dir && regexp.test(relativePath);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
else { // text
|
||
|
|
return this.filter(function(relativePath, file) {
|
||
|
|
return !file.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 (utils.isRegExp(arg)) {
|
||
|
|
return this.filter(function(relativePath, file) {
|
||
|
|
return file.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 && !file.dir) {
|
||
|
|
// file
|
||
|
|
delete this.files[name];
|
||
|
|
} else {
|
||
|
|
// maybe a folder, delete recursively
|
||
|
|
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",
|
||
|
|
compressionOptions : null,
|
||
|
|
type: "base64",
|
||
|
|
platform: "DOS",
|
||
|
|
comment: null,
|
||
|
|
mimeType: 'application/zip'
|
||
|
|
});
|
||
|
|
|
||
|
|
utils.checkSupport(options.type);
|
||
|
|
|
||
|
|
// accept nodejs `process.platform`
|
||
|
|
if(
|
||
|
|
options.platform === 'darwin' ||
|
||
|
|
options.platform === 'freebsd' ||
|
||
|
|
options.platform === 'linux' ||
|
||
|
|
options.platform === 'sunos'
|
||
|
|
) {
|
||
|
|
options.platform = "UNIX";
|
||
|
|
}
|
||
|
|
if (options.platform === 'win32') {
|
||
|
|
options.platform = "DOS";
|
||
|
|
}
|
||
|
|
|
||
|
|
var zipData = [],
|
||
|
|
localDirLength = 0,
|
||
|
|
centralDirLength = 0,
|
||
|
|
writer, i,
|
||
|
|
utfEncodedComment = utils.transformTo("string", this.utf8encode(options.comment || this.comment || ""));
|
||
|
|
|
||
|
|
// first, generate all the zip parts.
|
||
|
|
for (var name in this.files) {
|
||
|
|
if (!this.files.hasOwnProperty(name)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
var file = this.files[name];
|
||
|
|
|
||
|
|
var compressionName = file.options.compression || options.compression.toUpperCase();
|
||
|
|
var compression = compressions[compressionName];
|
||
|
|
if (!compression) {
|
||
|
|
throw new Error(compressionName + " is not a valid compression method !");
|
||
|
|
}
|
||
|
|
var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
|
||
|
|
|
||
|
|
var compressedObject = generateCompressedObjectFrom.call(this, file, compression, compressionOptions);
|
||
|
|
|
||
|
|
var zipPart = generateZipParts.call(this, name, file, compressedObject, localDirLength, options.platform);
|
||
|
|
localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize;
|
||
|
|
centralDirLength += zipPart.dirRecord.length;
|
||
|
|
zipData.push(zipPart);
|
||
|
|
}
|
||
|
|
|
||
|
|
var dirEnd = "";
|
||
|
|
|
||
|
|
// end of central dir signature
|
||
|
|
dirEnd = 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
|
||
|
|
decToHex(utfEncodedComment.length, 2) +
|
||
|
|
// .ZIP file comment
|
||
|
|
utfEncodedComment;
|
||
|
|
|
||
|
|
|
||
|
|
// we have all the parts (and the total length)
|
||
|
|
// time to create a writer !
|
||
|
|
var typeName = options.type.toLowerCase();
|
||
|
|
if(typeName==="uint8array"||typeName==="arraybuffer"||typeName==="blob"||typeName==="nodebuffer") {
|
||
|
|
writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length);
|
||
|
|
}else{
|
||
|
|
writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length);
|
||
|
|
}
|
||
|
|
|
||
|
|
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 utils.transformTo(options.type.toLowerCase(), zip);
|
||
|
|
case "blob" :
|
||
|
|
return utils.arrayBuffer2Blob(utils.transformTo("arraybuffer", zip), options.mimeType);
|
||
|
|
// case "zip is a string"
|
||
|
|
case "base64" :
|
||
|
|
return (options.base64) ? base64.encode(zip) : zip;
|
||
|
|
default : // case "string" :
|
||
|
|
return zip;
|
||
|
|
}
|
||
|
|
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @deprecated
|
||
|
|
* This method will be removed in a future version without replacement.
|
||
|
|
*/
|
||
|
|
crc32: function (input, crc) {
|
||
|
|
return crc32(input, crc);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @deprecated
|
||
|
|
* This method will be removed in a future version without replacement.
|
||
|
|
*/
|
||
|
|
utf8encode: function (string) {
|
||
|
|
return utils.transformTo("string", utf8.utf8encode(string));
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @deprecated
|
||
|
|
* This method will be removed in a future version without replacement.
|
||
|
|
*/
|
||
|
|
utf8decode: function (input) {
|
||
|
|
return utf8.utf8decode(input);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = out;
|