cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From za...@apache.org
Subject [01/20] cordova-firefoxos git commit: CB-7567 Don't use adm-zip because it creates invalid zip files
Date Fri, 20 Feb 2015 19:37:55 GMT
Repository: cordova-firefoxos
Updated Branches:
  refs/heads/master bacbd0910 -> bd21ce3b0


http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-entry.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-entry.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-entry.js
new file mode 100644
index 0000000..3c6f8b8
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-entry.js
@@ -0,0 +1,16 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+var ArchiveEntry = module.exports = function() {};
+
+ArchiveEntry.prototype.getName = function() {};
+
+ArchiveEntry.prototype.getSize = function() {};
+
+ArchiveEntry.prototype.getLastModifiedDate = function() {};
+
+ArchiveEntry.prototype.isDirectory = function() {};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-output-stream.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-output-stream.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-output-stream.js
new file mode 100644
index 0000000..b2325bc
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/archive-output-stream.js
@@ -0,0 +1,118 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+var inherits = require('util').inherits;
+var Transform = require('readable-stream').Transform;
+
+var ArchiveEntry = require('./archive-entry');
+var util = require('../util');
+
+var ArchiveOutputStream = module.exports = function(options) {
+  if (!(this instanceof ArchiveOutputStream)) {
+    return new ArchiveOutputStream(options);
+  }
+
+  Transform.call(this, options);
+
+  this.offset = 0;
+  this._archive = {
+    finish: false,
+    finished: false,
+    processing: false
+  };
+};
+
+inherits(ArchiveOutputStream, Transform);
+
+ArchiveOutputStream.prototype._appendBuffer = function(zae, source, callback) {
+  // scaffold only
+};
+
+ArchiveOutputStream.prototype._appendStream = function(zae, source, callback) {
+  // scaffold only
+};
+
+ArchiveOutputStream.prototype._emitErrorCallback = function(err) {
+  if (err) {
+    this.emit('error', err);
+  }
+};
+
+ArchiveOutputStream.prototype._finish = function(ae) {
+  // scaffold only
+};
+
+ArchiveOutputStream.prototype._normalizeEntry = function(ae) {
+  // scaffold only
+};
+
+ArchiveOutputStream.prototype._transform = function(chunk, encoding, callback) {
+  callback(null, chunk);
+};
+
+ArchiveOutputStream.prototype.entry = function(ae, source, callback) {
+  source = source || null;
+
+  if (typeof callback !== 'function') {
+    callback = this._emitErrorCallback.bind(this);
+  }
+
+  if (!(ae instanceof ArchiveEntry)) {
+    callback(new Error('not a valid instance of ArchiveEntry'));
+    return;
+  }
+
+  if (this._archive.finish || this._archive.finished) {
+    callback(new Error('unacceptable entry after finish'));
+    return;
+  }
+
+  if (this._archive.processing) {
+    callback(new Error('already processing an entry'));
+    return;
+  }
+
+  this._archive.processing = true;
+  this._normalizeEntry(ae);
+  this._entry = ae;
+
+  source = util.normalizeInputSource(source);
+
+  if (Buffer.isBuffer(source)) {
+    this._appendBuffer(ae, source, callback);
+  } else if (util.isStream(source)) {
+    source.on('error', callback);
+    this._appendStream(ae, source, callback);
+  } else {
+    this._archive.processing = false;
+    callback(new Error('input source must be valid Stream or Buffer instance'));
+    return;
+  }
+
+  return this;
+};
+
+ArchiveOutputStream.prototype.finish = function() {
+  if (this._archive.processing) {
+    this._archive.finish = true;
+    return;
+  }
+
+  this._finish();
+};
+
+ArchiveOutputStream.prototype.getBytesWritten = function() {
+  return this.offset;
+};
+
+ArchiveOutputStream.prototype.write = function(chunk, cb) {
+  if (chunk) {
+    this.offset += chunk.length;
+  }
+
+  return Transform.prototype.write.call(this, chunk, cb);
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/constants.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/constants.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/constants.js
new file mode 100644
index 0000000..2514645
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/constants.js
@@ -0,0 +1,71 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+module.exports = {
+  WORD: 4,
+  DWORD: 8,
+  EMPTY: new Buffer(0),
+
+  SHORT: 2,
+  SHORT_MASK: 0xffff,
+  SHORT_SHIFT: 16,
+  SHORT_ZERO: new Buffer(Array(2)),
+  LONG: 4,
+  LONG_ZERO: new Buffer(Array(4)),
+
+  MIN_VERSION_INITIAL: 10,
+  MIN_VERSION_DATA_DESCRIPTOR: 20,
+  MIN_VERSION_ZIP64: 45,
+  VERSION_MADEBY: 45,
+
+  METHOD_STORED: 0,
+  METHOD_DEFLATED: 8,
+
+  PLATFORM_UNIX: 3,
+  PLATFORM_FAT: 0,
+
+  SIG_LFH: 0x04034b50,
+  SIG_DD: 0x08074b50,
+  SIG_CFH: 0x02014b50,
+  SIG_EOCD: 0x06054b50,
+  SIG_ZIP64_EOCD: 0x06064B50,
+  SIG_ZIP64_EOCD_LOC: 0x07064B50,
+
+  ZIP64_MAGIC_SHORT: 0xffff,
+  ZIP64_MAGIC: 0xffffffff,
+  ZIP64_EXTRA_ID: 0x0001,
+
+  ZLIB_NO_COMPRESSION: 0,
+  ZLIB_BEST_SPEED: 1,
+  ZLIB_BEST_COMPRESSION: 9,
+  ZLIB_DEFAULT_COMPRESSION: -1,
+
+  MODE_MASK: 0xFFF,
+  DEFAULT_FILE_MODE: 0100644, // 644 -rw-r--r-- = S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
+  DEFAULT_DIR_MODE: 040755, // 755 drwxr-xr-x = S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH
+
+  EXT_FILE_ATTR_DIR: 010173200020, // 755 drwxr-xr-x = (((S_IFDIR | 0755) << 16) | S_DOS_D)
+  EXT_FILE_ATTR_FILE: 020151000040, // 644 -rw-r--r-- = (((S_IFREG | 0644) << 16) | S_DOS_A) >>> 0
+
+  // Unix file types
+  S_IFMT: 0170000, // type of file mask  
+  S_IFIFO: 010000, // named pipe (fifo)
+  S_IFCHR: 020000, // character special
+  S_IFDIR: 040000, // directory
+  S_IFBLK: 060000, // block special
+  S_IFREG: 0100000, // regular
+  S_IFLNK: 0120000, // symbolic link
+  S_IFSOCK: 0140000, // socket
+
+  // DOS file type flags
+  S_DOS_A: 040, // Archive
+  S_DOS_D: 020, // Directory
+  S_DOS_V: 010, // Volume
+  S_DOS_S: 04, // System
+  S_DOS_H: 02, // Hidden
+  S_DOS_R: 01 // Read Only
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js
new file mode 100644
index 0000000..dc21073
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js
@@ -0,0 +1,101 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+var zipUtil = require('./util');
+
+var DATA_DESCRIPTOR_FLAG = 1 << 3;
+var ENCRYPTION_FLAG = 1 << 0;
+var NUMBER_OF_SHANNON_FANO_TREES_FLAG = 1 << 2;
+var SLIDING_DICTIONARY_SIZE_FLAG = 1 << 1;
+var STRONG_ENCRYPTION_FLAG = 1 << 6;
+var UFT8_NAMES_FLAG = 1 << 11;
+
+var GeneralPurposeBit = module.exports = function() {
+  if (!(this instanceof GeneralPurposeBit)) {
+    return new GeneralPurposeBit();
+  }
+
+  this.descriptor = false;
+  this.encryption = false;
+  this.utf8 = false;
+  this.numberOfShannonFanoTrees = 0;
+  this.strongEncryption = false;
+  this.slidingDictionarySize = 0;
+
+  return this;
+};
+
+GeneralPurposeBit.prototype.encode = function() {
+  return zipUtil.getShortBytes(
+    (this.descriptor ? DATA_DESCRIPTOR_FLAG : 0) |
+    (this.utf8 ? UFT8_NAMES_FLAG : 0) |
+    (this.encryption ? ENCRYPTION_FLAG : 0) |
+    (this.strongEncryption ? STRONG_ENCRYPTION_FLAG : 0)
+  );
+};
+
+GeneralPurposeBit.prototype.parse = function(buf, offset) {
+  var flag = zipUtil.getShortBytesValue(buf, offset);
+  var gbp = new GeneralPurposeBit();
+
+  gbp.useDataDescriptor((flag & DATA_DESCRIPTOR_FLAG) !== 0);
+  gbp.useUTF8ForNames((flag & UFT8_NAMES_FLAG) !== 0);
+  gbp.useStrongEncryption((flag & STRONG_ENCRYPTION_FLAG) !== 0);
+  gbp.useEncryption((flag & ENCRYPTION_FLAG) !== 0);
+  gbp.setSlidingDictionarySize((flag & SLIDING_DICTIONARY_SIZE_FLAG) !== 0 ? 8192 : 4096);
+  gbp.setNumberOfShannonFanoTrees((flag & NUMBER_OF_SHANNON_FANO_TREES_FLAG) !== 0 ? 3 : 2);
+
+  return gbp;
+};
+
+GeneralPurposeBit.prototype.setNumberOfShannonFanoTrees = function(n) {
+  this.numberOfShannonFanoTrees = n;
+};
+
+GeneralPurposeBit.prototype.getNumberOfShannonFanoTrees = function() {
+  return this.numberOfShannonFanoTrees;
+};
+
+GeneralPurposeBit.prototype.setSlidingDictionarySize = function(n) {
+  this.slidingDictionarySize = n;
+};
+
+GeneralPurposeBit.prototype.getSlidingDictionarySize = function() {
+  return this.slidingDictionarySize;
+};
+
+GeneralPurposeBit.prototype.useDataDescriptor = function(b) {
+  this.descriptor = b;
+};
+
+GeneralPurposeBit.prototype.usesDataDescriptor = function() {
+  return this.descriptor;
+};
+
+GeneralPurposeBit.prototype.useEncryption = function(b) {
+  this.encryption = b;
+};
+
+GeneralPurposeBit.prototype.usesEncryption = function() {
+  return this.encryption;
+};
+
+GeneralPurposeBit.prototype.useStrongEncryption = function(b) {
+  this.strongEncryption = b;
+};
+
+GeneralPurposeBit.prototype.usesStrongEncryption = function() {
+  return this.strongEncryption;
+};
+
+GeneralPurposeBit.prototype.useUTF8ForNames = function(b) {
+  this.utf8 = b;
+};
+
+GeneralPurposeBit.prototype.usesUTF8ForNames = function() {
+  return this.utf8;
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/util.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/util.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/util.js
new file mode 100644
index 0000000..36c69a9
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/util.js
@@ -0,0 +1,84 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+var Int64 = require('node-int64');
+var util = module.exports = {};
+
+util.dateToDos = function(d) {
+  var year = d.getFullYear();
+
+  if (year < 1980) {
+    return 2162688; // 1980-1-1 00:00:00
+  } else if (year >= 2044) {
+    return 2141175677; // 2043-12-31 23:59:58
+  }
+
+  var val = {
+    year: year,
+    month: d.getMonth(),
+    date: d.getDate(),
+    hours: d.getHours(),
+    minutes: d.getMinutes(),
+    seconds: d.getSeconds()
+  };
+
+  return ((val.year - 1980) << 25) | ((val.month + 1) << 21) | (val.date << 16) |
+    (val.hours << 11) | (val.minutes << 5) | (val.seconds / 2);
+};
+
+util.dosToDate = function(dos) {
+  return new Date(
+    ((dos >> 25) & 0x7f) + 1980,
+    ((dos >> 21) & 0x0f) - 1,
+    (dos >> 16) & 0x1f,
+    (dos >> 11) & 0x1f,
+    (dos >> 5) & 0x3f,
+    (dos & 0x1f) << 1
+  );
+};
+
+util.fromDosTime = function(buf) {
+  return util.dosToDate(buf.readUInt32LE());
+};
+
+util.getEightBytes = function(v) {
+  var buf = new Buffer(8);
+  var i64 = new Int64(v);
+
+  // BE to LE
+  for(i = 0; i < 8; i++) {
+    buf[i] = i64.buffer[7 - i];
+  }
+
+  return buf;
+};
+
+util.getShortBytes = function(v) {
+  var buf = new Buffer(2);
+  buf.writeUInt16LE(v, 0);
+
+  return buf;
+};
+
+util.getShortBytesValue = function(buf, offset) {
+  return buf.readUInt16LE(offset);
+};
+
+util.getLongBytes = function(v) {
+  var buf = new Buffer(4);
+  buf.writeUInt32LE(v, 0);
+
+  return buf;
+};
+
+util.getLongBytesValue = function(buf, offset) {
+  return buf.readUInt32LE(offset);
+};
+
+util.toDosTime = function(d) {
+  return util.getLongBytes(util.dateToDos(d));
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js
new file mode 100644
index 0000000..9eecf00
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js
@@ -0,0 +1,223 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+var inherits = require('util').inherits;
+
+var ArchiveEntry = require('../archive-entry');
+var GeneralPurposeBit = require('./general-purpose-bit');
+
+var constants = require('./constants');
+var zipUtil = require('./util');
+
+var ZipArchiveEntry = module.exports = function(name) {
+  if (!(this instanceof ZipArchiveEntry)) {
+    return new ZipArchiveEntry(name);
+  }
+
+  ArchiveEntry.call(this);
+
+  this.platform = constants.PLATFORM_FAT;
+  this.method = -1;
+
+  this.name = null;
+  this.size = -1;
+  this.csize = -1;
+  this.gpb = new GeneralPurposeBit();
+  this.crc = 0;
+  this.time = -1;
+
+  this.minver = constants.MIN_VERSION_INITIAL;
+  this.mode = -1;
+  this.extra = null;
+  this.exattr = 0;
+  this.inattr = 0;
+  this.comment = null;
+
+  if (name) {
+    this.setName(name);
+  }
+};
+
+inherits(ZipArchiveEntry, ArchiveEntry);
+
+ZipArchiveEntry.prototype.getCentralDirectoryExtra = function() {
+  return this.getExtra();
+};
+
+ZipArchiveEntry.prototype.getComment = function() {
+  return this.comment !== null ? this.comment : '';
+};
+
+ZipArchiveEntry.prototype.getCompressedSize = function() {
+  return this.csize;
+};
+
+ZipArchiveEntry.prototype.getCrc = function() {
+  return this.crc;
+};
+
+ZipArchiveEntry.prototype.getExternalAttributes = function() {
+  return this.exattr;
+};
+
+ZipArchiveEntry.prototype.getExtra = function() {
+  return this.extra !== null ? this.extra : constants.EMPTY;
+};
+
+ZipArchiveEntry.prototype.getGeneralPurposeBit = function() {
+  return this.gpb;
+};
+
+ZipArchiveEntry.prototype.getInternalAttributes = function() {
+  return this.inattr;
+};
+
+ZipArchiveEntry.prototype.getLastModifiedDate = function() {
+  return this.getTime();
+};
+
+ZipArchiveEntry.prototype.getLocalFileDataExtra = function() {
+  return this.getExtra();
+};
+
+ZipArchiveEntry.prototype.getMethod = function() {
+  return this.method;
+};
+
+ZipArchiveEntry.prototype.getName = function() {
+  return this.name;
+};
+
+ZipArchiveEntry.prototype.getPlatform = function() {
+  return this.platform;
+};
+
+ZipArchiveEntry.prototype.getSize = function() {
+  return this.size;
+};
+
+ZipArchiveEntry.prototype.getTime = function() {
+  return this.time !== -1 ? zipUtil.dosToDate(this.time) : -1;
+};
+
+ZipArchiveEntry.prototype.getTimeDos = function() {
+  return this.time !== -1 ? this.time : 0;
+};
+
+ZipArchiveEntry.prototype.getUnixMode = function() {
+  return this.platform !== constants.PLATFORM_UNIX ? 0 : ((this.getExternalAttributes() >> constants.SHORT_SHIFT) & constants.SHORT_MASK) & constants.MODE_MASK;
+};
+
+ZipArchiveEntry.prototype.getVersionNeededToExtract = function() {
+  return this.minver;
+};
+
+ZipArchiveEntry.prototype.setComment = function(comment) {
+  if (Buffer.byteLength(comment) !== comment.length) {
+    this.getGeneralPurposeBit().useUTF8ForNames(true);
+  }
+
+  this.comment = comment;
+};
+
+ZipArchiveEntry.prototype.setCompressedSize = function(size) {
+  if (size < 0) {
+    throw new Error('invalid entry compressed size');
+  }
+
+  this.csize = size;
+};
+
+ZipArchiveEntry.prototype.setCrc = function(crc) {
+  if (crc < 0) {
+    throw new Error('invalid entry crc32');
+  }
+
+  this.crc = crc;
+};
+
+ZipArchiveEntry.prototype.setExternalAttributes = function(attr) {
+  this.exattr = attr >>> 0;
+};
+
+ZipArchiveEntry.prototype.setExtra = function(extra) {
+  this.extra = extra;
+};
+
+ZipArchiveEntry.prototype.setGeneralPurposeBit = function(gpb) {
+  if (!(gpb instanceof GeneralPurposeBit)) {
+    throw new Error('invalid entry GeneralPurposeBit');
+  }
+
+  this.gpb = gpb;
+};
+
+ZipArchiveEntry.prototype.setInternalAttributes = function(attr) {
+  this.inattr = attr;
+};
+
+ZipArchiveEntry.prototype.setMethod = function(method) {
+  if (method < 0) {
+    throw new Error('invalid entry compression method');
+  }
+
+  this.method = method;
+};
+
+ZipArchiveEntry.prototype.setName = function(name) {
+  name = name.replace(/\\/g, '/').replace(/:/g, '').replace(/^\/+/, '');
+
+  if (Buffer.byteLength(name) !== name.length) {
+    this.getGeneralPurposeBit().useUTF8ForNames(true);
+  }
+
+  this.name = name;
+};
+
+ZipArchiveEntry.prototype.setPlatform = function(platform) {
+  this.platform = platform;
+};
+
+ZipArchiveEntry.prototype.setSize = function(size) {
+  if (size < 0) {
+    throw new Error('invalid entry size');
+  }
+
+  this.size = size;
+};
+
+ZipArchiveEntry.prototype.setTime = function(time) {
+  if (!(time instanceof Date)) {
+    throw new Error('invalid entry time');
+  }
+
+  this.time = zipUtil.dateToDos(time);
+};
+
+ZipArchiveEntry.prototype.setUnixMode = function(mode) {
+  mode &= ~constants.S_IFMT;
+  mode |= this.isDirectory() ? constants.S_IFDIR : constants.S_IFREG;
+
+  var extattr = 0;
+  extattr |= (mode << constants.SHORT_SHIFT) | (this.isDirectory() ? constants.S_DOS_D : constants.S_DOS_A);
+
+  this.setExternalAttributes(extattr);
+  this.mode = mode & constants.MODE_MASK;
+  this.platform = constants.PLATFORM_UNIX;
+};
+
+ZipArchiveEntry.prototype.setVersionNeededToExtract = function(minver) {
+  this.minver = minver;
+};
+
+ZipArchiveEntry.prototype.isDirectory = function() {
+  return this.getName().slice(-1) === '/';
+};
+
+ZipArchiveEntry.prototype.isZip64 = function() {
+  return this.csize > constants.ZIP64_MAGIC || this.size > constants.ZIP64_MAGIC;
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js
new file mode 100644
index 0000000..e527875
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js
@@ -0,0 +1,427 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+var inherits = require('util').inherits;
+var crc32 = require('buffer-crc32');
+var CRC32Stream = require('crc32-stream');
+var DeflateCRC32Stream = CRC32Stream.DeflateCRC32Stream;
+
+var ArchiveOutputStream = require('../archive-output-stream');
+var ZipArchiveEntry = require('./zip-archive-entry');
+var GeneralPurposeBit = require('./general-purpose-bit');
+
+var constants = require('./constants');
+var util = require('../../util');
+var zipUtil = require('./util');
+
+var ZipArchiveOutputStream = module.exports = function(options) {
+  if (!(this instanceof ZipArchiveOutputStream)) {
+    return new ZipArchiveOutputStream(options);
+  }
+
+  options = this.options = this._defaults(options);
+
+  ArchiveOutputStream.call(this, options);
+
+  this._entry = null;
+  this._entries = [];
+  this._archive = {
+    centralLength: 0,
+    centralOffset: 0,
+    comment: '',
+    finish: false,
+    finished: false,
+    processing: false
+  };
+};
+
+inherits(ZipArchiveOutputStream, ArchiveOutputStream);
+
+ZipArchiveOutputStream.prototype._afterAppend = function(ae) {
+  this._entries.push(ae);
+
+  if (ae.getGeneralPurposeBit().usesDataDescriptor()) {
+    this._writeDataDescriptor(ae);
+  }
+
+  this._archive.processing = false;
+  this._entry = null;
+
+  if (this._archive.finish && !this._archive.finished) {
+    this._finish();
+  }
+};
+
+ZipArchiveOutputStream.prototype._appendBuffer = function(ae, source, callback) {
+  if (source.length === 0) {
+    ae.setMethod(constants.METHOD_STORED);
+  }
+
+  var method = ae.getMethod();
+
+  if (method === constants.METHOD_STORED) {
+    ae.setSize(source.length);
+    ae.setCompressedSize(source.length);
+    ae.setCrc(crc32.unsigned(source));
+  }
+
+  this._writeLocalFileHeader(ae);
+
+  if (method === constants.METHOD_STORED) {
+    this.write(source);
+    this._afterAppend(ae);
+    callback(null, ae);
+    return;
+  } else if (method === constants.METHOD_DEFLATED) {
+    this._smartStream(ae, callback).end(source);
+    return;
+  } else {
+    callback(new Error('compression method ' + method + ' not implemented'));
+    return;
+  }
+};
+
+ZipArchiveOutputStream.prototype._appendStream = function(ae, source, callback) {
+  ae.getGeneralPurposeBit().useDataDescriptor(true);
+  ae.setVersionNeededToExtract(constants.MIN_VERSION_DATA_DESCRIPTOR);
+
+  this._writeLocalFileHeader(ae);
+
+  var smart = this._smartStream(ae, callback);
+  source.pipe(smart);
+};
+
+ZipArchiveOutputStream.prototype._defaults = function(o) {
+  if (typeof o !== 'object') {
+    o = {};
+  }
+
+  if (typeof o.zlib !== 'object') {
+    o.zlib = {};
+  }
+
+  if (typeof o.zlib.level !== 'number') {
+    o.zlib.level = constants.ZLIB_BEST_SPEED;
+  }
+
+  return o;
+};
+
+ZipArchiveOutputStream.prototype._finish = function() {
+  this._archive.centralOffset = this.offset;
+
+  this._entries.forEach(function(ae) {
+    this._writeCentralFileHeader(ae);
+  }.bind(this));
+
+  this._archive.centralLength = this.offset - this._archive.centralOffset;
+
+  if (this.isZip64()) {
+    this._writeCentralDirectoryZip64();
+  }
+
+  this._writeCentralDirectoryEnd();
+
+  this._archive.processing = false;
+  this._archive.finish = true;
+  this._archive.finished = true;
+  this.end();
+};
+
+ZipArchiveOutputStream.prototype._normalizeEntry = function(ae) {
+  if (ae.getMethod() === -1) {
+    ae.setMethod(constants.METHOD_DEFLATED);
+  }
+
+  if (ae.getMethod() === constants.METHOD_DEFLATED) {
+    ae.getGeneralPurposeBit().useDataDescriptor(true);
+    ae.setVersionNeededToExtract(constants.MIN_VERSION_DATA_DESCRIPTOR);
+  }
+
+  if (ae.getTime() === -1) {
+    ae.setTime(new Date());
+  }
+
+  ae._offsets = {
+    file: 0,
+    data: 0,
+    contents: 0,
+  };
+};
+
+ZipArchiveOutputStream.prototype._smartStream = function(ae, callback) {
+  var deflate = ae.getMethod() === constants.METHOD_DEFLATED;
+  var process = deflate ? new DeflateCRC32Stream(this.options.zlib) : new CRC32Stream();
+
+  function handleStuff(err) {
+    ae.setCrc(process.digest());
+    ae.setSize(process.size());
+    ae.setCompressedSize(process.size(true));
+    this._afterAppend(ae);
+    callback(null, ae);
+  }
+
+  process.once('error', callback);
+  process.once('end', handleStuff.bind(this));
+
+  process.pipe(this, { end: false });
+
+  return process;
+};
+
+ZipArchiveOutputStream.prototype._writeCentralDirectoryEnd = function() {
+  var records = this._entries.length;
+  var size = this._archive.centralLength;
+  var offset = this._archive.centralOffset;
+
+  if (this.isZip64()) {
+    records = constants.ZIP64_MAGIC_SHORT;
+    size = constants.ZIP64_MAGIC;
+    offset = constants.ZIP64_MAGIC;
+  }
+
+  // signature
+  this.write(zipUtil.getLongBytes(constants.SIG_EOCD));
+
+  // disk numbers
+  this.write(constants.SHORT_ZERO);
+  this.write(constants.SHORT_ZERO);
+
+  // number of entries
+  this.write(zipUtil.getShortBytes(records));
+  this.write(zipUtil.getShortBytes(records));
+
+  // length and location of CD
+  this.write(zipUtil.getLongBytes(size));
+  this.write(zipUtil.getLongBytes(offset));
+
+  // archive comment
+  var comment = this.getComment();
+  var commentLength = Buffer.byteLength(comment);
+  this.write(zipUtil.getShortBytes(commentLength));
+  this.write(comment);
+};
+
+ZipArchiveOutputStream.prototype._writeCentralDirectoryZip64 = function() {
+  // signature
+  this.write(zipUtil.getLongBytes(constants.SIG_ZIP64_EOCD));
+
+  // size of the ZIP64 EOCD record
+  this.write(zipUtil.getEightBytes(56));
+
+  // version made by
+  this.write(zipUtil.getShortBytes(constants.MIN_VERSION_ZIP64));
+
+  // version to extract
+  this.write(zipUtil.getShortBytes(constants.MIN_VERSION_ZIP64));
+
+  // disk numbers
+  this.write(constants.LONG_ZERO);
+  this.write(constants.LONG_ZERO);
+
+  // number of entries
+  this.write(zipUtil.getEightBytes(this._entries.length));
+  this.write(zipUtil.getEightBytes(this._entries.length));
+
+  // length and location of CD
+  this.write(zipUtil.getEightBytes(this._archive.centralLength));
+  this.write(zipUtil.getEightBytes(this._archive.centralOffset));
+
+  // extensible data sector
+  // not implemented at this time
+
+  // end of central directory locator
+  this.write(zipUtil.getLongBytes(constants.SIG_ZIP64_EOCD_LOC));
+
+  // disk number holding the ZIP64 EOCD record
+  this.write(constants.LONG_ZERO);
+
+  // relative offset of the ZIP64 EOCD record
+  this.write(zipUtil.getEightBytes(this._archive.centralOffset + this._archive.centralLength));
+
+  // total number of disks
+  this.write(zipUtil.getLongBytes(1));
+};
+
+ZipArchiveOutputStream.prototype._writeCentralFileHeader = function(ae) {
+  var gpb = ae.getGeneralPurposeBit();
+  var method = ae.getMethod();
+  var offsets = ae._offsets;
+
+  var size = ae.getSize();
+  var compressedSize = ae.getCompressedSize();
+
+  if (ae.isZip64() || offsets.file > constants.ZIP64_MAGIC) {
+    size = constants.ZIP64_MAGIC;
+    compressedSize = constants.ZIP64_MAGIC;
+
+    ae.setVersionNeededToExtract(constants.MIN_VERSION_ZIP64);
+
+    var extraBuf = Buffer.concat([
+      zipUtil.getShortBytes(constants.ZIP64_EXTRA_ID),
+      zipUtil.getShortBytes(24),
+      zipUtil.getEightBytes(ae.getSize()),
+      zipUtil.getEightBytes(ae.getCompressedSize()),
+      zipUtil.getEightBytes(offsets.file)
+    ], 28);
+
+    ae.setExtra(extraBuf);
+  }
+
+  // signature
+  this.write(zipUtil.getLongBytes(constants.SIG_CFH));
+
+  // version made by
+  this.write(zipUtil.getShortBytes((ae.getPlatform() << 8) | constants.VERSION_MADEBY));
+
+  // version to extract and general bit flag
+  this.write(zipUtil.getShortBytes(ae.getVersionNeededToExtract()));
+  this.write(gpb.encode());
+
+  // compression method
+  this.write(zipUtil.getShortBytes(method));
+
+  // datetime
+  this.write(zipUtil.getLongBytes(ae.getTimeDos()));
+
+  // crc32 checksum
+  this.write(zipUtil.getLongBytes(ae.getCrc()));
+
+  // sizes
+  this.write(zipUtil.getLongBytes(compressedSize));
+  this.write(zipUtil.getLongBytes(size));
+
+  var name = ae.getName();
+  var comment = ae.getComment();
+  var extra = ae.getCentralDirectoryExtra();
+
+  if (gpb.usesUTF8ForNames()) {
+    name = new Buffer(name);
+    comment = new Buffer(comment);
+  }
+
+  // name length
+  this.write(zipUtil.getShortBytes(name.length));
+
+  // extra length
+  this.write(zipUtil.getShortBytes(extra.length));
+
+  // comments length
+  this.write(zipUtil.getShortBytes(comment.length));
+
+  // disk number start
+  this.write(constants.SHORT_ZERO);
+
+  // internal attributes
+  this.write(zipUtil.getShortBytes(ae.getInternalAttributes()));
+
+  // external attributes
+  this.write(zipUtil.getLongBytes(ae.getExternalAttributes()));
+
+  // relative offset of LFH
+  if (offsets.file > constants.ZIP64_MAGIC) {
+    this.write(zipUtil.getLongBytes(constants.ZIP64_MAGIC));
+  } else {
+    this.write(zipUtil.getLongBytes(offsets.file));
+  }
+
+  // name
+  this.write(name);
+
+  // extra
+  this.write(extra);
+
+  // comment
+  this.write(comment);
+};
+
+ZipArchiveOutputStream.prototype._writeDataDescriptor = function(ae) {
+  // signature
+  this.write(zipUtil.getLongBytes(constants.SIG_DD));
+
+  // crc32 checksum
+  this.write(zipUtil.getLongBytes(ae.getCrc()));
+
+  // sizes
+  if (ae.isZip64()) {
+    this.write(zipUtil.getEightBytes(ae.getCompressedSize()));
+    this.write(zipUtil.getEightBytes(ae.getSize()));
+  } else {
+    this.write(zipUtil.getLongBytes(ae.getCompressedSize()));
+    this.write(zipUtil.getLongBytes(ae.getSize()));
+  }
+};
+
+ZipArchiveOutputStream.prototype._writeLocalFileHeader = function(ae) {
+  var gpb = ae.getGeneralPurposeBit();
+  var method = ae.getMethod();
+  var name = ae.getName();
+  var extra = ae.getLocalFileDataExtra();
+
+  if (ae.isZip64()) {
+    gpb.useDataDescriptor(true);
+    ae.setVersionNeededToExtract(constants.MIN_VERSION_ZIP64);
+  }
+
+  if (gpb.usesUTF8ForNames()) {
+    name = new Buffer(name);
+  }
+
+  ae._offsets.file = this.offset;
+
+  // signature
+  this.write(zipUtil.getLongBytes(constants.SIG_LFH));
+
+  // version to extract and general bit flag
+  this.write(zipUtil.getShortBytes(ae.getVersionNeededToExtract()));
+  this.write(gpb.encode());
+
+  // compression method
+  this.write(zipUtil.getShortBytes(method));
+
+  // datetime
+  this.write(zipUtil.getLongBytes(ae.getTimeDos()));
+
+  ae._offsets.data = this.offset;
+
+  // crc32 checksum and sizes
+  if (gpb.usesDataDescriptor()) {
+    this.write(constants.LONG_ZERO);
+    this.write(constants.LONG_ZERO);
+    this.write(constants.LONG_ZERO);
+  } else {
+    this.write(zipUtil.getLongBytes(ae.getCrc()));
+    this.write(zipUtil.getLongBytes(ae.getCompressedSize()));
+    this.write(zipUtil.getLongBytes(ae.getSize()));
+  }
+
+  // name length
+  this.write(zipUtil.getShortBytes(name.length));
+
+  // extra length
+  this.write(zipUtil.getShortBytes(extra.length));
+
+  // name
+  this.write(name);
+
+  // extra
+  this.write(extra);
+
+  ae._offsets.contents = this.offset;
+};
+
+ZipArchiveOutputStream.prototype.getComment = function(comment) {
+  return this._archive.comment !== null ? this._archive.comment : '';
+};
+
+ZipArchiveOutputStream.prototype.isZip64 = function() {
+  return this._entries.length > constants.ZIP64_MAGIC_SHORT || this._archive.centralLength > constants.ZIP64_MAGIC || this._archive.centralOffset > constants.ZIP64_MAGIC;
+};
+
+ZipArchiveOutputStream.prototype.setComment = function(comment) {
+  this._archive.comment = comment;
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/compress-commons.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/compress-commons.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/compress-commons.js
new file mode 100644
index 0000000..fe3a581
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/compress-commons.js
@@ -0,0 +1,13 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+module.exports = {
+  ArchiveEntry: require('./archivers/archive-entry'),
+  ZipArchiveEntry: require('./archivers/zip/zip-archive-entry'),
+  ArchiveOutputStream: require('./archivers/archive-output-stream'),
+  ZipArchiveOutputStream: require('./archivers/zip/zip-archive-output-stream')
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/util/index.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/util/index.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/util/index.js
new file mode 100644
index 0000000..6e89f0e
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/lib/util/index.js
@@ -0,0 +1,30 @@
+/**
+ * node-compress-commons
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/ctalkington/node-compress-commons/blob/master/LICENSE-MIT
+ */
+var Stream = require('stream').Stream;
+var PassThrough = require('readable-stream').PassThrough;
+
+var util = module.exports = {};
+
+util.isStream = function(source) {
+  return source instanceof Stream;
+};
+
+util.normalizeInputSource = function(source) {
+  if (source === null) {
+    return new Buffer(0);
+  } else if (typeof source === 'string') {
+    return new Buffer(source);
+  } else if (util.isStream(source) && !source._readableState) {
+    var normalized = new PassThrough();
+    source.pipe(normalized);
+
+    return normalized;
+  }
+
+  return source;
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/CHANGELOG
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/CHANGELOG b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/CHANGELOG
new file mode 100644
index 0000000..983c20b
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/CHANGELOG
@@ -0,0 +1,18 @@
+v0.2.0:
+  date: 2014-05-03
+  changes:
+    - add size method to return raw size of data passed-through.
+v0.1.2:
+  date: 2014-04-18
+  changes:
+    - always use readable-stream for consistency.
+    - use crc32.unsigned to get digest.
+v0.1.1:
+  date: 2014-03-30
+  changes:
+    - gracefully handle "no data" scenario.
+    - trim down deps.
+v0.1.0:
+  date: 2014-03-30
+  changes:
+    - initial release.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/LICENSE-MIT
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/LICENSE-MIT b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/LICENSE-MIT
new file mode 100644
index 0000000..819b403
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/LICENSE-MIT
@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chris Talkington, contributors.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/README.md
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/README.md b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/README.md
new file mode 100644
index 0000000..040224f
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/README.md
@@ -0,0 +1,81 @@
+# crc32-stream v0.3.2 [![Build Status](https://travis-ci.org/archiverjs/node-crc32-stream.svg?branch=master)](https://travis-ci.org/archiverjs/node-crc32-stream)
+
+crc32-stream is a streaming CRC32 checksumer. It uses [buffer-crc32](https://www.npmjs.org/package/buffer-crc32) behind the scenes to reliably handle binary data and fancy character sets. Data is passed through untouched.
+
+[![NPM](https://nodei.co/npm/crc32-stream.png)](https://nodei.co/npm/crc32-stream/)
+
+### Install
+
+```bash
+npm install crc32-stream --save
+```
+
+You can also use `npm install https://github.com/archiverjs/node-crc32-stream/archive/master.tar.gz` to test upcoming versions.
+
+### Usage
+
+#### CRC32Stream
+
+Inherits [Transform Stream](http://nodejs.org/api/stream.html#stream_class_stream_transform) options and methods.
+
+```js
+var CRC32Stream = require('crc32-stream');
+
+var source = fs.createReadStream('file.txt');
+var checksum = new CRC32Stream();
+
+checksum.on('end', function(err) {
+  // do something with checksum.digest() here
+});
+
+// either pipe it
+source.pipe(checksum);
+
+// or write it
+checksum.write('string');
+checksum.end();
+```
+
+#### DeflateCRC32Stream
+
+Inherits [zlib.DeflateRaw](http://nodejs.org/api/zlib.html#zlib_class_zlib_deflateraw) options and methods.
+
+```js
+var DeflateCRC32Stream = require('crc32-stream').DeflateCRC32Stream;
+
+var source = fs.createReadStream('file.txt');
+var checksum = new DeflateCRC32Stream();
+
+checksum.on('end', function(err) {
+  // do something with checksum.digest() here
+});
+
+// either pipe it
+source.pipe(checksum);
+
+// or write it
+checksum.write('string');
+checksum.end();
+```
+
+### Instance API
+
+#### digest()
+
+Returns the checksum digest in unsigned form.
+
+#### hex()
+
+Returns the hexadecimal representation of the checksum digest. (ie E81722F0)
+
+#### size(compressed)
+
+Returns the raw size/length of passed-through data.
+
+If `compressed` is `true`, it returns compressed length instead. (DeflateCRC32Stream)
+
+## Things of Interest
+
+- [Changelog](https://github.com/archiverjs/node-crc32-stream/releases)
+- [Contributing](https://github.com/archiverjs/node-crc32-stream/blob/master/CONTRIBUTING.md)
+- [MIT License](https://github.com/archiverjs/node-crc32-stream/blob/master/LICENSE-MIT)
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/crc32-stream.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/crc32-stream.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/crc32-stream.js
new file mode 100644
index 0000000..42cb454
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/crc32-stream.js
@@ -0,0 +1,42 @@
+/**
+ * node-crc32-stream
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/archiverjs/node-crc32-stream/blob/master/LICENSE-MIT
+ */
+var inherits = require('util').inherits;
+var Transform = require('readable-stream').Transform;
+
+var crc32 = require('buffer-crc32');
+
+var CRC32Stream = module.exports = function CRC32Stream(options) {
+  Transform.call(this, options);
+  this.checksum = new Buffer(4);
+  this.checksum.writeInt32BE(0, 0);
+
+  this.rawSize = 0;
+};
+
+inherits(CRC32Stream, Transform);
+
+CRC32Stream.prototype._transform = function(chunk, encoding, callback) {
+  if (chunk) {
+    this.checksum = crc32(chunk, this.checksum);
+    this.rawSize += chunk.length;
+  }
+
+  callback(null, chunk);
+};
+
+CRC32Stream.prototype.digest = function() {
+  return crc32.unsigned(0, this.checksum);
+};
+
+CRC32Stream.prototype.hex = function() {
+  return this.digest().toString(16).toUpperCase();
+};
+
+CRC32Stream.prototype.size = function() {
+  return this.rawSize;
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/deflate-crc32-stream.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/deflate-crc32-stream.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/deflate-crc32-stream.js
new file mode 100644
index 0000000..ba31dd1
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/deflate-crc32-stream.js
@@ -0,0 +1,67 @@
+/**
+ * node-crc32-stream
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/archiverjs/node-crc32-stream/blob/master/LICENSE-MIT
+ */
+var zlib = require('zlib');
+var inherits = require('util').inherits;
+
+var crc32 = require('buffer-crc32');
+
+var DeflateCRC32Stream = module.exports = function (options) {
+  zlib.DeflateRaw.call(this, options);
+
+  this.checksum = new Buffer(4);
+  this.checksum.writeInt32BE(0, 0);
+
+  this.rawSize = 0;
+  this.compressedSize = 0;
+
+  // BC v0.8
+  if (typeof zlib.DeflateRaw.prototype.push !== 'function') {
+    this.on('data', function(chunk) {
+      if (chunk) {
+        this.compressedSize += chunk.length;
+      }
+    });
+  }
+};
+
+inherits(DeflateCRC32Stream, zlib.DeflateRaw);
+
+DeflateCRC32Stream.prototype.push = function(chunk, encoding) {
+  if (chunk) {
+    this.compressedSize += chunk.length;
+  }
+
+  return zlib.DeflateRaw.prototype.push.call(this, chunk, encoding);
+};
+
+DeflateCRC32Stream.prototype.write = function(chunk, cb) {
+  if (chunk) {
+    this.checksum = crc32(chunk, this.checksum);
+    this.rawSize += chunk.length;
+  }
+
+  return zlib.DeflateRaw.prototype.write.call(this, chunk, cb);
+};
+
+DeflateCRC32Stream.prototype.digest = function() {
+  return crc32.unsigned(0, this.checksum);
+};
+
+DeflateCRC32Stream.prototype.hex = function() {
+  return this.digest().toString(16).toUpperCase();
+};
+
+DeflateCRC32Stream.prototype.size = function(compressed) {
+  compressed = compressed || false;
+
+  if (compressed) {
+    return this.compressedSize;
+  } else {
+    return this.rawSize;
+  }
+};
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/index.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/index.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/index.js
new file mode 100644
index 0000000..31187e3
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/lib/index.js
@@ -0,0 +1,10 @@
+/**
+ * node-crc32-stream
+ *
+ * Copyright (c) 2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/archiverjs/node-crc32-stream/blob/master/LICENSE-MIT
+ */
+exports = module.exports = require('./crc32-stream');
+exports.CRC32Stream = exports;
+exports.DeflateCRC32Stream = require('./deflate-crc32-stream');
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/package.json
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/package.json b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/package.json
new file mode 100644
index 0000000..a03d576
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/crc32-stream/package.json
@@ -0,0 +1,70 @@
+{
+  "name": "crc32-stream",
+  "version": "0.3.2",
+  "description": "a streaming CRC32 checksumer",
+  "homepage": "https://github.com/archiverjs/node-crc32-stream",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/node-crc32-stream.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/node-crc32-stream/issues"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/archiverjs/node-crc32-stream/blob/master/LICENSE-MIT"
+    }
+  ],
+  "main": "lib/index.js",
+  "files": [
+    "lib",
+    "LICENSE-MIT"
+  ],
+  "engines": {
+    "node": ">= 0.8.0"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot"
+  },
+  "dependencies": {
+    "readable-stream": "~1.0.24",
+    "buffer-crc32": "~0.2.1"
+  },
+  "devDependencies": {
+    "chai": "~2.0.0",
+    "mocha": "~2.1.0"
+  },
+  "keywords": [
+    "crc32-stream",
+    "crc32",
+    "stream",
+    "checksum"
+  ],
+  "gitHead": "5fff7a70787e28b634c166ecb4e6184ad0efca66",
+  "_id": "crc32-stream@0.3.2",
+  "_shasum": "8c86a5c4ed38c53e36750d662784ad8ec642e38e",
+  "_from": "crc32-stream@>=0.3.1 <0.4.0",
+  "_npmVersion": "2.5.1",
+  "_nodeVersion": "0.12.0",
+  "_npmUser": {
+    "name": "ctalkington",
+    "email": "chris@christalkington.com"
+  },
+  "maintainers": [
+    {
+      "name": "ctalkington",
+      "email": "chris@christalkington.com"
+    }
+  ],
+  "dist": {
+    "shasum": "8c86a5c4ed38c53e36750d662784ad8ec642e38e",
+    "tarball": "http://registry.npmjs.org/crc32-stream/-/crc32-stream-0.3.2.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-0.3.2.tgz"
+}

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/.npmignore
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/.npmignore b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/.npmignore
new file mode 100644
index 0000000..825fc67
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/.npmignore
@@ -0,0 +1,3 @@
+node_modules
+.DS_Store
+npm-debug.log

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/Int64.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/Int64.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/Int64.js
new file mode 100644
index 0000000..aa889bb
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/Int64.js
@@ -0,0 +1,234 @@
+//     Int64.js
+//
+//     Copyright (c) 2012 Robert Kieffer
+//     MIT License - http://opensource.org/licenses/mit-license.php
+
+/**
+ * Support for handling 64-bit int numbers in Javascript (node.js)
+ *
+ * JS Numbers are IEEE-754 binary double-precision floats, which limits the
+ * range of values that can be represented with integer precision to:
+ *
+ * 2^^53 <= N <= 2^53
+ *
+ * Int64 objects wrap a node Buffer that holds the 8-bytes of int64 data.  These
+ * objects operate directly on the buffer which means that if they are created
+ * using an existing buffer then setting the value will modify the Buffer, and
+ * vice-versa.
+ *
+ * Internal Representation
+ *
+ * The internal buffer format is Big Endian.  I.e. the most-significant byte is
+ * at buffer[0], the least-significant at buffer[7].  For the purposes of
+ * converting to/from JS native numbers, the value is assumed to be a signed
+ * integer stored in 2's complement form.
+ *
+ * For details about IEEE-754 see:
+ * http://en.wikipedia.org/wiki/Double_precision_floating-point_format
+ */
+
+// Useful masks and values for bit twiddling
+var MASK31 =  0x7fffffff, VAL31 = 0x80000000;
+var MASK32 =  0xffffffff, VAL32 = 0x100000000;
+
+// Map for converting hex octets to strings
+var _HEX = [];
+for (var i = 0; i < 256; i++) {
+  _HEX[i] = (i > 0xF ? '' : '0') + i.toString(16);
+}
+
+//
+// Int64
+//
+
+/**
+ * Constructor accepts any of the following argument types:
+ *
+ * new Int64(buffer[, offset=0]) - Existing Buffer with byte offset
+ * new Int64(Uint8Array[, offset=0]) - Existing Uint8Array with a byte offset
+ * new Int64(string)             - Hex string (throws if n is outside int64 range)
+ * new Int64(number)             - Number (throws if n is outside int64 range)
+ * new Int64(hi, lo)             - Raw bits as two 32-bit values
+ */
+var Int64 = module.exports = function(a1, a2) {
+  if (a1 instanceof Buffer) {
+    this.buffer = a1;
+    this.offset = a2 || 0;
+  } else if (Object.prototype.toString.call(a1) == '[object Uint8Array]') {
+    // Under Browserify, Buffers can extend Uint8Arrays rather than an
+    // instance of Buffer. We could assume the passed in Uint8Array is actually
+    // a buffer but that won't handle the case where a raw Uint8Array is passed
+    // in. We construct a new Buffer just in case.
+    this.buffer = new Buffer(a1);
+    this.offset = a2 || 0;
+  } else {
+    this.buffer = this.buffer || new Buffer(8);
+    this.offset = 0;
+    this.setValue.apply(this, arguments);
+  }
+};
+
+
+// Max integer value that JS can accurately represent
+Int64.MAX_INT = Math.pow(2, 53);
+
+// Min integer value that JS can accurately represent
+Int64.MIN_INT = -Math.pow(2, 53);
+
+Int64.prototype = {
+  /**
+   * Do in-place 2's compliment.  See
+   * http://en.wikipedia.org/wiki/Two's_complement
+   */
+  _2scomp: function() {
+    var b = this.buffer, o = this.offset, carry = 1;
+    for (var i = o + 7; i >= o; i--) {
+      var v = (b[i] ^ 0xff) + carry;
+      b[i] = v & 0xff;
+      carry = v >> 8;
+    }
+  },
+
+  /**
+   * Set the value. Takes any of the following arguments:
+   *
+   * setValue(string) - A hexidecimal string
+   * setValue(number) - Number (throws if n is outside int64 range)
+   * setValue(hi, lo) - Raw bits as two 32-bit values
+   */
+  setValue: function(hi, lo) {
+    var negate = false;
+    if (arguments.length == 1) {
+      if (typeof(hi) == 'number') {
+        // Simplify bitfield retrieval by using abs() value.  We restore sign
+        // later
+        negate = hi < 0;
+        hi = Math.abs(hi);
+        lo = hi % VAL32;
+        hi = hi / VAL32;
+        if (hi > VAL32) throw new RangeError(hi  + ' is outside Int64 range');
+        hi = hi | 0;
+      } else if (typeof(hi) == 'string') {
+        hi = (hi + '').replace(/^0x/, '');
+        lo = hi.substr(-8);
+        hi = hi.length > 8 ? hi.substr(0, hi.length - 8) : '';
+        hi = parseInt(hi, 16);
+        lo = parseInt(lo, 16);
+      } else {
+        throw new Error(hi + ' must be a Number or String');
+      }
+    }
+
+    // Technically we should throw if hi or lo is outside int32 range here, but
+    // it's not worth the effort. Anything past the 32'nd bit is ignored.
+
+    // Copy bytes to buffer
+    var b = this.buffer, o = this.offset;
+    for (var i = 7; i >= 0; i--) {
+      b[o+i] = lo & 0xff;
+      lo = i == 4 ? hi : lo >>> 8;
+    }
+
+    // Restore sign of passed argument
+    if (negate) this._2scomp();
+  },
+
+  /**
+   * Convert to a native JS number.
+   *
+   * WARNING: Do not expect this value to be accurate to integer precision for
+   * large (positive or negative) numbers!
+   *
+   * @param allowImprecise If true, no check is performed to verify the
+   * returned value is accurate to integer precision.  If false, imprecise
+   * numbers (very large positive or negative numbers) will be forced to +/-
+   * Infinity.
+   */
+  toNumber: function(allowImprecise) {
+    var b = this.buffer, o = this.offset;
+
+    // Running sum of octets, doing a 2's complement
+    var negate = b[o] & 0x80, x = 0, carry = 1;
+    for (var i = 7, m = 1; i >= 0; i--, m *= 256) {
+      var v = b[o+i];
+
+      // 2's complement for negative numbers
+      if (negate) {
+        v = (v ^ 0xff) + carry;
+        carry = v >> 8;
+        v = v & 0xff;
+      }
+
+      x += v * m;
+    }
+
+    // Return Infinity if we've lost integer precision
+    if (!allowImprecise && x >= Int64.MAX_INT) {
+      return negate ? -Infinity : Infinity;
+    }
+
+    return negate ? -x : x;
+  },
+
+  /**
+   * Convert to a JS Number. Returns +/-Infinity for values that can't be
+   * represented to integer precision.
+   */
+  valueOf: function() {
+    return this.toNumber(false);
+  },
+
+  /**
+   * Return string value
+   *
+   * @param radix Just like Number#toString()'s radix
+   */
+  toString: function(radix) {
+    return this.valueOf().toString(radix || 10);
+  },
+
+  /**
+   * Return a string showing the buffer octets, with MSB on the left.
+   *
+   * @param sep separator string. default is '' (empty string)
+   */
+  toOctetString: function(sep) {
+    var out = new Array(8);
+    var b = this.buffer, o = this.offset;
+    for (var i = 0; i < 8; i++) {
+      out[i] = _HEX[b[o+i]];
+    }
+    return out.join(sep || '');
+  },
+
+  /**
+   * Returns the int64's 8 bytes in a buffer.
+   *
+   * @param {bool} [rawBuffer=false]  If no offset and this is true, return the internal buffer.  Should only be used if
+   *                                  you're discarding the Int64 afterwards, as it breaks encapsulation.
+   */
+  toBuffer: function(rawBuffer) {
+    if (rawBuffer && this.offset === 0) return this.buffer;
+
+    var out = new Buffer(8);
+    this.buffer.copy(out, 0, this.offset, this.offset + 8);
+    return out;
+  },
+
+  /**
+   * Copy 8 bytes of int64 into target buffer at target offset.
+   *
+   * @param {Buffer} targetBuffer       Buffer to copy into.
+   * @param {number} [targetOffset=0]   Offset into target buffer.
+   */
+  copy: function(targetBuffer, targetOffset) {
+    this.buffer.copy(targetBuffer, targetOffset || 0, this.offset, this.offset + 8);
+  },
+
+  /**
+   * Pretty output in console.log
+   */
+  inspect: function() {
+    return '[Int64 value:' + this + ' octets:' + this.toOctetString(' ') + ']';
+  }
+};

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/LICENSE
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/LICENSE b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/LICENSE
new file mode 100644
index 0000000..ddb6a90
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 Robert Kieffer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/README.md
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/README.md b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/README.md
new file mode 100644
index 0000000..efef18a
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/README.md
@@ -0,0 +1,78 @@
+JavaScript Numbers are represented as [IEEE 754 double-precision floats](http://steve.hollasch.net/cgindex/coding/ieeefloat.html).  Unfortunately, this means they lose integer precision for values beyond +/- 2^^53.  For projects that need to accurately handle 64-bit ints, such as [node-thrift](https://github.com/wadey/node-thrift), a performant, Number-like class is needed.  Int64 is that class.
+
+Int64 instances look and feel much like JS-native Numbers.  By way of example ...
+```js
+// First, let's illustrate the problem ...
+> (0x123456789).toString(16)
+'123456789' // <- what we expect.
+> (0x123456789abcdef0).toString(16)
+'123456789abcdf00' // <- Ugh!  JS doesn't do big ints. :(
+
+// So let's create a couple Int64s using the above values ...
+
+// Require, of course
+> Int64 = require('node-int64')
+
+// x's value is what we expect (the decimal value of 0x123456789)
+> x = new Int64(0x123456789)
+[Int64 value:4886718345 octets:00 00 00 01 23 45 67 89]
+
+// y's value is Infinity because it's outside the range of integer
+// precision.  But that's okay - it's still useful because it's internal
+// representation (octets) is what we passed in
+> y = new Int64('123456789abcdef0')
+[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]
+
+// Let's do some math.  Int64's behave like Numbers.  (Sorry, Int64 isn't
+// for doing 64-bit integer arithmetic (yet) - it's just for carrying
+// around int64 values
+> x + 1
+4886718346
+> y + 1
+Infinity
+
+// Int64 string operations ...
+> 'value: ' + x
+'value: 4886718345'
+> 'value: ' + y
+'value: Infinity'
+> x.toString(2)
+'100100011010001010110011110001001'
+> y.toString(2)
+'Infinity'
+
+// Use JS's isFinite() method to see if the Int64 value is in the
+// integer-precise range of JS values
+> isFinite(x)
+true
+> isFinite(y)
+false
+
+// Get an octet string representation.  (Yay, y is what we put in!)
+> x.toOctetString()
+'0000000123456789'
+> y.toOctetString()
+'123456789abcdef0'
+
+// Finally, some other ways to create Int64s ...
+
+// Pass hi/lo words
+> new Int64(0x12345678, 0x9abcdef0)
+[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]
+
+// Pass a Buffer
+> new Int64(new Buffer([0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0]))
+[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]
+
+// Pass a Buffer and offset
+> new Int64(new Buffer([0,0,0,0,0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0]), 4)
+[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]
+
+// Pull out into a buffer
+> new Int64(new Buffer([0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0])).toBuffer()
+<Buffer 12 34 56 78 9a bc de f0>
+
+// Or copy into an existing one (at an offset)
+> var buf = new Buffer(1024);
+> new Int64(new Buffer([0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0])).copy(buf, 512);
+```

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/package.json
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/package.json b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/package.json
new file mode 100644
index 0000000..8404a2c
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/package.json
@@ -0,0 +1,56 @@
+{
+  "name": "node-int64",
+  "description": "Support for representing 64-bit integers in JavaScript",
+  "url": "http://github.com/broofa/node-int64",
+  "keywords": [
+    "math",
+    "integer",
+    "int64"
+  ],
+  "author": {
+    "name": "Robert Kieffer",
+    "email": "robert@broofa.com"
+  },
+  "contributors": [],
+  "dependencies": {},
+  "license": "MIT",
+  "lib": ".",
+  "main": "./Int64.js",
+  "version": "0.3.3",
+  "scripts": {
+    "test": "nodeunit test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/broofa/node-int64"
+  },
+  "devDependencies": {
+    "nodeunit": "^0.9.0"
+  },
+  "gitHead": "21873768fb14d6ce954507f229e3db254328a183",
+  "bugs": {
+    "url": "https://github.com/broofa/node-int64/issues"
+  },
+  "homepage": "https://github.com/broofa/node-int64",
+  "_id": "node-int64@0.3.3",
+  "_shasum": "2d6e6b2ece5de8588b43d88d1bc41b26cd1fa84d",
+  "_from": "node-int64@>=0.3.0 <0.4.0",
+  "_npmVersion": "1.4.28",
+  "_npmUser": {
+    "name": "broofa",
+    "email": "robert@broofa.com"
+  },
+  "maintainers": [
+    {
+      "name": "broofa",
+      "email": "robert@broofa.com"
+    }
+  ],
+  "dist": {
+    "shasum": "2d6e6b2ece5de8588b43d88d1bc41b26cd1fa84d",
+    "tarball": "http://registry.npmjs.org/node-int64/-/node-int64-0.3.3.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.3.3.tgz",
+  "readme": "ERROR: No README data found!"
+}

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/test.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/test.js b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/test.js
new file mode 100644
index 0000000..1187364
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/node_modules/node-int64/test.js
@@ -0,0 +1,83 @@
+var assert = require('assert');
+var Int64 = require('./Int64');
+
+exports.setUp = function(done) {
+  done();
+};
+
+exports.testBufferToString = function(test) {
+  var int = new Int64(0xfffaffff, 0xfffff700);
+  test.equal(
+    int.toBuffer().toString('hex'),
+    'fffafffffffff700',
+    'Buffer to string conversion'
+  );
+  test.done();
+};
+
+exports.testBufferCopy = function(test) {
+  var src = new Int64(0xfffaffff, 0xfffff700);
+  var dst = new Buffer(8);
+
+  src.copy(dst);
+
+  test.deepEqual(
+    dst,
+    new Buffer([0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x00]),
+    'Copy to buffer'
+  );
+
+  test.done();
+};
+
+exports.testValueRepresentation = function(test) {
+  var args = [
+    [0],                     '0000000000000000', 0,
+    [1],                     '0000000000000001', 1,
+    [-1],                    'ffffffffffffffff', -1,
+    [1e18],                  '0de0b6b3a7640000', 1e18,
+    ['0001234500654321'],    '0001234500654321',     0x1234500654321,
+    ['0ff1234500654321'],    '0ff1234500654321',   0xff1234500654300, // Imprecise!
+    [0xff12345, 0x654321],   '0ff1234500654321',   0xff1234500654300, // Imprecise!
+    [0xfffaffff, 0xfffff700],'fffafffffffff700',    -0x5000000000900,
+    [0xafffffff, 0xfffff700],'affffffffffff700', -0x5000000000000800, // Imprecise!
+    ['0x0000123450654321'],  '0000123450654321',      0x123450654321,
+    ['0xFFFFFFFFFFFFFFFF'],  'ffffffffffffffff', -1
+  ];
+
+  // Test constructor argments
+
+  for (var i = 0; i < args.length; i += 3) {
+    var a = args[i], octets = args[i+1], number = args[i+2];
+
+    // Create instance
+    var x = new Int64();
+    Int64.apply(x, a);
+
+    test.equal(x.toOctetString(), octets, 'Constuctor with ' + args.join(', '));
+    test.equal(x.toNumber(true), number);
+  }
+
+  test.done();
+};
+
+exports.testBufferOffsets = function(test) {
+  var sourceBuffer = new Buffer(16);
+  sourceBuffer.writeUInt32BE(0xfffaffff, 2);
+  sourceBuffer.writeUInt32BE(0xfffff700, 6);
+
+  var int = new Int64(sourceBuffer, 2);
+  assert.equal(
+    int.toBuffer().toString('hex'), 'fffafffffffff700',
+    'Construct from offset'
+  );
+
+  var targetBuffer = new Buffer(16);
+  int.copy(targetBuffer, 4);
+  assert.equal(
+    targetBuffer.slice(4, 12).toString('hex'), 'fffafffffffff700',
+    'Copy to offset'
+  );
+
+  test.done();
+};

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/package.json
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/package.json b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/package.json
new file mode 100644
index 0000000..b9cdf10
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/node_modules/compress-commons/package.json
@@ -0,0 +1,73 @@
+{
+  "name": "compress-commons",
+  "version": "0.2.7",
+  "description": "a library that defines a common interface for working with archive formats within node",
+  "homepage": "https://github.com/archiverjs/node-compress-commons",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/node-compress-commons.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/node-compress-commons/issues"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/archiverjs/node-compress-commons/blob/master/LICENSE-MIT"
+    }
+  ],
+  "main": "lib/compress-commons.js",
+  "files": [
+    "lib",
+    "LICENSE-MIT"
+  ],
+  "engines": {
+    "node": ">= 0.8.0"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot"
+  },
+  "dependencies": {
+    "buffer-crc32": "~0.2.1",
+    "crc32-stream": "~0.3.1",
+    "node-int64": "~0.3.0",
+    "readable-stream": "~1.0.26"
+  },
+  "devDependencies": {
+    "chai": "~1.10.0",
+    "mocha": "~2.0.1",
+    "rimraf": "~2.2.8",
+    "mkdirp": "~0.5.0"
+  },
+  "keywords": [
+    "compress",
+    "commons",
+    "archive"
+  ],
+  "gitHead": "a5e5c01424894053993eb4b0aeadfe9b7992475f",
+  "_id": "compress-commons@0.2.7",
+  "_shasum": "0c68d0eb4242dc0042705b7591d29a5e995adc5e",
+  "_from": "compress-commons@>=0.2.0 <0.3.0",
+  "_npmVersion": "2.5.1",
+  "_nodeVersion": "0.12.0",
+  "_npmUser": {
+    "name": "ctalkington",
+    "email": "chris@christalkington.com"
+  },
+  "maintainers": [
+    {
+      "name": "ctalkington",
+      "email": "chris@christalkington.com"
+    }
+  ],
+  "dist": {
+    "shasum": "0c68d0eb4242dc0042705b7591d29a5e995adc5e",
+    "tarball": "http://registry.npmjs.org/compress-commons/-/compress-commons-0.2.7.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-0.2.7.tgz"
+}

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/zip-stream/package.json
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/zip-stream/package.json b/node_modules/archiver/node_modules/zip-stream/package.json
new file mode 100644
index 0000000..e807db6
--- /dev/null
+++ b/node_modules/archiver/node_modules/zip-stream/package.json
@@ -0,0 +1,73 @@
+{
+  "name": "zip-stream",
+  "version": "0.5.1",
+  "description": "a streaming zip archive generator.",
+  "homepage": "https://github.com/archiverjs/node-zip-stream",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/node-zip-stream.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/node-zip-stream/issues"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/archiverjs/node-zip-stream/blob/master/LICENSE-MIT"
+    }
+  ],
+  "main": "lib/zip-stream.js",
+  "files": [
+    "lib",
+    "LICENSE-MIT"
+  ],
+  "engines": {
+    "node": ">= 0.8.0"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot"
+  },
+  "dependencies": {
+    "compress-commons": "~0.2.0",
+    "lodash": "~3.2.0",
+    "readable-stream": "~1.0.26"
+  },
+  "devDependencies": {
+    "chai": "~2.0.0",
+    "mocha": "~2.1.0",
+    "rimraf": "~2.2.8",
+    "mkdirp": "~0.5.0"
+  },
+  "keywords": [
+    "archive",
+    "stream",
+    "zip-stream",
+    "zip"
+  ],
+  "gitHead": "b2c2023d355886a5dff8da5907064c70bf27d290",
+  "_id": "zip-stream@0.5.1",
+  "_shasum": "1c85540abcb25d70342875529949ef244f3dfcf6",
+  "_from": "zip-stream@>=0.5.0 <0.6.0",
+  "_npmVersion": "2.5.1",
+  "_nodeVersion": "0.12.0",
+  "_npmUser": {
+    "name": "ctalkington",
+    "email": "chris@christalkington.com"
+  },
+  "maintainers": [
+    {
+      "name": "ctalkington",
+      "email": "chris@christalkington.com"
+    }
+  ],
+  "dist": {
+    "shasum": "1c85540abcb25d70342875529949ef244f3dfcf6",
+    "tarball": "http://registry.npmjs.org/zip-stream/-/zip-stream-0.5.1.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-0.5.1.tgz"
+}

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/package.json
----------------------------------------------------------------------
diff --git a/node_modules/archiver/package.json b/node_modules/archiver/package.json
new file mode 100644
index 0000000..7506601
--- /dev/null
+++ b/node_modules/archiver/package.json
@@ -0,0 +1,84 @@
+{
+  "name": "archiver",
+  "version": "0.14.3",
+  "description": "a streaming interface for archive generation",
+  "homepage": "https://github.com/archiverjs/node-archiver",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/node-archiver.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/node-archiver/issues"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/archiverjs/node-archiver/blob/master/LICENSE-MIT"
+    }
+  ],
+  "main": "lib/archiver.js",
+  "files": [
+    "lib",
+    "LICENSE-MIT"
+  ],
+  "engines": {
+    "node": ">= 0.10.0"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot",
+    "bencha": "node benchmark/simple/pack-zip.js",
+    "benchb": "mocha --reporter list test/optional/bench.js"
+  },
+  "dependencies": {
+    "async": "~0.9.0",
+    "buffer-crc32": "~0.2.1",
+    "glob": "~4.3.0",
+    "lazystream": "~0.1.0",
+    "lodash": "~3.2.0",
+    "readable-stream": "~1.0.26",
+    "tar-stream": "~1.1.0",
+    "zip-stream": "~0.5.0"
+  },
+  "devDependencies": {
+    "chai": "~2.0.0",
+    "mocha": "~2.1.0",
+    "rimraf": "~2.2.8",
+    "mkdirp": "~0.5.0",
+    "stream-bench": "~0.1.2",
+    "tar": "~1.0.3",
+    "yauzl": "~2.2.1"
+  },
+  "keywords": [
+    "archive",
+    "archiver",
+    "stream",
+    "zip",
+    "tar"
+  ],
+  "gitHead": "c62a470d7a22a018e87bc9dc1d1e3adf07ddffc2",
+  "_id": "archiver@0.14.3",
+  "_shasum": "e265f2af74df8f24124c01cecccc0772f57f36fc",
+  "_from": "archiver@*",
+  "_npmVersion": "2.5.1",
+  "_nodeVersion": "0.12.0",
+  "_npmUser": {
+    "name": "ctalkington",
+    "email": "chris@christalkington.com"
+  },
+  "maintainers": [
+    {
+      "name": "ctalkington",
+      "email": "chris@christalkington.com"
+    }
+  ],
+  "dist": {
+    "shasum": "e265f2af74df8f24124c01cecccc0772f57f36fc",
+    "tarball": "http://registry.npmjs.org/archiver/-/archiver-0.14.3.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/archiver/-/archiver-0.14.3.tgz"
+}

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/package.json
----------------------------------------------------------------------
diff --git a/package.json b/package.json
index 532f337..576fb97 100644
--- a/package.json
+++ b/package.json
@@ -13,12 +13,12 @@
         "apache"
     ],
     "dependencies": {
-        "shelljs": "^0.1.4",
-        "adm-zip": "0.4.4"
+        "archiver": "^0.14.3",
+        "shelljs": "^0.1.4"
     },
     "bundledDependencies": [
-        "shelljs",
-        "adm-zip"
+        "archiver",
+        "shelljs"
     ],
     "author": "Apache Software Foundation",
     "contributors": [
@@ -36,4 +36,4 @@
         }
     ],
     "license": "Apache Version 2.0"
-}
\ No newline at end of file
+}


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message