summaryrefslogtreecommitdiffstats
path: root/afb-client/bower_components/jszip/lib/object.js
diff options
context:
space:
mode:
Diffstat (limited to 'afb-client/bower_components/jszip/lib/object.js')
-rw-r--r--afb-client/bower_components/jszip/lib/object.js883
1 files changed, 883 insertions, 0 deletions
diff --git a/afb-client/bower_components/jszip/lib/object.js b/afb-client/bower_components/jszip/lib/object.js
new file mode 100644
index 0000000..3b5e5b8
--- /dev/null
+++ b/afb-client/bower_components/jszip/lib/object.js
@@ -0,0 +1,883 @@
+'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;