cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From za...@apache.org
Subject [12/20] cordova-firefoxos git commit: CB-7567 Don't use adm-zip because it creates invalid zip files
Date Fri, 20 Feb 2015 19:38:06 GMT
http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/README.md
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/README.md b/node_modules/archiver/node_modules/lodash/README.md
new file mode 100644
index 0000000..7c2b172
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/README.md
@@ -0,0 +1,118 @@
+# lodash v3.2.0
+
+The [modern build](https://github.com/lodash/lodash/wiki/Build-Differences) of [lodash](https://lodash.com/) exported as [Node.js](http://nodejs.org/)/[io.js](https://iojs.org/) modules.
+
+Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli):
+```bash
+$ lodash modularize modern exports=node -o ./
+$ lodash modern -d -o ./index.js
+```
+
+## Installation
+
+Using npm:
+
+```bash
+$ {sudo -H} npm i -g npm
+$ npm i --save lodash
+```
+
+In Node.js/io.js:
+
+```js
+// load the modern build
+var _ = require('lodash');
+// or a method category
+var array = require('lodash/array');
+// or a method
+var chunk = require('lodash/array/chunk');
+```
+
+See the [package source](https://github.com/lodash/lodash/tree/3.2.0-npm) for more details.
+
+**Note:**<br>
+Don’t assign values to the [special variable](http://nodejs.org/api/repl.html#repl_repl_features) `_` when in the REPL.<br>
+Install [n_](https://www.npmjs.com/package/n_) for a REPL that includes lodash by default.
+
+## Module formats
+
+lodash is also available in a variety of other builds & module formats.
+
+ * npm packages for [modern](https://www.npmjs.com/package/lodash), [compatibility](https://www.npmjs.com/package/lodash-compat), & [per method](https://www.npmjs.com/browse/keyword/lodash-modularized) builds
+ * AMD modules for [modern](https://github.com/lodash/lodash/tree/3.2.0-amd) & [compatibility](https://github.com/lodash/lodash-compat/tree/3.2.0-amd) builds
+ * ES modules for the [modern](https://github.com/lodash/lodash/tree/3.2.0-es) build
+
+## Further Reading
+
+  * [API Documentation](https://lodash.com/docs)
+  * [Build Differences](https://github.com/lodash/lodash/wiki/Build-Differences)
+  * [Changelog](https://github.com/lodash/lodash/wiki/Changelog)
+  * [Release Notes](https://github.com/lodash/lodash/releases)
+  * [Roadmap](https://github.com/lodash/lodash/wiki/Roadmap)
+  * [More Resources](https://github.com/lodash/lodash/wiki/Resources)
+
+## Features *not* in Underscore
+
+ * ~100% [code coverage](https://coveralls.io/r/lodash)
+ * Follows [semantic versioning](http://semver.org/) for releases
+ * [Lazily evaluated](http://filimanjaro.com/blog/2014/introducing-lazy-evaluation/) chaining
+ * [_(…)](https://lodash.com/docs#_) supports intuitive chaining
+ * [_.ary](https://lodash.com/docs#ary) & [_.rearg](https://lodash.com/docs#rearg) to change function argument limits & order
+ * [_.at](https://lodash.com/docs#at) for cherry-picking collection values
+ * [_.attempt](https://lodash.com/docs#attempt) to execute functions which may error without a try-catch
+ * [_.before](https://lodash.com/docs#before) to complement [_.after](https://lodash.com/docs#after)
+ * [_.bindKey](https://lodash.com/docs#bindKey) for binding [*“lazy”*](http://michaux.ca/articles/lazy-function-definition-pattern) defined methods
+ * [_.chunk](https://lodash.com/docs#chunk) for splitting an array into chunks of a given size
+ * [_.clone](https://lodash.com/docs#clone) supports shallow cloning of `Date` & `RegExp` objects
+ * [_.cloneDeep](https://lodash.com/docs#cloneDeep) for deep cloning arrays & objects
+ * [_.create](https://lodash.com/docs#create) for easier object inheritance
+ * [_.curry](https://lodash.com/docs#curry) & [_.curryRight](https://lodash.com/docs#curryRight) for creating [curried](http://hughfdjackson.com/javascript/why-curry-helps/) functions
+ * [_.debounce](https://lodash.com/docs#debounce) & [_.throttle](https://lodash.com/docs#throttle) are cancelable & accept options for more control
+ * [_.fill](https://lodash.com/docs#fill) to fill arrays with values
+ * [_.findIndex](https://lodash.com/docs#findIndex) & [_.findKey](https://lodash.com/docs#findKey) for finding indexes & keys
+ * [_.flow](https://lodash.com/docs#flow) to complement [_.flowRight](https://lodash.com/docs#flowRight) (a.k.a `_.compose`)
+ * [_.forEach](https://lodash.com/docs#forEach) supports exiting early
+ * [_.forIn](https://lodash.com/docs#forIn) for iterating all enumerable properties
+ * [_.forOwn](https://lodash.com/docs#forOwn) for iterating own properties
+ * [_.includes](https://lodash.com/docs#includes) accepts a `fromIndex`
+ * [_.isError](https://lodash.com/docs#isError) to check for error objects
+ * [_.isNative](https://lodash.com/docs#isNative) to check for native functions
+ * [_.isPlainObject](https://lodash.com/docs#isPlainObject) & [_.toPlainObject](https://lodash.com/docs#toPlainObject) to check for & convert to `Object` objects
+ * [_.isTypedArray](https://lodash.com/docs#isTypedArray) to check for typed arrays
+ * [_.keysIn](https://lodash.com/docs#keysIn) & [_.valuesIn](https://lodash.com/docs#valuesIn) for getting keys & values of all enumerable properties
+ * [_.mapValues](https://lodash.com/docs#mapValues) for [mapping](https://lodash.com/docs#map) values to an object
+ * [_.matches](https://lodash.com/docs#matches) supports deep object comparisons
+ * [_.matchesProperty](https://lodash.com/docs#matchesProperty) to complement [_.matches](https://lodash.com/docs#matches) & [_.property](https://lodash.com/docs#property)
+ * [_.merge](https://lodash.com/docs#merge) for a deep [_.extend](https://lodash.com/docs#extend)
+ * [_.parseInt](https://lodash.com/docs#parseInt) for consistent cross-environment behavior
+ * [_.propertyOf](https://lodash.com/docs#propertyOf) to complement [_.property](https://lodash.com/docs#property)
+ * [_.pull](https://lodash.com/docs#pull), [_.pullAt](https://lodash.com/docs#pullAt), & [_.remove](https://lodash.com/docs#remove) for mutating arrays
+ * [_.random](https://lodash.com/docs#random) supports returning floating-point numbers
+ * [_.runInContext](https://lodash.com/docs#runInContext) for collisionless mixins & easier mocking
+ * [_.slice](https://lodash.com/docs#slice) for creating subsets of array-like values
+ * [_.sortByAll](https://lodash.com/docs#sortBy) for sorting by multiple properties
+ * [_.spread](https://lodash.com/docs#spread) for creating a function to spread an array of arguments to another
+ * [_.support](https://lodash.com/docs#support) for flagging environment features
+ * [_.template](https://lodash.com/docs#template) supports [*“imports”*](https://lodash.com/docs#templateSettings-imports) options & [ES template delimiters](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-template-literal-lexical-components)
+ * [_.transform](https://lodash.com/docs#transform) as a powerful alternative to [_.reduce](https://lodash.com/docs#reduce) for transforming objects
+ * [_.xor](https://lodash.com/docs#xor) to complement [_.difference](https://lodash.com/docs#difference), [_.intersection](https://lodash.com/docs#intersection), & [_.union](https://lodash.com/docs#union)
+ * [_.bind](https://lodash.com/docs#bind), [_.curry](https://lodash.com/docs#curry), [_.partial](https://lodash.com/docs#partial), &
+   [more](https://lodash.com/docs "_.bindKey, _.curryRight, _.partialRight") support customizable argument placeholders
+ * [_.capitalize](https://lodash.com/docs#capitalize), [_.trim](https://lodash.com/docs#trim), &
+   [more](https://lodash.com/docs "_.camelCase, _.deburr, _.endsWith, _.escapeRegExp, _.kebabCase, _.pad, _.padLeft, _.padRight, _.repeat, _.snakeCase, _.startCase, _.startsWith, _.trimLeft, _.trimRight, _.trunc, _.words") string methods
+ * [_.clone](https://lodash.com/docs#clone), [_.isEqual](https://lodash.com/docs#isEqual), &
+   [more](https://lodash.com/docs "_.assign, _.cloneDeep, _.merge") accept callbacks
+ * [_.dropWhile](https://lodash.com/docs#dropWhile), [_.takeWhile](https://lodash.com/docs#takeWhile), &
+   [more](https://lodash.com/docs "_.drop, _.dropRightWhile, _.take, _.takeRightWhile") to complement [_.first](https://lodash.com/docs#first), [_.initial](https://lodash.com/docs#initial), [_.last](https://lodash.com/docs#last), & [_.rest](https://lodash.com/docs#rest)
+ * [_.findLast](https://lodash.com/docs#findLast), [_.findLastIndex](https://lodash.com/docs#findLastIndex), &
+   [more](https://lodash.com/docs "_.findLastKey, _.flowRight, _.forEachRight, _.forInRight, _.forOwnRight, _.partialRight") right-associative methods
+ * [_.includes](https://lodash.com/docs#includes), [_.toArray](https://lodash.com/docs#toArray), &
+   [more](https://lodash.com/docs "_.at, _.countBy, _.every, _.filter, _.find, _.findLast, _.forEach, _.forEachRight, _.groupBy, _.indexBy, _.invoke, _.map, _.max, _.min, _.partition, _.pluck, _.reduce, _.reduceRight, _.reject, _.shuffle, _.size, _.some, _.sortBy") accept strings
+ * [_#commit](https://lodash.com/docs#prototype-commit) & [_#plant](https://lodash.com/docs#prototype-plant) for working with chain sequences
+ * [_#thru](https://lodash.com/docs#thru) to pass values thru a chain sequence
+
+## Support
+
+Tested in Chrome 39-40, Firefox 34-35, IE 6-11, Opera 26-27, Safari 5-8, io.js 1.2.0, Node.js 0.8.28, 0.10.36, & 0.12.0, PhantomJS 1.9.8, RingoJS 0.11, & Rhino 1.7RC5.
+
+Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available. Special thanks to [Sauce Labs](https://saucelabs.com/) for providing automated browser testing.

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array.js b/node_modules/archiver/node_modules/lodash/array.js
new file mode 100644
index 0000000..6ef12c7
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array.js
@@ -0,0 +1,42 @@
+module.exports = {
+  'chunk': require('./array/chunk'),
+  'compact': require('./array/compact'),
+  'difference': require('./array/difference'),
+  'drop': require('./array/drop'),
+  'dropRight': require('./array/dropRight'),
+  'dropRightWhile': require('./array/dropRightWhile'),
+  'dropWhile': require('./array/dropWhile'),
+  'fill': require('./array/fill'),
+  'findIndex': require('./array/findIndex'),
+  'findLastIndex': require('./array/findLastIndex'),
+  'first': require('./array/first'),
+  'flatten': require('./array/flatten'),
+  'flattenDeep': require('./array/flattenDeep'),
+  'head': require('./array/head'),
+  'indexOf': require('./array/indexOf'),
+  'initial': require('./array/initial'),
+  'intersection': require('./array/intersection'),
+  'last': require('./array/last'),
+  'lastIndexOf': require('./array/lastIndexOf'),
+  'object': require('./array/object'),
+  'pull': require('./array/pull'),
+  'pullAt': require('./array/pullAt'),
+  'remove': require('./array/remove'),
+  'rest': require('./array/rest'),
+  'slice': require('./array/slice'),
+  'sortedIndex': require('./array/sortedIndex'),
+  'sortedLastIndex': require('./array/sortedLastIndex'),
+  'tail': require('./array/tail'),
+  'take': require('./array/take'),
+  'takeRight': require('./array/takeRight'),
+  'takeRightWhile': require('./array/takeRightWhile'),
+  'takeWhile': require('./array/takeWhile'),
+  'union': require('./array/union'),
+  'uniq': require('./array/uniq'),
+  'unique': require('./array/unique'),
+  'unzip': require('./array/unzip'),
+  'without': require('./array/without'),
+  'xor': require('./array/xor'),
+  'zip': require('./array/zip'),
+  'zipObject': require('./array/zipObject')
+};

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/chunk.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/chunk.js b/node_modules/archiver/node_modules/lodash/array/chunk.js
new file mode 100644
index 0000000..4de9b39
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/chunk.js
@@ -0,0 +1,47 @@
+var baseSlice = require('../internal/baseSlice'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/** Native method references. */
+var ceil = Math.ceil;
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Creates an array of elements split into groups the length of `size`.
+ * If `collection` can't be split evenly, the final chunk will be the remaining
+ * elements.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to process.
+ * @param {number} [size=1] The length of each chunk.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Array} Returns the new array containing chunks.
+ * @example
+ *
+ * _.chunk(['a', 'b', 'c', 'd'], 2);
+ * // => [['a', 'b'], ['c', 'd']]
+ *
+ * _.chunk(['a', 'b', 'c', 'd'], 3);
+ * // => [['a', 'b', 'c'], ['d']]
+ */
+function chunk(array, size, guard) {
+  if (guard ? isIterateeCall(array, size, guard) : size == null) {
+    size = 1;
+  } else {
+    size = nativeMax(+size || 1, 1);
+  }
+  var index = 0,
+      length = array ? array.length : 0,
+      resIndex = -1,
+      result = Array(ceil(length / size));
+
+  while (index < length) {
+    result[++resIndex] = baseSlice(array, index, (index += size));
+  }
+  return result;
+}
+
+module.exports = chunk;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/compact.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/compact.js b/node_modules/archiver/node_modules/lodash/array/compact.js
new file mode 100644
index 0000000..1dc1c55
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/compact.js
@@ -0,0 +1,30 @@
+/**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are falsey.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+function compact(array) {
+  var index = -1,
+      length = array ? array.length : 0,
+      resIndex = -1,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (value) {
+      result[++resIndex] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = compact;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/difference.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/difference.js b/node_modules/archiver/node_modules/lodash/array/difference.js
new file mode 100644
index 0000000..67ee055
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/difference.js
@@ -0,0 +1,39 @@
+var baseDifference = require('../internal/baseDifference'),
+    baseFlatten = require('../internal/baseFlatten'),
+    isArguments = require('../lang/isArguments'),
+    isArray = require('../lang/isArray');
+
+/**
+ * Creates an array excluding all values of the provided arrays using
+ * `SameValueZero` for equality comparisons.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...Array} [values] The arrays of values to exclude.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.difference([1, 2, 3], [5, 2, 10]);
+ * // => [1, 3]
+ */
+function difference() {
+  var index = -1,
+      length = arguments.length;
+
+  while (++index < length) {
+    var value = arguments[index];
+    if (isArray(value) || isArguments(value)) {
+      break;
+    }
+  }
+  return baseDifference(value, baseFlatten(arguments, false, true, ++index));
+}
+
+module.exports = difference;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/drop.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/drop.js b/node_modules/archiver/node_modules/lodash/array/drop.js
new file mode 100644
index 0000000..039a0b5
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/drop.js
@@ -0,0 +1,39 @@
+var baseSlice = require('../internal/baseSlice'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Creates a slice of `array` with `n` elements dropped from the beginning.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to drop.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.drop([1, 2, 3]);
+ * // => [2, 3]
+ *
+ * _.drop([1, 2, 3], 2);
+ * // => [3]
+ *
+ * _.drop([1, 2, 3], 5);
+ * // => []
+ *
+ * _.drop([1, 2, 3], 0);
+ * // => [1, 2, 3]
+ */
+function drop(array, n, guard) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  if (guard ? isIterateeCall(array, n, guard) : n == null) {
+    n = 1;
+  }
+  return baseSlice(array, n < 0 ? 0 : n);
+}
+
+module.exports = drop;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/dropRight.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/dropRight.js b/node_modules/archiver/node_modules/lodash/array/dropRight.js
new file mode 100644
index 0000000..14b5eb6
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/dropRight.js
@@ -0,0 +1,40 @@
+var baseSlice = require('../internal/baseSlice'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Creates a slice of `array` with `n` elements dropped from the end.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to drop.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.dropRight([1, 2, 3]);
+ * // => [1, 2]
+ *
+ * _.dropRight([1, 2, 3], 2);
+ * // => [1]
+ *
+ * _.dropRight([1, 2, 3], 5);
+ * // => []
+ *
+ * _.dropRight([1, 2, 3], 0);
+ * // => [1, 2, 3]
+ */
+function dropRight(array, n, guard) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  if (guard ? isIterateeCall(array, n, guard) : n == null) {
+    n = 1;
+  }
+  n = length - (+n || 0);
+  return baseSlice(array, 0, n < 0 ? 0 : n);
+}
+
+module.exports = dropRight;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/dropRightWhile.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/dropRightWhile.js b/node_modules/archiver/node_modules/lodash/array/dropRightWhile.js
new file mode 100644
index 0000000..3cb93b7
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/dropRightWhile.js
@@ -0,0 +1,61 @@
+var baseCallback = require('../internal/baseCallback'),
+    baseSlice = require('../internal/baseSlice');
+
+/**
+ * Creates a slice of `array` excluding elements dropped from the end.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * bound to `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that match the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per element.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.dropRightWhile([1, 2, 3], function(n) { return n > 1; });
+ * // => [1]
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': true },
+ *   { 'user': 'fred',    'age': 40, 'active': false },
+ *   { 'user': 'pebbles', 'age': 1,  'active': false }
+ * ];
+ *
+ * // using the "_.matches" callback shorthand
+ * _.pluck(_.dropRightWhile(users, { 'age': 1, 'active': false }), 'user');
+ * // => ['barney', 'fred']
+ *
+ * // using the "_.matchesProperty" callback shorthand
+ * _.pluck(_.dropRightWhile(users, 'active', false), 'user');
+ * // => ['barney']
+ *
+ * // using the "_.property" callback shorthand
+ * _.pluck(_.dropRightWhile(users, 'active'), 'user');
+ * // => ['barney', 'fred', 'pebbles']
+ */
+function dropRightWhile(array, predicate, thisArg) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  predicate = baseCallback(predicate, thisArg, 3);
+  while (length-- && predicate(array[length], length, array)) {}
+  return baseSlice(array, 0, length + 1);
+}
+
+module.exports = dropRightWhile;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/dropWhile.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/dropWhile.js b/node_modules/archiver/node_modules/lodash/array/dropWhile.js
new file mode 100644
index 0000000..6910181
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/dropWhile.js
@@ -0,0 +1,62 @@
+var baseCallback = require('../internal/baseCallback'),
+    baseSlice = require('../internal/baseSlice');
+
+/**
+ * Creates a slice of `array` excluding elements dropped from the beginning.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * bound to `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per element.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.dropWhile([1, 2, 3], function(n) { return n < 3; });
+ * // => [3]
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': false },
+ *   { 'user': 'fred',    'age': 40, 'active': false },
+ *   { 'user': 'pebbles', 'age': 1,  'active': true }
+ * ];
+ *
+ * // using the "_.matches" callback shorthand
+ * _.pluck(_.dropWhile(users, { 'age': 36, 'active': false }), 'user');
+ * // => ['fred', 'pebbles']
+ *
+ * // using the "_.matchesProperty" callback shorthand
+ * _.pluck(_.dropWhile(users, 'active', false), 'user');
+ * // => ['pebbles']
+ *
+ * // using the "_.property" callback shorthand
+ * _.pluck(_.dropWhile(users, 'active'), 'user');
+ * // => ['barney', 'fred', 'pebbles']
+ */
+function dropWhile(array, predicate, thisArg) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  var index = -1;
+  predicate = baseCallback(predicate, thisArg, 3);
+  while (++index < length && predicate(array[index], index, array)) {}
+  return baseSlice(array, index);
+}
+
+module.exports = dropWhile;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/fill.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/fill.js b/node_modules/archiver/node_modules/lodash/array/fill.js
new file mode 100644
index 0000000..3259ff4
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/fill.js
@@ -0,0 +1,29 @@
+var baseFill = require('../internal/baseFill'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Fills elements of `array` with `value` from `start` up to, but not
+ * including, `end`.
+ *
+ * **Note:** This method mutates `array`.
+ *
+ * @private
+ * @param {Array} array The array to fill.
+ * @param {*} value The value to fill `array` with.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns `array`.
+ */
+function fill(array, value, start, end) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
+    start = 0;
+    end = length;
+  }
+  return baseFill(array, value, start, end);
+}
+
+module.exports = fill;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/findIndex.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/findIndex.js b/node_modules/archiver/node_modules/lodash/array/findIndex.js
new file mode 100644
index 0000000..7b19d61
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/findIndex.js
@@ -0,0 +1,63 @@
+var baseCallback = require('../internal/baseCallback');
+
+/**
+ * This method is like `_.find` except that it returns the index of the first
+ * element `predicate` returns truthy for, instead of the element itself.
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per iteration. If a property name or object is provided it is used to
+ *  create a "_.property" or "_.matches" style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': false },
+ *   { 'user': 'fred',    'age': 40, 'active': true },
+ *   { 'user': 'pebbles', 'age': 1,  'active': false }
+ * ];
+ *
+ * _.findIndex(users, function(chr) { return chr.age < 40; });
+ * // => 0
+ *
+ * // using the "_.matches" callback shorthand
+ * _.findIndex(users, { 'age': 40, 'active': true });
+ * // => 1
+ *
+ * // using the "_.matchesProperty" callback shorthand
+ * _.findIndex(users, 'age', 1);
+ * // => 2
+ *
+ * // using the "_.property" callback shorthand
+ * _.findIndex(users, 'active');
+ * // => 1
+ */
+function findIndex(array, predicate, thisArg) {
+  var index = -1,
+      length = array ? array.length : 0;
+
+  predicate = baseCallback(predicate, thisArg, 3);
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+module.exports = findIndex;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/findLastIndex.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/findLastIndex.js b/node_modules/archiver/node_modules/lodash/array/findLastIndex.js
new file mode 100644
index 0000000..ed63709
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/findLastIndex.js
@@ -0,0 +1,61 @@
+var baseCallback = require('../internal/baseCallback');
+
+/**
+ * This method is like `_.findIndex` except that it iterates over elements
+ * of `collection` from right to left.
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to search.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per iteration. If a property name or object is provided it is used to
+ *  create a "_.property" or "_.matches" style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': true },
+ *   { 'user': 'fred',    'age': 40, 'active': false },
+ *   { 'user': 'pebbles', 'age': 1,  'active': false }
+ * ];
+ *
+ * _.findLastIndex(users, function(chr) { return chr.age < 40; });
+ * // => 2
+ *
+ * // using the "_.matches" callback shorthand
+ * _.findLastIndex(users, { 'age': 36, 'active': true });
+ * // => 0
+ *
+ * // using the "_.matchesProperty" callback shorthand
+ * _.findLastIndex(users, 'age', 40);
+ * // => 1
+ *
+ * // using the "_.property" callback shorthand
+ * _.findLastIndex(users, 'active');
+ * // => 0
+ */
+function findLastIndex(array, predicate, thisArg) {
+  var length = array ? array.length : 0;
+  predicate = baseCallback(predicate, thisArg, 3);
+  while (length--) {
+    if (predicate(array[length], length, array)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+module.exports = findLastIndex;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/first.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/first.js b/node_modules/archiver/node_modules/lodash/array/first.js
new file mode 100644
index 0000000..b3b9c79
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/first.js
@@ -0,0 +1,22 @@
+/**
+ * Gets the first element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @alias head
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the first element of `array`.
+ * @example
+ *
+ * _.first([1, 2, 3]);
+ * // => 1
+ *
+ * _.first([]);
+ * // => undefined
+ */
+function first(array) {
+  return array ? array[0] : undefined;
+}
+
+module.exports = first;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/flatten.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/flatten.js b/node_modules/archiver/node_modules/lodash/array/flatten.js
new file mode 100644
index 0000000..c0fabd0
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/flatten.js
@@ -0,0 +1,32 @@
+var baseFlatten = require('../internal/baseFlatten'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Flattens a nested array. If `isDeep` is `true` the array is recursively
+ * flattened, otherwise it is only flattened a single level.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isDeep] Specify a deep flatten.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2], [3, [[4]]]]);
+ * // => [1, 2, 3, [[4]]];
+ *
+ * // using `isDeep`
+ * _.flatten([1, [2], [3, [[4]]]], true);
+ * // => [1, 2, 3, 4];
+ */
+function flatten(array, isDeep, guard) {
+  var length = array ? array.length : 0;
+  if (guard && isIterateeCall(array, isDeep, guard)) {
+    isDeep = false;
+  }
+  return length ? baseFlatten(array, isDeep) : [];
+}
+
+module.exports = flatten;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/flattenDeep.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/flattenDeep.js b/node_modules/archiver/node_modules/lodash/array/flattenDeep.js
new file mode 100644
index 0000000..a38bc70
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/flattenDeep.js
@@ -0,0 +1,21 @@
+var baseFlatten = require('../internal/baseFlatten');
+
+/**
+ * Recursively flattens a nested array.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to recursively flatten.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flattenDeep([1, [2], [3, [[4]]]]);
+ * // => [1, 2, 3, 4];
+ */
+function flattenDeep(array) {
+  var length = array ? array.length : 0;
+  return length ? baseFlatten(array, true) : [];
+}
+
+module.exports = flattenDeep;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/head.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/head.js b/node_modules/archiver/node_modules/lodash/array/head.js
new file mode 100644
index 0000000..1961b08
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/head.js
@@ -0,0 +1 @@
+module.exports = require('./first');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/indexOf.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/indexOf.js b/node_modules/archiver/node_modules/lodash/array/indexOf.js
new file mode 100644
index 0000000..afcdea4
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/indexOf.js
@@ -0,0 +1,55 @@
+var baseIndexOf = require('../internal/baseIndexOf'),
+    binaryIndex = require('../internal/binaryIndex');
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Gets the index at which the first occurrence of `value` is found in `array`
+ * using `SameValueZero` for equality comparisons. If `fromIndex` is negative,
+ * it is used as the offset from the end of `array`. If `array` is sorted
+ * providing `true` for `fromIndex` performs a faster binary search.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {boolean|number} [fromIndex=0] The index to search from or `true`
+ *  to perform a binary search on a sorted array.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 1
+ *
+ * // using `fromIndex`
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 4
+ *
+ * // performing a binary search
+ * _.indexOf([4, 4, 5, 5, 6, 6], 5, true);
+ * // => 2
+ */
+function indexOf(array, value, fromIndex) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return -1;
+  }
+  if (typeof fromIndex == 'number') {
+    fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : (fromIndex || 0);
+  } else if (fromIndex) {
+    var index = binaryIndex(array, value),
+        other = array[index];
+
+    return (value === value ? value === other : other !== other) ? index : -1;
+  }
+  return baseIndexOf(array, value, fromIndex);
+}
+
+module.exports = indexOf;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/initial.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/initial.js b/node_modules/archiver/node_modules/lodash/array/initial.js
new file mode 100644
index 0000000..59b7a7d
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/initial.js
@@ -0,0 +1,20 @@
+var dropRight = require('./dropRight');
+
+/**
+ * Gets all but the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.initial([1, 2, 3]);
+ * // => [1, 2]
+ */
+function initial(array) {
+  return dropRight(array, 1);
+}
+
+module.exports = initial;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/intersection.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/intersection.js b/node_modules/archiver/node_modules/lodash/array/intersection.js
new file mode 100644
index 0000000..9d25fab
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/intersection.js
@@ -0,0 +1,68 @@
+var baseIndexOf = require('../internal/baseIndexOf'),
+    cacheIndexOf = require('../internal/cacheIndexOf'),
+    createCache = require('../internal/createCache'),
+    isArguments = require('../lang/isArguments'),
+    isArray = require('../lang/isArray');
+
+/**
+ * Creates an array of unique values in all provided arrays using `SameValueZero`
+ * for equality comparisons.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of shared values.
+ * @example
+ *
+ * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2]
+ */
+function intersection() {
+  var args = [],
+      argsIndex = -1,
+      argsLength = arguments.length,
+      caches = [],
+      indexOf = baseIndexOf,
+      isCommon = true;
+
+  while (++argsIndex < argsLength) {
+    var value = arguments[argsIndex];
+    if (isArray(value) || isArguments(value)) {
+      args.push(value);
+      caches.push(isCommon && value.length >= 120 && createCache(argsIndex && value));
+    }
+  }
+  argsLength = args.length;
+  var array = args[0],
+      index = -1,
+      length = array ? array.length : 0,
+      result = [],
+      seen = caches[0];
+
+  outer:
+  while (++index < length) {
+    value = array[index];
+    if ((seen ? cacheIndexOf(seen, value) : indexOf(result, value)) < 0) {
+      argsIndex = argsLength;
+      while (--argsIndex) {
+        var cache = caches[argsIndex];
+        if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) {
+          continue outer;
+        }
+      }
+      if (seen) {
+        seen.push(value);
+      }
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+module.exports = intersection;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/last.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/last.js b/node_modules/archiver/node_modules/lodash/array/last.js
new file mode 100644
index 0000000..299af31
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/last.js
@@ -0,0 +1,19 @@
+/**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+function last(array) {
+  var length = array ? array.length : 0;
+  return length ? array[length - 1] : undefined;
+}
+
+module.exports = last;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/lastIndexOf.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/lastIndexOf.js b/node_modules/archiver/node_modules/lodash/array/lastIndexOf.js
new file mode 100644
index 0000000..e8daa53
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/lastIndexOf.js
@@ -0,0 +1,57 @@
+var binaryIndex = require('../internal/binaryIndex'),
+    indexOfNaN = require('../internal/indexOfNaN');
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max,
+    nativeMin = Math.min;
+
+/**
+ * This method is like `_.indexOf` except that it iterates over elements of
+ * `array` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {boolean|number} [fromIndex=array.length-1] The index to search from
+ *  or `true` to perform a binary search on a sorted array.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 4
+ *
+ * // using `fromIndex`
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 1
+ *
+ * // performing a binary search
+ * _.lastIndexOf([4, 4, 5, 5, 6, 6], 5, true);
+ * // => 3
+ */
+function lastIndexOf(array, value, fromIndex) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return -1;
+  }
+  var index = length;
+  if (typeof fromIndex == 'number') {
+    index = (fromIndex < 0 ? nativeMax(length + fromIndex, 0) : nativeMin(fromIndex || 0, length - 1)) + 1;
+  } else if (fromIndex) {
+    index = binaryIndex(array, value, true) - 1;
+    var other = array[index];
+    return (value === value ? value === other : other !== other) ? index : -1;
+  }
+  if (value !== value) {
+    return indexOfNaN(array, index, true);
+  }
+  while (index--) {
+    if (array[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+module.exports = lastIndexOf;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/object.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/object.js b/node_modules/archiver/node_modules/lodash/array/object.js
new file mode 100644
index 0000000..f4a3453
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/object.js
@@ -0,0 +1 @@
+module.exports = require('./zipObject');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/pull.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/pull.js b/node_modules/archiver/node_modules/lodash/array/pull.js
new file mode 100644
index 0000000..70a1181
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/pull.js
@@ -0,0 +1,52 @@
+var baseIndexOf = require('../internal/baseIndexOf');
+
+/** Used for native method references. */
+var arrayProto = Array.prototype;
+
+/** Native method references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes all provided values from `array` using `SameValueZero` for equality
+ * comparisons.
+ *
+ * **Notes:**
+ *  - Unlike `_.without`, this method mutates `array`.
+ *  - `SameValueZero` comparisons are like strict equality comparisons, e.g. `===`,
+ *    except that `NaN` matches `NaN`. See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ *    for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {...*} [values] The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3, 1, 2, 3];
+ * _.pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+function pull() {
+  var array = arguments[0];
+  if (!(array && array.length)) {
+    return array;
+  }
+  var index = 0,
+      indexOf = baseIndexOf,
+      length = arguments.length;
+
+  while (++index < length) {
+    var fromIndex = 0,
+        value = arguments[index];
+
+    while ((fromIndex = indexOf(array, value, fromIndex)) > -1) {
+      splice.call(array, fromIndex, 1);
+    }
+  }
+  return array;
+}
+
+module.exports = pull;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/pullAt.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/pullAt.js b/node_modules/archiver/node_modules/lodash/array/pullAt.js
new file mode 100644
index 0000000..01ca5d1
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/pullAt.js
@@ -0,0 +1,33 @@
+var baseFlatten = require('../internal/baseFlatten'),
+    basePullAt = require('../internal/basePullAt');
+
+/**
+ * Removes elements from `array` corresponding to the given indexes and returns
+ * an array of the removed elements. Indexes may be specified as an array of
+ * indexes or as individual arguments.
+ *
+ * **Note:** Unlike `_.at`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {...(number|number[])} [indexes] The indexes of elements to remove,
+ *  specified as individual indexes or arrays of indexes.
+ * @returns {Array} Returns the new array of removed elements.
+ * @example
+ *
+ * var array = [5, 10, 15, 20];
+ * var evens = _.pullAt(array, [1, 3]);
+ *
+ * console.log(array);
+ * // => [5, 15]
+ *
+ * console.log(evens);
+ * // => [10, 20]
+ */
+function pullAt(array) {
+  return basePullAt(array || [], baseFlatten(arguments, false, false, 1));
+}
+
+module.exports = pullAt;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/remove.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/remove.js b/node_modules/archiver/node_modules/lodash/array/remove.js
new file mode 100644
index 0000000..1257565
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/remove.js
@@ -0,0 +1,64 @@
+var baseCallback = require('../internal/baseCallback');
+
+/** Used for native method references. */
+var arrayProto = Array.prototype;
+
+/** Native method references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes all elements from `array` that `predicate` returns truthy for
+ * and returns an array of the removed elements. The predicate is bound to
+ * `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * **Note:** Unlike `_.filter`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per iteration. If a property name or object is provided it is used to
+ *  create a "_.property" or "_.matches" style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {Array} Returns the new array of removed elements.
+ * @example
+ *
+ * var array = [1, 2, 3, 4];
+ * var evens = _.remove(array, function(n) { return n % 2 == 0; });
+ *
+ * console.log(array);
+ * // => [1, 3]
+ *
+ * console.log(evens);
+ * // => [2, 4]
+ */
+function remove(array, predicate, thisArg) {
+  var index = -1,
+      length = array ? array.length : 0,
+      result = [];
+
+  predicate = baseCallback(predicate, thisArg, 3);
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result.push(value);
+      splice.call(array, index--, 1);
+      length--;
+    }
+  }
+  return result;
+}
+
+module.exports = remove;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/rest.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/rest.js b/node_modules/archiver/node_modules/lodash/array/rest.js
new file mode 100644
index 0000000..9bfb734
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/rest.js
@@ -0,0 +1,21 @@
+var drop = require('./drop');
+
+/**
+ * Gets all but the first element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @alias tail
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.rest([1, 2, 3]);
+ * // => [2, 3]
+ */
+function rest(array) {
+  return drop(array, 1);
+}
+
+module.exports = rest;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/slice.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/slice.js b/node_modules/archiver/node_modules/lodash/array/slice.js
new file mode 100644
index 0000000..ee6fb73
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/slice.js
@@ -0,0 +1,30 @@
+var baseSlice = require('../internal/baseSlice'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Creates a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * **Note:** This function is used instead of `Array#slice` to support node
+ * lists in IE < 9 and to ensure dense arrays are returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+function slice(array, start, end) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
+    start = 0;
+    end = length;
+  }
+  return baseSlice(array, start, end);
+}
+
+module.exports = slice;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/sortedIndex.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/sortedIndex.js b/node_modules/archiver/node_modules/lodash/array/sortedIndex.js
new file mode 100644
index 0000000..75e9f82
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/sortedIndex.js
@@ -0,0 +1,60 @@
+var baseCallback = require('../internal/baseCallback'),
+    binaryIndex = require('../internal/binaryIndex'),
+    binaryIndexBy = require('../internal/binaryIndexBy');
+
+/**
+ * Uses a binary search to determine the lowest index at which `value` should
+ * be inserted into `array` in order to maintain its sort order. If an iteratee
+ * function is provided it is invoked for `value` and each element of `array`
+ * to compute their sort ranking. The iteratee is bound to `thisArg` and
+ * invoked with one argument; (value).
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+ *  per iteration. If a property name or object is provided it is used to
+ *  create a "_.property" or "_.matches" style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ *
+ * _.sortedIndex([30, 50], 40);
+ * // => 1
+ *
+ * _.sortedIndex([4, 4, 5, 5, 6, 6], 5);
+ * // => 2
+ *
+ * var dict = { 'data': { 'thirty': 30, 'forty': 40, 'fifty': 50 } };
+ *
+ * // using an iteratee function
+ * _.sortedIndex(['thirty', 'fifty'], 'forty', function(word) {
+ *   return this.data[word];
+ * }, dict);
+ * // => 1
+ *
+ * // using the "_.property" callback shorthand
+ * _.sortedIndex([{ 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+ * // => 1
+ */
+function sortedIndex(array, value, iteratee, thisArg) {
+  return iteratee == null
+    ? binaryIndex(array, value)
+    : binaryIndexBy(array, value, baseCallback(iteratee, thisArg, 1));
+}
+
+module.exports = sortedIndex;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/sortedLastIndex.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/sortedLastIndex.js b/node_modules/archiver/node_modules/lodash/array/sortedLastIndex.js
new file mode 100644
index 0000000..806713a
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/sortedLastIndex.js
@@ -0,0 +1,32 @@
+var baseCallback = require('../internal/baseCallback'),
+    binaryIndex = require('../internal/binaryIndex'),
+    binaryIndexBy = require('../internal/binaryIndexBy');
+
+/**
+ * This method is like `_.sortedIndex` except that it returns the highest
+ * index at which `value` should be inserted into `array` in order to
+ * maintain its sort order.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+ *  per iteration. If a property name or object is provided it is used to
+ *  create a "_.property" or "_.matches" style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ *
+ * _.sortedLastIndex([4, 4, 5, 5, 6, 6], 5);
+ * // => 4
+ */
+function sortedLastIndex(array, value, iteratee, thisArg) {
+  return iteratee == null
+    ? binaryIndex(array, value, true)
+    : binaryIndexBy(array, value, baseCallback(iteratee, thisArg, 1), true);
+}
+
+module.exports = sortedLastIndex;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/tail.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/tail.js b/node_modules/archiver/node_modules/lodash/array/tail.js
new file mode 100644
index 0000000..c5dfe77
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/tail.js
@@ -0,0 +1 @@
+module.exports = require('./rest');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/take.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/take.js b/node_modules/archiver/node_modules/lodash/array/take.js
new file mode 100644
index 0000000..875917a
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/take.js
@@ -0,0 +1,39 @@
+var baseSlice = require('../internal/baseSlice'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Creates a slice of `array` with `n` elements taken from the beginning.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to take.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.take([1, 2, 3]);
+ * // => [1]
+ *
+ * _.take([1, 2, 3], 2);
+ * // => [1, 2]
+ *
+ * _.take([1, 2, 3], 5);
+ * // => [1, 2, 3]
+ *
+ * _.take([1, 2, 3], 0);
+ * // => []
+ */
+function take(array, n, guard) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  if (guard ? isIterateeCall(array, n, guard) : n == null) {
+    n = 1;
+  }
+  return baseSlice(array, 0, n < 0 ? 0 : n);
+}
+
+module.exports = take;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/takeRight.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/takeRight.js b/node_modules/archiver/node_modules/lodash/array/takeRight.js
new file mode 100644
index 0000000..6e89c87
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/takeRight.js
@@ -0,0 +1,40 @@
+var baseSlice = require('../internal/baseSlice'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Creates a slice of `array` with `n` elements taken from the end.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to take.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.takeRight([1, 2, 3]);
+ * // => [3]
+ *
+ * _.takeRight([1, 2, 3], 2);
+ * // => [2, 3]
+ *
+ * _.takeRight([1, 2, 3], 5);
+ * // => [1, 2, 3]
+ *
+ * _.takeRight([1, 2, 3], 0);
+ * // => []
+ */
+function takeRight(array, n, guard) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  if (guard ? isIterateeCall(array, n, guard) : n == null) {
+    n = 1;
+  }
+  n = length - (+n || 0);
+  return baseSlice(array, n < 0 ? 0 : n);
+}
+
+module.exports = takeRight;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/takeRightWhile.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/takeRightWhile.js b/node_modules/archiver/node_modules/lodash/array/takeRightWhile.js
new file mode 100644
index 0000000..3764543
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/takeRightWhile.js
@@ -0,0 +1,61 @@
+var baseCallback = require('../internal/baseCallback'),
+    baseSlice = require('../internal/baseSlice');
+
+/**
+ * Creates a slice of `array` with elements taken from the end. Elements are
+ * taken until `predicate` returns falsey. The predicate is bound to `thisArg`
+ * and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per element.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.takeRightWhile([1, 2, 3], function(n) { return n > 1; });
+ * // => [2, 3]
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': true },
+ *   { 'user': 'fred',    'age': 40, 'active': false },
+ *   { 'user': 'pebbles', 'age': 1,  'active': false }
+ * ];
+ *
+ * // using the "_.matches" callback shorthand
+ * _.pluck(_.takeRightWhile(users, { 'age': 1, 'active': true }), 'user');
+ * // => ['pebbles']
+ *
+ * // using the "_.matchesProperty" callback shorthand
+ * _.pluck(_.takeRightWhile(users, 'active', false), 'user');
+ * // => ['fred', 'pebbles']
+ *
+ * // using the "_.property" callback shorthand
+ * _.pluck(_.takeRightWhile(users, 'active'), 'user');
+ * // => []
+ */
+function takeRightWhile(array, predicate, thisArg) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  predicate = baseCallback(predicate, thisArg, 3);
+  while (length-- && predicate(array[length], length, array)) {}
+  return baseSlice(array, length + 1);
+}
+
+module.exports = takeRightWhile;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/takeWhile.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/takeWhile.js b/node_modules/archiver/node_modules/lodash/array/takeWhile.js
new file mode 100644
index 0000000..403fa73
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/takeWhile.js
@@ -0,0 +1,62 @@
+var baseCallback = require('../internal/baseCallback'),
+    baseSlice = require('../internal/baseSlice');
+
+/**
+ * Creates a slice of `array` with elements taken from the beginning. Elements
+ * are taken until `predicate` returns falsey. The predicate is bound to
+ * `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per element.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.takeWhile([1, 2, 3], function(n) { return n < 3; });
+ * // => [1, 2]
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': false },
+ *   { 'user': 'fred',    'age': 40, 'active': false },
+ *   { 'user': 'pebbles', 'age': 1,  'active': true }
+ * ];
+ *
+ * // using the "_.matches" callback shorthand
+ * _.pluck(_.takeWhile(users, { 'age': 36, 'active': true }), 'user');
+ * // => ['barney']
+ *
+ * // using the "_.matchesProperty" callback shorthand
+ * _.pluck(_.takeWhile(users, 'active', false), 'user');
+ * // => ['barney', 'fred']
+ *
+ * // using the "_.property" callback shorthand
+ * _.pluck(_.takeWhile(users, 'active'), 'user');
+ * // => []
+ */
+function takeWhile(array, predicate, thisArg) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  var index = -1;
+  predicate = baseCallback(predicate, thisArg, 3);
+  while (++index < length && predicate(array[index], index, array)) {}
+  return baseSlice(array, 0, index);
+}
+
+module.exports = takeWhile;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/union.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/union.js b/node_modules/archiver/node_modules/lodash/array/union.js
new file mode 100644
index 0000000..ff9e377
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/union.js
@@ -0,0 +1,27 @@
+var baseFlatten = require('../internal/baseFlatten'),
+    baseUniq = require('../internal/baseUniq');
+
+/**
+ * Creates an array of unique values, in order, of the provided arrays using
+ * `SameValueZero` for equality comparisons.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]);
+ * // => [1, 2, 3, 5, 4]
+ */
+function union() {
+  return baseUniq(baseFlatten(arguments, false, true));
+}
+
+module.exports = union;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/uniq.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/uniq.js b/node_modules/archiver/node_modules/lodash/array/uniq.js
new file mode 100644
index 0000000..0d51f0e
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/uniq.js
@@ -0,0 +1,75 @@
+var baseCallback = require('../internal/baseCallback'),
+    baseUniq = require('../internal/baseUniq'),
+    isIterateeCall = require('../internal/isIterateeCall'),
+    sortedUniq = require('../internal/sortedUniq');
+
+/**
+ * Creates a duplicate-value-free version of an array using `SameValueZero`
+ * for equality comparisons. Providing `true` for `isSorted` performs a faster
+ * search algorithm for sorted arrays. If an iteratee function is provided it
+ * is invoked for each value in the array to generate the criterion by which
+ * uniqueness is computed. The `iteratee` is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `predicate` the created "_.property"
+ * style callback returns the property value of the given element.
+ *
+ * If value is also provided for `thisArg` the created "_.matchesProperty"
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created "_.matches" style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @alias unique
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {boolean} [isSorted] Specify the array is sorted.
+ * @param {Function|Object|string} [iteratee] The function invoked per iteration.
+ *  If a property name or object is provided it is used to create a "_.property"
+ *  or "_.matches" style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Array} Returns the new duplicate-value-free array.
+ * @example
+ *
+ * _.uniq([1, 2, 1]);
+ * // => [1, 2]
+ *
+ * // using `isSorted`
+ * _.uniq([1, 1, 2], true);
+ * // => [1, 2]
+ *
+ * // using an iteratee function
+ * _.uniq([1, 2.5, 1.5, 2], function(n) { return this.floor(n); }, Math);
+ * // => [1, 2.5]
+ *
+ * // using the "_.property" callback shorthand
+ * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+function uniq(array, isSorted, iteratee, thisArg) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  // Juggle arguments.
+  if (typeof isSorted != 'boolean' && isSorted != null) {
+    thisArg = iteratee;
+    iteratee = isIterateeCall(array, isSorted, thisArg) ? null : isSorted;
+    isSorted = false;
+  }
+  iteratee = iteratee == null ? iteratee : baseCallback(iteratee, thisArg, 3);
+  return (isSorted)
+    ? sortedUniq(array, iteratee)
+    : baseUniq(array, iteratee);
+}
+
+module.exports = uniq;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/unique.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/unique.js b/node_modules/archiver/node_modules/lodash/array/unique.js
new file mode 100644
index 0000000..396de1b
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/unique.js
@@ -0,0 +1 @@
+module.exports = require('./uniq');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/unzip.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/unzip.js b/node_modules/archiver/node_modules/lodash/array/unzip.js
new file mode 100644
index 0000000..f7f8558
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/unzip.js
@@ -0,0 +1,37 @@
+var arrayMap = require('../internal/arrayMap'),
+    arrayMax = require('../internal/arrayMax'),
+    baseProperty = require('../internal/baseProperty');
+
+/** Used to the length of n-tuples for `_.unzip`. */
+var getLength = baseProperty('length');
+
+/**
+ * This method is like `_.zip` except that it accepts an array of grouped
+ * elements and creates an array regrouping the elements to their pre-`_.zip`
+ * configuration.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array of grouped elements to process.
+ * @returns {Array} Returns the new array of regrouped elements.
+ * @example
+ *
+ * var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
+ * // => [['fred', 30, true], ['barney', 40, false]]
+ *
+ * _.unzip(zipped);
+ * // => [['fred', 'barney'], [30, 40], [true, false]]
+ */
+function unzip(array) {
+  var index = -1,
+      length = (array && array.length && arrayMax(arrayMap(array, getLength))) >>> 0,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = arrayMap(array, baseProperty(index));
+  }
+  return result;
+}
+
+module.exports = unzip;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/without.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/without.js b/node_modules/archiver/node_modules/lodash/array/without.js
new file mode 100644
index 0000000..d335688
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/without.js
@@ -0,0 +1,28 @@
+var baseDifference = require('../internal/baseDifference'),
+    baseSlice = require('../internal/baseSlice');
+
+/**
+ * Creates an array excluding all provided values using `SameValueZero` for
+ * equality comparisons.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to filter.
+ * @param {...*} [values] The values to exclude.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+ * // => [2, 3, 4]
+ */
+function without(array) {
+  return baseDifference(array, baseSlice(arguments, 1));
+}
+
+module.exports = without;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/xor.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/xor.js b/node_modules/archiver/node_modules/lodash/array/xor.js
new file mode 100644
index 0000000..a1f3179
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/xor.js
@@ -0,0 +1,39 @@
+var baseDifference = require('../internal/baseDifference'),
+    baseUniq = require('../internal/baseUniq'),
+    isArguments = require('../lang/isArguments'),
+    isArray = require('../lang/isArray');
+
+/**
+ * Creates an array that is the symmetric difference of the provided arrays.
+ * See [Wikipedia](https://en.wikipedia.org/wiki/Symmetric_difference) for
+ * more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of values.
+ * @example
+ *
+ * _.xor([1, 2, 3], [5, 2, 1, 4]);
+ * // => [3, 5, 4]
+ *
+ * _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]);
+ * // => [1, 4, 5]
+ */
+function xor() {
+  var index = -1,
+      length = arguments.length;
+
+  while (++index < length) {
+    var array = arguments[index];
+    if (isArray(array) || isArguments(array)) {
+      var result = result
+        ? baseDifference(result, array).concat(baseDifference(array, result))
+        : array;
+    }
+  }
+  return result ? baseUniq(result) : [];
+}
+
+module.exports = xor;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/zip.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/zip.js b/node_modules/archiver/node_modules/lodash/array/zip.js
new file mode 100644
index 0000000..039bac0
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/zip.js
@@ -0,0 +1,28 @@
+var unzip = require('./unzip');
+
+/**
+ * Creates an array of grouped elements, the first of which contains the first
+ * elements of the given arrays, the second of which contains the second elements
+ * of the given arrays, and so on.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to process.
+ * @returns {Array} Returns the new array of grouped elements.
+ * @example
+ *
+ * _.zip(['fred', 'barney'], [30, 40], [true, false]);
+ * // => [['fred', 30, true], ['barney', 40, false]]
+ */
+function zip() {
+  var length = arguments.length,
+      array = Array(length);
+
+  while (length--) {
+    array[length] = arguments[length];
+  }
+  return unzip(array);
+}
+
+module.exports = zip;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/array/zipObject.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/array/zipObject.js b/node_modules/archiver/node_modules/lodash/array/zipObject.js
new file mode 100644
index 0000000..bc3f952
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/array/zipObject.js
@@ -0,0 +1,39 @@
+var isArray = require('../lang/isArray');
+
+/**
+ * Creates an object composed from arrays of property names and values. Provide
+ * either a single two dimensional array, e.g. `[[key1, value1], [key2, value2]]`
+ * or two arrays, one of property names and one of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @alias object
+ * @category Array
+ * @param {Array} props The property names.
+ * @param {Array} [values=[]] The property values.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.zipObject(['fred', 'barney'], [30, 40]);
+ * // => { 'fred': 30, 'barney': 40 }
+ */
+function zipObject(props, values) {
+  var index = -1,
+      length = props ? props.length : 0,
+      result = {};
+
+  if (length && !values && !isArray(props[0])) {
+    values = [];
+  }
+  while (++index < length) {
+    var key = props[index];
+    if (values) {
+      result[key] = values[index];
+    } else if (key) {
+      result[key[0]] = key[1];
+    }
+  }
+  return result;
+}
+
+module.exports = zipObject;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain.js b/node_modules/archiver/node_modules/lodash/chain.js
new file mode 100644
index 0000000..7992b73
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain.js
@@ -0,0 +1,15 @@
+module.exports = {
+  'chain': require('./chain/chain'),
+  'commit': require('./chain/commit'),
+  'lodash': require('./chain/lodash'),
+  'plant': require('./chain/plant'),
+  'reverse': require('./chain/reverse'),
+  'run': require('./chain/run'),
+  'tap': require('./chain/tap'),
+  'thru': require('./chain/thru'),
+  'toJSON': require('./chain/toJSON'),
+  'toString': require('./chain/toString'),
+  'value': require('./chain/value'),
+  'valueOf': require('./chain/valueOf'),
+  'wrapperChain': require('./chain/wrapperChain')
+};

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain/chain.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain/chain.js b/node_modules/archiver/node_modules/lodash/chain/chain.js
new file mode 100644
index 0000000..36cc3d3
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain/chain.js
@@ -0,0 +1,33 @@
+var lodash = require('./lodash');
+
+/**
+ * Creates a `lodash` object that wraps `value` with explicit method
+ * chaining enabled.
+ *
+ * @static
+ * @memberOf _
+ * @category Chain
+ * @param {*} value The value to wrap.
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36 },
+ *   { 'user': 'fred',    'age': 40 },
+ *   { 'user': 'pebbles', 'age': 1 }
+ * ];
+ *
+ * var youngest = _.chain(users)
+ *   .sortBy('age')
+ *   .map(function(chr) { return chr.user + ' is ' + chr.age; })
+ *   .first()
+ *   .value();
+ * // => 'pebbles is 1'
+ */
+function chain(value) {
+  var result = lodash(value);
+  result.__chain__ = true;
+  return result;
+}
+
+module.exports = chain;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain/commit.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain/commit.js b/node_modules/archiver/node_modules/lodash/chain/commit.js
new file mode 100644
index 0000000..c732d1b
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain/commit.js
@@ -0,0 +1 @@
+module.exports = require('./wrapperCommit');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain/lodash.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain/lodash.js b/node_modules/archiver/node_modules/lodash/chain/lodash.js
new file mode 100644
index 0000000..a60b5c0
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain/lodash.js
@@ -0,0 +1,109 @@
+var LazyWrapper = require('../internal/LazyWrapper'),
+    LodashWrapper = require('../internal/LodashWrapper'),
+    isArray = require('../lang/isArray'),
+    isObjectLike = require('../internal/isObjectLike'),
+    wrapperClone = require('../internal/wrapperClone');
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates a `lodash` object which wraps `value` to enable implicit chaining.
+ * Methods that operate on and return arrays, collections, and functions can
+ * be chained together. Methods that return a boolean or single value will
+ * automatically end the chain returning the unwrapped value. Explicit chaining
+ * may be enabled using `_.chain`. The execution of chained methods is lazy,
+ * that is, execution is deferred until `_#value` is implicitly or explicitly
+ * called.
+ *
+ * Lazy evaluation allows several methods to support shortcut fusion. Shortcut
+ * fusion is an optimization that merges iteratees to avoid creating intermediate
+ * arrays and reduce the number of iteratee executions.
+ *
+ * Chaining is supported in custom builds as long as the `_#value` method is
+ * directly or indirectly included in the build.
+ *
+ * In addition to lodash methods, wrappers also have the following `Array` methods:
+ * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,
+ * and `unshift`
+ *
+ * The wrapper methods that support shortcut fusion are:
+ * `compact`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `filter`,
+ * `first`, `initial`, `last`, `map`, `pluck`, `reject`, `rest`, `reverse`,
+ * `slice`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `toArray`,
+ * and `where`
+ *
+ * The chainable wrapper methods are:
+ * `after`, `ary`, `assign`, `at`, `before`, `bind`, `bindAll`, `bindKey`,
+ * `callback`, `chain`, `chunk`, `commit`, `compact`, `concat`, `constant`,
+ * `countBy`, `create`, `curry`, `debounce`, `defaults`, `defer`, `delay`,
+ * `difference`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `fill`,
+ * `filter`, `flatten`, `flattenDeep`, `flow`, `flowRight`, `forEach`,
+ * `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `functions`,
+ * `groupBy`, `indexBy`, `initial`, `intersection`, `invert`, `invoke`, `keys`,
+ * `keysIn`, `map`, `mapValues`, `matches`, `memoize`, `merge`, `mixin`,
+ * `negate`, `noop`, `omit`, `once`, `pairs`, `partial`, `partialRight`,
+ * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`,
+ * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `reverse`,
+ * `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`, `splice`, `spread`,
+ * `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `tap`, `throttle`,
+ * `thru`, `times`, `toArray`, `toPlainObject`, `transform`, `union`, `uniq`,
+ * `unshift`, `unzip`, `values`, `valuesIn`, `where`, `without`, `wrap`, `xor`,
+ * `zip`, and `zipObject`
+ *
+ * The wrapper methods that are **not** chainable by default are:
+ * `attempt`, `camelCase`, `capitalize`, `clone`, `cloneDeep`, `deburr`,
+ * `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`,
+ * `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`, `has`,
+ * `identity`, `includes`, `indexOf`, `isArguments`, `isArray`, `isBoolean`,
+ * `isDate`, `isElement`, `isEmpty`, `isEqual`, `isError`, `isFinite`,
+ * `isFunction`, `isMatch`, `isNative`, `isNaN`, `isNull`, `isNumber`,
+ * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`,
+ * `isTypedArray`, `join`, `kebabCase`, `last`, `lastIndexOf`, `max`, `min`,
+ * `noConflict`, `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`,
+ * `random`, `reduce`, `reduceRight`, `repeat`, `result`, `runInContext`,
+ * `shift`, `size`, `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`,
+ * `startCase`, `startsWith`, `template`, `trim`, `trimLeft`, `trimRight`,
+ * `trunc`, `unescape`, `uniqueId`, `value`, and `words`
+ *
+ * The wrapper method `sample` will return a wrapped value when `n` is provided,
+ * otherwise an unwrapped value is returned.
+ *
+ * @name _
+ * @constructor
+ * @category Chain
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var wrapped = _([1, 2, 3]);
+ *
+ * // returns an unwrapped value
+ * wrapped.reduce(function(sum, n) { return sum + n; });
+ * // => 6
+ *
+ * // returns a wrapped value
+ * var squares = wrapped.map(function(n) { return n * n; });
+ *
+ * _.isArray(squares);
+ * // => false
+ *
+ * _.isArray(squares.value());
+ * // => true
+ */
+function lodash(value) {
+  if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
+    if (value instanceof LodashWrapper) {
+      return value;
+    }
+    if (hasOwnProperty.call(value, '__chain__') && hasOwnProperty.call(value, '__wrapped__')) {
+      return wrapperClone(value);
+    }
+  }
+  return new LodashWrapper(value);
+}
+
+module.exports = lodash;

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain/plant.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain/plant.js b/node_modules/archiver/node_modules/lodash/chain/plant.js
new file mode 100644
index 0000000..04099f2
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain/plant.js
@@ -0,0 +1 @@
+module.exports = require('./wrapperPlant');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain/reverse.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain/reverse.js b/node_modules/archiver/node_modules/lodash/chain/reverse.js
new file mode 100644
index 0000000..f72a64a
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain/reverse.js
@@ -0,0 +1 @@
+module.exports = require('./wrapperReverse');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain/run.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain/run.js b/node_modules/archiver/node_modules/lodash/chain/run.js
new file mode 100644
index 0000000..5e751a2
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain/run.js
@@ -0,0 +1 @@
+module.exports = require('./wrapperValue');

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/bd21ce3b/node_modules/archiver/node_modules/lodash/chain/tap.js
----------------------------------------------------------------------
diff --git a/node_modules/archiver/node_modules/lodash/chain/tap.js b/node_modules/archiver/node_modules/lodash/chain/tap.js
new file mode 100644
index 0000000..c413785
--- /dev/null
+++ b/node_modules/archiver/node_modules/lodash/chain/tap.js
@@ -0,0 +1,27 @@
+/**
+ * This method invokes `interceptor` and returns `value`. The interceptor is
+ * bound to `thisArg` and invoked with one argument; (value). The purpose of
+ * this method is to "tap into" a method chain in order to perform operations
+ * on intermediate results within the chain.
+ *
+ * @static
+ * @memberOf _
+ * @category Chain
+ * @param {*} value The value to provide to `interceptor`.
+ * @param {Function} interceptor The function to invoke.
+ * @param {*} [thisArg] The `this` binding of `interceptor`.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * _([1, 2, 3])
+ *  .tap(function(array) { array.pop(); })
+ *  .reverse()
+ *  .value();
+ * // => [2, 1]
+ */
+function tap(value, interceptor, thisArg) {
+  interceptor.call(thisArg, value);
+  return value;
+}
+
+module.exports = tap;


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


Mime
View raw message