ui

app/code/node_modules/collect.js/dist/helpers/clone.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Clone helper
+ *
+ * Clone an array or object
+ *
+ * @param items
+ * @returns {*}
+ */
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+module.exports = function clone(items) {
+  var cloned = void 0;
+
+  if (Array.isArray(items)) {
+    var _cloned;
+
+    cloned = [];
+
+    (_cloned = cloned).push.apply(_cloned, _toConsumableArray(items));
+  } else {
+    cloned = {};
+
+    Object.keys(items).forEach(function (prop) {
+      cloned[prop] = items[prop];
+    });
+  }
+
+  return cloned;
+};

app/code/node_modules/collect.js/dist/helpers/deleteKeys.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var variadic = require('./variadic');
+
+/**
+ * Delete keys helper
+ *
+ * Delete one or multiple keys from an object
+ *
+ * @param obj
+ * @param keys
+ * @returns {void}
+ */
+module.exports = function deleteKeys(obj) {
+  for (var _len = arguments.length, keys = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    keys[_key - 1] = arguments[_key];
+  }
+
+  variadic(keys).forEach(function (key) {
+    // eslint-disable-next-line
+    delete obj[key];
+  });
+};

app/code/node_modules/collect.js/dist/helpers/is.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+module.exports = {
+  /**
+   * @returns {boolean}
+   */
+  isArray: function isArray(item) {
+    return Array.isArray(item);
+  },
+
+  /**
+   * @returns {boolean}
+   */
+  isObject: function isObject(item) {
+    return (typeof item === 'undefined' ? 'undefined' : _typeof(item)) === 'object' && Array.isArray(item) === false && item !== null;
+  },
+
+  /**
+   * @returns {boolean}
+   */
+  isFunction: function isFunction(item) {
+    return typeof item === 'function';
+  }
+};

app/code/node_modules/collect.js/dist/helpers/nestedValue.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * Get value of a nested property
+ *
+ * @param mainObject
+ * @param key
+ * @returns {*}
+ */
+
+module.exports = function nestedValue(mainObject, key) {
+  try {
+    return key.split('.').reduce(function (obj, property) {
+      return obj[property];
+    }, mainObject);
+  } catch (err) {
+    // If we end up here, we're not working with an object, and @var mainObject is the value itself
+    return mainObject;
+  }
+};

app/code/node_modules/collect.js/dist/helpers/values.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * Values helper
+ *
+ * Retrieve values from [this.items] when it is an array, object or Collection
+ *
+ * @param items
+ * @returns {*}
+ */
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+module.exports = function values(items) {
+  var valuesArray = [];
+
+  if (Array.isArray(items)) {
+    valuesArray.push.apply(valuesArray, _toConsumableArray(items));
+  } else if (items.constructor.name === 'Collection') {
+    valuesArray.push.apply(valuesArray, _toConsumableArray(items.all()));
+  } else {
+    Object.keys(items).forEach(function (prop) {
+      return valuesArray.push(items[prop]);
+    });
+  }
+
+  return valuesArray;
+};

app/code/node_modules/collect.js/dist/helpers/variadic.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Variadic helper function
+ *
+ * @param args
+ * @returns {Array}
+ */
+
+module.exports = function variadic(args) {
+  if (Array.isArray(args[0])) {
+    return args[0];
+  }
+
+  return args;
+};

app/code/node_modules/collect.js/dist/index.js

@@ -0,0 +1,161 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+function Collection(collection) {
+  if (collection !== undefined && !Array.isArray(collection) && (typeof collection === 'undefined' ? 'undefined' : _typeof(collection)) !== 'object') {
+    this.items = [collection];
+  } else if (collection instanceof this.constructor) {
+    this.items = collection.all();
+  } else {
+    this.items = collection || [];
+  }
+}
+
+/**
+ * Symbol.iterator
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator
+ */
+var SymbolIterator = require('./methods/symbol.iterator');
+
+if (typeof Symbol !== 'undefined') {
+  Collection.prototype[Symbol.iterator] = SymbolIterator;
+}
+
+/**
+ * Support JSON.stringify
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+ */
+Collection.prototype.toJSON = function toJSON() {
+  return this.items;
+};
+
+Collection.prototype.all = require('./methods/all');
+Collection.prototype.average = require('./methods/average');
+Collection.prototype.avg = require('./methods/avg');
+Collection.prototype.chunk = require('./methods/chunk');
+Collection.prototype.collapse = require('./methods/collapse');
+Collection.prototype.combine = require('./methods/combine');
+Collection.prototype.concat = require('./methods/concat');
+Collection.prototype.contains = require('./methods/contains');
+Collection.prototype.count = require('./methods/count');
+Collection.prototype.countBy = require('./methods/countBy');
+Collection.prototype.crossJoin = require('./methods/crossJoin');
+Collection.prototype.dd = require('./methods/dd');
+Collection.prototype.diff = require('./methods/diff');
+Collection.prototype.diffAssoc = require('./methods/diffAssoc');
+Collection.prototype.diffKeys = require('./methods/diffKeys');
+Collection.prototype.doesntContain = require('./methods/doesntContain');
+Collection.prototype.dump = require('./methods/dump');
+Collection.prototype.duplicates = require('./methods/duplicates');
+Collection.prototype.each = require('./methods/each');
+Collection.prototype.eachSpread = require('./methods/eachSpread');
+Collection.prototype.every = require('./methods/every');
+Collection.prototype.except = require('./methods/except');
+Collection.prototype.filter = require('./methods/filter');
+Collection.prototype.first = require('./methods/first');
+Collection.prototype.firstOrFail = require('./methods/firstOrFail');
+Collection.prototype.firstWhere = require('./methods/firstWhere');
+Collection.prototype.flatMap = require('./methods/flatMap');
+Collection.prototype.flatten = require('./methods/flatten');
+Collection.prototype.flip = require('./methods/flip');
+Collection.prototype.forPage = require('./methods/forPage');
+Collection.prototype.forget = require('./methods/forget');
+Collection.prototype.get = require('./methods/get');
+Collection.prototype.groupBy = require('./methods/groupBy');
+Collection.prototype.has = require('./methods/has');
+Collection.prototype.implode = require('./methods/implode');
+Collection.prototype.intersect = require('./methods/intersect');
+Collection.prototype.intersectByKeys = require('./methods/intersectByKeys');
+Collection.prototype.isEmpty = require('./methods/isEmpty');
+Collection.prototype.isNotEmpty = require('./methods/isNotEmpty');
+Collection.prototype.join = require('./methods/join');
+Collection.prototype.keyBy = require('./methods/keyBy');
+Collection.prototype.keys = require('./methods/keys');
+Collection.prototype.last = require('./methods/last');
+Collection.prototype.macro = require('./methods/macro');
+Collection.prototype.make = require('./methods/make');
+Collection.prototype.map = require('./methods/map');
+Collection.prototype.mapSpread = require('./methods/mapSpread');
+Collection.prototype.mapToDictionary = require('./methods/mapToDictionary');
+Collection.prototype.mapInto = require('./methods/mapInto');
+Collection.prototype.mapToGroups = require('./methods/mapToGroups');
+Collection.prototype.mapWithKeys = require('./methods/mapWithKeys');
+Collection.prototype.max = require('./methods/max');
+Collection.prototype.median = require('./methods/median');
+Collection.prototype.merge = require('./methods/merge');
+Collection.prototype.mergeRecursive = require('./methods/mergeRecursive');
+Collection.prototype.min = require('./methods/min');
+Collection.prototype.mode = require('./methods/mode');
+Collection.prototype.nth = require('./methods/nth');
+Collection.prototype.only = require('./methods/only');
+Collection.prototype.pad = require('./methods/pad');
+Collection.prototype.partition = require('./methods/partition');
+Collection.prototype.pipe = require('./methods/pipe');
+Collection.prototype.pluck = require('./methods/pluck');
+Collection.prototype.pop = require('./methods/pop');
+Collection.prototype.prepend = require('./methods/prepend');
+Collection.prototype.pull = require('./methods/pull');
+Collection.prototype.push = require('./methods/push');
+Collection.prototype.put = require('./methods/put');
+Collection.prototype.random = require('./methods/random');
+Collection.prototype.reduce = require('./methods/reduce');
+Collection.prototype.reject = require('./methods/reject');
+Collection.prototype.replace = require('./methods/replace');
+Collection.prototype.replaceRecursive = require('./methods/replaceRecursive');
+Collection.prototype.reverse = require('./methods/reverse');
+Collection.prototype.search = require('./methods/search');
+Collection.prototype.shift = require('./methods/shift');
+Collection.prototype.shuffle = require('./methods/shuffle');
+Collection.prototype.skip = require('./methods/skip');
+Collection.prototype.skipUntil = require('./methods/skipUntil');
+Collection.prototype.skipWhile = require('./methods/skipWhile');
+Collection.prototype.slice = require('./methods/slice');
+Collection.prototype.sole = require('./methods/sole');
+Collection.prototype.some = require('./methods/some');
+Collection.prototype.sort = require('./methods/sort');
+Collection.prototype.sortDesc = require('./methods/sortDesc');
+Collection.prototype.sortBy = require('./methods/sortBy');
+Collection.prototype.sortByDesc = require('./methods/sortByDesc');
+Collection.prototype.sortKeys = require('./methods/sortKeys');
+Collection.prototype.sortKeysDesc = require('./methods/sortKeysDesc');
+Collection.prototype.splice = require('./methods/splice');
+Collection.prototype.split = require('./methods/split');
+Collection.prototype.sum = require('./methods/sum');
+Collection.prototype.take = require('./methods/take');
+Collection.prototype.takeUntil = require('./methods/takeUntil');
+Collection.prototype.takeWhile = require('./methods/takeWhile');
+Collection.prototype.tap = require('./methods/tap');
+Collection.prototype.times = require('./methods/times');
+Collection.prototype.toArray = require('./methods/toArray');
+Collection.prototype.toJson = require('./methods/toJson');
+Collection.prototype.transform = require('./methods/transform');
+Collection.prototype.unless = require('./methods/unless');
+Collection.prototype.unlessEmpty = require('./methods/whenNotEmpty');
+Collection.prototype.unlessNotEmpty = require('./methods/whenEmpty');
+Collection.prototype.union = require('./methods/union');
+Collection.prototype.unique = require('./methods/unique');
+Collection.prototype.unwrap = require('./methods/unwrap');
+Collection.prototype.values = require('./methods/values');
+Collection.prototype.when = require('./methods/when');
+Collection.prototype.whenEmpty = require('./methods/whenEmpty');
+Collection.prototype.whenNotEmpty = require('./methods/whenNotEmpty');
+Collection.prototype.where = require('./methods/where');
+Collection.prototype.whereBetween = require('./methods/whereBetween');
+Collection.prototype.whereIn = require('./methods/whereIn');
+Collection.prototype.whereInstanceOf = require('./methods/whereInstanceOf');
+Collection.prototype.whereNotBetween = require('./methods/whereNotBetween');
+Collection.prototype.whereNotIn = require('./methods/whereNotIn');
+Collection.prototype.whereNull = require('./methods/whereNull');
+Collection.prototype.whereNotNull = require('./methods/whereNotNull');
+Collection.prototype.wrap = require('./methods/wrap');
+Collection.prototype.zip = require('./methods/zip');
+
+var collect = function collect(collection) {
+  return new Collection(collection);
+};
+
+module.exports = collect;
+module.exports.collect = collect;
+module.exports.default = collect;
+module.exports.Collection = Collection;

app/code/node_modules/collect.js/dist/methods/all.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function all() {
+  return this.items;
+};

app/code/node_modules/collect.js/dist/methods/average.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function average(key) {
+  if (key === undefined) {
+    return this.sum() / this.items.length;
+  }
+
+  if (isFunction(key)) {
+    return new this.constructor(this.items).sum(key) / this.items.length;
+  }
+
+  return new this.constructor(this.items).pluck(key).sum() / this.items.length;
+};

app/code/node_modules/collect.js/dist/methods/avg.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var average = require('./average');
+
+module.exports = average;

app/code/node_modules/collect.js/dist/methods/chunk.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+module.exports = function chunk(size) {
+  var _this = this;
+
+  var chunks = [];
+  var index = 0;
+
+  if (Array.isArray(this.items)) {
+    do {
+      var items = this.items.slice(index, index + size);
+      var collection = new this.constructor(items);
+
+      chunks.push(collection);
+      index += size;
+    } while (index < this.items.length);
+  } else if (_typeof(this.items) === 'object') {
+    var keys = Object.keys(this.items);
+
+    var _loop = function _loop() {
+      var keysOfChunk = keys.slice(index, index + size);
+      var collection = new _this.constructor({});
+
+      keysOfChunk.forEach(function (key) {
+        return collection.put(key, _this.items[key]);
+      });
+
+      chunks.push(collection);
+      index += size;
+    };
+
+    do {
+      _loop();
+    } while (index < keys.length);
+  } else {
+    chunks.push(new this.constructor([this.items]));
+  }
+
+  return new this.constructor(chunks);
+};

app/code/node_modules/collect.js/dist/methods/collapse.js

@@ -0,0 +1,9 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+module.exports = function collapse() {
+  var _ref;
+
+  return new this.constructor((_ref = []).concat.apply(_ref, _toConsumableArray(this.items)));
+};

app/code/node_modules/collect.js/dist/methods/combine.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+module.exports = function combine(array) {
+  var _this = this;
+
+  var values = array;
+
+  if (values instanceof this.constructor) {
+    values = array.all();
+  }
+
+  var collection = {};
+
+  if (Array.isArray(this.items) && Array.isArray(values)) {
+    this.items.forEach(function (key, iterator) {
+      collection[key] = values[iterator];
+    });
+  } else if (_typeof(this.items) === 'object' && (typeof values === 'undefined' ? 'undefined' : _typeof(values)) === 'object') {
+    Object.keys(this.items).forEach(function (key, index) {
+      collection[_this.items[key]] = values[Object.keys(values)[index]];
+    });
+  } else if (Array.isArray(this.items)) {
+    collection[this.items[0]] = values;
+  } else if (typeof this.items === 'string' && Array.isArray(values)) {
+    var _values = values;
+
+    var _values2 = _slicedToArray(_values, 1);
+
+    collection[this.items] = _values2[0];
+  } else if (typeof this.items === 'string') {
+    collection[this.items] = values;
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/concat.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var clone = require('../helpers/clone');
+
+module.exports = function concat(collectionOrArrayOrObject) {
+  var list = collectionOrArrayOrObject;
+
+  if (collectionOrArrayOrObject instanceof this.constructor) {
+    list = collectionOrArrayOrObject.all();
+  } else if ((typeof collectionOrArrayOrObject === 'undefined' ? 'undefined' : _typeof(collectionOrArrayOrObject)) === 'object') {
+    list = [];
+    Object.keys(collectionOrArrayOrObject).forEach(function (property) {
+      list.push(collectionOrArrayOrObject[property]);
+    });
+  }
+
+  var collection = clone(this.items);
+
+  list.forEach(function (item) {
+    if ((typeof item === 'undefined' ? 'undefined' : _typeof(item)) === 'object') {
+      Object.keys(item).forEach(function (key) {
+        return collection.push(item[key]);
+      });
+    } else {
+      collection.push(item);
+    }
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/contains.js

@@ -0,0 +1,35 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var values = require('../helpers/values');
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function contains(key, value) {
+  if (value !== undefined) {
+    if (Array.isArray(this.items)) {
+      return this.items.filter(function (items) {
+        return items[key] !== undefined && items[key] === value;
+      }).length > 0;
+    }
+
+    return this.items[key] !== undefined && this.items[key] === value;
+  }
+
+  if (isFunction(key)) {
+    return this.items.filter(function (item, index) {
+      return key(item, index);
+    }).length > 0;
+  }
+
+  if (Array.isArray(this.items)) {
+    return this.items.indexOf(key) !== -1;
+  }
+
+  var keysAndValues = values(this.items);
+  keysAndValues.push.apply(keysAndValues, _toConsumableArray(Object.keys(this.items)));
+
+  return keysAndValues.indexOf(key) !== -1;
+};

app/code/node_modules/collect.js/dist/methods/count.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function count() {
+  var arrayLength = 0;
+
+  if (Array.isArray(this.items)) {
+    arrayLength = this.items.length;
+  }
+
+  return Math.max(Object.keys(this.items).length, arrayLength);
+};

app/code/node_modules/collect.js/dist/methods/countBy.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function countBy() {
+  var fn = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (value) {
+    return value;
+  };
+
+  return new this.constructor(this.items).groupBy(fn).map(function (value) {
+    return value.count();
+  });
+};

app/code/node_modules/collect.js/dist/methods/crossJoin.js

@@ -0,0 +1,34 @@
+'use strict';
+
+module.exports = function crossJoin() {
+  function join(collection, constructor, args) {
+    var current = args[0];
+
+    if (current instanceof constructor) {
+      current = current.all();
+    }
+
+    var rest = args.slice(1);
+    var last = !rest.length;
+    var result = [];
+
+    for (var i = 0; i < current.length; i += 1) {
+      var collectionCopy = collection.slice();
+      collectionCopy.push(current[i]);
+
+      if (last) {
+        result.push(collectionCopy);
+      } else {
+        result = result.concat(join(collectionCopy, constructor, rest));
+      }
+    }
+
+    return result;
+  }
+
+  for (var _len = arguments.length, values = Array(_len), _key = 0; _key < _len; _key++) {
+    values[_key] = arguments[_key];
+  }
+
+  return new this.constructor(join([], this.constructor, [].concat([this.items], values)));
+};

app/code/node_modules/collect.js/dist/methods/dd.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function dd() {
+  this.dump();
+
+  if (typeof process !== 'undefined') {
+    process.exit(1);
+  }
+};

app/code/node_modules/collect.js/dist/methods/diff.js

@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports = function diff(values) {
+  var valuesToDiff = void 0;
+
+  if (values instanceof this.constructor) {
+    valuesToDiff = values.all();
+  } else {
+    valuesToDiff = values;
+  }
+
+  var collection = this.items.filter(function (item) {
+    return valuesToDiff.indexOf(item) === -1;
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/diffAssoc.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = function diffAssoc(values) {
+  var _this = this;
+
+  var diffValues = values;
+
+  if (values instanceof this.constructor) {
+    diffValues = values.all();
+  }
+
+  var collection = {};
+
+  Object.keys(this.items).forEach(function (key) {
+    if (diffValues[key] === undefined || diffValues[key] !== _this.items[key]) {
+      collection[key] = _this.items[key];
+    }
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/diffKeys.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = function diffKeys(object) {
+  var objectToDiff = void 0;
+
+  if (object instanceof this.constructor) {
+    objectToDiff = object.all();
+  } else {
+    objectToDiff = object;
+  }
+
+  var objectKeys = Object.keys(objectToDiff);
+
+  var remainingKeys = Object.keys(this.items).filter(function (item) {
+    return objectKeys.indexOf(item) === -1;
+  });
+
+  return new this.constructor(this.items).only(remainingKeys);
+};

app/code/node_modules/collect.js/dist/methods/doesntContain.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function contains(key, value) {
+  return !this.contains(key, value);
+};

app/code/node_modules/collect.js/dist/methods/dump.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function dump() {
+  // eslint-disable-next-line
+  console.log(this);
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/duplicates.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+module.exports = function duplicates() {
+  var _this = this;
+
+  var occuredValues = [];
+  var duplicateValues = {};
+
+  var stringifiedValue = function stringifiedValue(value) {
+    if (Array.isArray(value) || (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
+      return JSON.stringify(value);
+    }
+
+    return value;
+  };
+
+  if (Array.isArray(this.items)) {
+    this.items.forEach(function (value, index) {
+      var valueAsString = stringifiedValue(value);
+
+      if (occuredValues.indexOf(valueAsString) === -1) {
+        occuredValues.push(valueAsString);
+      } else {
+        duplicateValues[index] = value;
+      }
+    });
+  } else if (_typeof(this.items) === 'object') {
+    Object.keys(this.items).forEach(function (key) {
+      var valueAsString = stringifiedValue(_this.items[key]);
+
+      if (occuredValues.indexOf(valueAsString) === -1) {
+        occuredValues.push(valueAsString);
+      } else {
+        duplicateValues[key] = _this.items[key];
+      }
+    });
+  }
+
+  return new this.constructor(duplicateValues);
+};

app/code/node_modules/collect.js/dist/methods/each.js

@@ -0,0 +1,26 @@
+'use strict';
+
+module.exports = function each(fn) {
+  var stop = false;
+
+  if (Array.isArray(this.items)) {
+    var length = this.items.length;
+
+
+    for (var index = 0; index < length && !stop; index += 1) {
+      stop = fn(this.items[index], index, this.items) === false;
+    }
+  } else {
+    var keys = Object.keys(this.items);
+    var _length = keys.length;
+
+
+    for (var _index = 0; _index < _length && !stop; _index += 1) {
+      var key = keys[_index];
+
+      stop = fn(this.items[key], key, this.items) === false;
+    }
+  }
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/eachSpread.js

@@ -0,0 +1,11 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+module.exports = function eachSpread(fn) {
+  this.each(function (values, key) {
+    fn.apply(undefined, _toConsumableArray(values).concat([key]));
+  });
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/every.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var values = require('../helpers/values');
+
+module.exports = function every(fn) {
+  var items = values(this.items);
+
+  return items.every(fn);
+};

app/code/node_modules/collect.js/dist/methods/except.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var variadic = require('../helpers/variadic');
+
+module.exports = function except() {
+  var _this = this;
+
+  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var properties = variadic(args);
+
+  if (Array.isArray(this.items)) {
+    var _collection = this.items.filter(function (item) {
+      return properties.indexOf(item) === -1;
+    });
+
+    return new this.constructor(_collection);
+  }
+
+  var collection = {};
+
+  Object.keys(this.items).forEach(function (property) {
+    if (properties.indexOf(property) === -1) {
+      collection[property] = _this.items[property];
+    }
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/filter.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+function falsyValue(item) {
+  if (Array.isArray(item)) {
+    if (item.length) {
+      return false;
+    }
+  } else if (item !== undefined && item !== null && (typeof item === 'undefined' ? 'undefined' : _typeof(item)) === 'object') {
+    if (Object.keys(item).length) {
+      return false;
+    }
+  } else if (item) {
+    return false;
+  }
+
+  return true;
+}
+
+function filterObject(func, items) {
+  var result = {};
+  Object.keys(items).forEach(function (key) {
+    if (func) {
+      if (func(items[key], key)) {
+        result[key] = items[key];
+      }
+    } else if (!falsyValue(items[key])) {
+      result[key] = items[key];
+    }
+  });
+
+  return result;
+}
+
+function filterArray(func, items) {
+  if (func) {
+    return items.filter(func);
+  }
+  var result = [];
+  for (var i = 0; i < items.length; i += 1) {
+    var item = items[i];
+    if (!falsyValue(item)) {
+      result.push(item);
+    }
+  }
+
+  return result;
+}
+
+module.exports = function filter(fn) {
+  var func = fn || false;
+  var filteredItems = null;
+  if (Array.isArray(this.items)) {
+    filteredItems = filterArray(func, this.items);
+  } else {
+    filteredItems = filterObject(func, this.items);
+  }
+
+  return new this.constructor(filteredItems);
+};

app/code/node_modules/collect.js/dist/methods/first.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function first(fn, defaultValue) {
+  if (isFunction(fn)) {
+    var keys = Object.keys(this.items);
+
+    for (var i = 0; i < keys.length; i += 1) {
+      var key = keys[i];
+      var item = this.items[key];
+
+      if (fn(item, key)) {
+        return item;
+      }
+    }
+
+    if (isFunction(defaultValue)) {
+      return defaultValue();
+    }
+
+    return defaultValue;
+  }
+
+  if (Array.isArray(this.items) && this.items.length || Object.keys(this.items).length) {
+    if (Array.isArray(this.items)) {
+      return this.items[0];
+    }
+
+    var firstKey = Object.keys(this.items)[0];
+
+    return this.items[firstKey];
+  }
+
+  if (isFunction(defaultValue)) {
+    return defaultValue();
+  }
+
+  return defaultValue;
+};

app/code/node_modules/collect.js/dist/methods/firstOrFail.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function firstOrFail(key, operator, value) {
+  if (isFunction(key)) {
+    return this.first(key, function () {
+      throw new Error('Item not found.');
+    });
+  }
+
+  var collection = this.where(key, operator, value);
+
+  if (collection.isEmpty()) {
+    throw new Error('Item not found.');
+  }
+
+  return collection.first();
+};

app/code/node_modules/collect.js/dist/methods/firstWhere.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function firstWhere(key, operator, value) {
+  return this.where(key, operator, value).first() || null;
+};

app/code/node_modules/collect.js/dist/methods/flatMap.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function flatMap(fn) {
+  return this.map(fn).collapse();
+};

app/code/node_modules/collect.js/dist/methods/flatten.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isArray = _require.isArray,
+    isObject = _require.isObject;
+
+module.exports = function flatten(depth) {
+  var flattenDepth = depth || Infinity;
+
+  var fullyFlattened = false;
+  var collection = [];
+
+  var flat = function flat(items) {
+    collection = [];
+
+    if (isArray(items)) {
+      items.forEach(function (item) {
+        if (isArray(item)) {
+          collection = collection.concat(item);
+        } else if (isObject(item)) {
+          Object.keys(item).forEach(function (property) {
+            collection = collection.concat(item[property]);
+          });
+        } else {
+          collection.push(item);
+        }
+      });
+    } else {
+      Object.keys(items).forEach(function (property) {
+        if (isArray(items[property])) {
+          collection = collection.concat(items[property]);
+        } else if (isObject(items[property])) {
+          Object.keys(items[property]).forEach(function (prop) {
+            collection = collection.concat(items[property][prop]);
+          });
+        } else {
+          collection.push(items[property]);
+        }
+      });
+    }
+
+    fullyFlattened = collection.filter(function (item) {
+      return isObject(item);
+    });
+    fullyFlattened = fullyFlattened.length === 0;
+
+    flattenDepth -= 1;
+  };
+
+  flat(this.items);
+
+  while (!fullyFlattened && flattenDepth > 0) {
+    flat(collection);
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/flip.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = function flip() {
+  var _this = this;
+
+  var collection = {};
+
+  if (Array.isArray(this.items)) {
+    Object.keys(this.items).forEach(function (key) {
+      collection[_this.items[key]] = Number(key);
+    });
+  } else {
+    Object.keys(this.items).forEach(function (key) {
+      collection[_this.items[key]] = key;
+    });
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/forPage.js

@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports = function forPage(page, chunk) {
+  var _this = this;
+
+  var collection = {};
+
+  if (Array.isArray(this.items)) {
+    collection = this.items.slice(page * chunk - chunk, page * chunk);
+  } else {
+    Object.keys(this.items).slice(page * chunk - chunk, page * chunk).forEach(function (key) {
+      collection[key] = _this.items[key];
+    });
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/forget.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function forget(key) {
+  if (Array.isArray(this.items)) {
+    this.items.splice(key, 1);
+  } else {
+    delete this.items[key];
+  }
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/get.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function get(key) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+  if (this.items[key] !== undefined) {
+    return this.items[key];
+  }
+
+  if (isFunction(defaultValue)) {
+    return defaultValue();
+  }
+
+  if (defaultValue !== null) {
+    return defaultValue;
+  }
+
+  return null;
+};

app/code/node_modules/collect.js/dist/methods/groupBy.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var nestedValue = require('../helpers/nestedValue');
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function groupBy(key) {
+  var _this = this;
+
+  var collection = {};
+
+  this.items.forEach(function (item, index) {
+    var resolvedKey = void 0;
+
+    if (isFunction(key)) {
+      resolvedKey = key(item, index);
+    } else if (nestedValue(item, key) || nestedValue(item, key) === 0) {
+      resolvedKey = nestedValue(item, key);
+    } else {
+      resolvedKey = '';
+    }
+
+    if (collection[resolvedKey] === undefined) {
+      collection[resolvedKey] = new _this.constructor([]);
+    }
+
+    collection[resolvedKey].push(item);
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/has.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var variadic = require('../helpers/variadic');
+
+module.exports = function has() {
+  var _this = this;
+
+  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var properties = variadic(args);
+
+  return properties.filter(function (key) {
+    return Object.hasOwnProperty.call(_this.items, key);
+  }).length === properties.length;
+};

app/code/node_modules/collect.js/dist/methods/implode.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function implode(key, glue) {
+  if (glue === undefined) {
+    return this.items.join(key);
+  }
+
+  return new this.constructor(this.items).pluck(key).all().join(glue);
+};

app/code/node_modules/collect.js/dist/methods/intersect.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = function intersect(values) {
+  var intersectValues = values;
+
+  if (values instanceof this.constructor) {
+    intersectValues = values.all();
+  }
+
+  var collection = this.items.filter(function (item) {
+    return intersectValues.indexOf(item) !== -1;
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/intersectByKeys.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = function intersectByKeys(values) {
+  var _this = this;
+
+  var intersectKeys = Object.keys(values);
+
+  if (values instanceof this.constructor) {
+    intersectKeys = Object.keys(values.all());
+  }
+
+  var collection = {};
+
+  Object.keys(this.items).forEach(function (key) {
+    if (intersectKeys.indexOf(key) !== -1) {
+      collection[key] = _this.items[key];
+    }
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/isEmpty.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function isEmpty() {
+  if (Array.isArray(this.items)) {
+    return !this.items.length;
+  }
+
+  return !Object.keys(this.items).length;
+};

app/code/node_modules/collect.js/dist/methods/isNotEmpty.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function isNotEmpty() {
+  return !this.isEmpty();
+};

app/code/node_modules/collect.js/dist/methods/join.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = function join(glue, finalGlue) {
+  var collection = this.values();
+
+  if (finalGlue === undefined) {
+    return collection.implode(glue);
+  }
+
+  var count = collection.count();
+
+  if (count === 0) {
+    return '';
+  }
+
+  if (count === 1) {
+    return collection.last();
+  }
+
+  var finalItem = collection.pop();
+
+  return collection.implode(glue) + finalGlue + finalItem;
+};

app/code/node_modules/collect.js/dist/methods/keyBy.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var nestedValue = require('../helpers/nestedValue');
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function keyBy(key) {
+  var collection = {};
+
+  if (isFunction(key)) {
+    this.items.forEach(function (item) {
+      collection[key(item)] = item;
+    });
+  } else {
+    this.items.forEach(function (item) {
+      var keyValue = nestedValue(item, key);
+
+      collection[keyValue || ''] = item;
+    });
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/keys.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function keys() {
+  var collection = Object.keys(this.items);
+
+  if (Array.isArray(this.items)) {
+    collection = collection.map(Number);
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/last.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function last(fn, defaultValue) {
+  var items = this.items;
+
+
+  if (isFunction(fn)) {
+    items = this.filter(fn).all();
+  }
+
+  if (Array.isArray(items) && !items.length || !Object.keys(items).length) {
+    if (isFunction(defaultValue)) {
+      return defaultValue();
+    }
+
+    return defaultValue;
+  }
+
+  if (Array.isArray(items)) {
+    return items[items.length - 1];
+  }
+  var keys = Object.keys(items);
+
+  return items[keys[keys.length - 1]];
+};

app/code/node_modules/collect.js/dist/methods/macro.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function macro(name, fn) {
+  this.constructor.prototype[name] = fn;
+};

app/code/node_modules/collect.js/dist/methods/make.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function make() {
+  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+  return new this.constructor(items);
+};

app/code/node_modules/collect.js/dist/methods/map.js

@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports = function map(fn) {
+  var _this = this;
+
+  if (Array.isArray(this.items)) {
+    return new this.constructor(this.items.map(fn));
+  }
+
+  var collection = {};
+
+  Object.keys(this.items).forEach(function (key) {
+    collection[key] = fn(_this.items[key], key);
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/mapInto.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function mapInto(ClassName) {
+  return this.map(function (value, key) {
+    return new ClassName(value, key);
+  });
+};

app/code/node_modules/collect.js/dist/methods/mapSpread.js

@@ -0,0 +1,9 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+module.exports = function mapSpread(fn) {
+  return this.map(function (values, key) {
+    return fn.apply(undefined, _toConsumableArray(values).concat([key]));
+  });
+};

app/code/node_modules/collect.js/dist/methods/mapToDictionary.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+module.exports = function mapToDictionary(fn) {
+  var collection = {};
+
+  this.items.forEach(function (item, k) {
+    var _fn = fn(item, k),
+        _fn2 = _slicedToArray(_fn, 2),
+        key = _fn2[0],
+        value = _fn2[1];
+
+    if (collection[key] === undefined) {
+      collection[key] = [value];
+    } else {
+      collection[key].push(value);
+    }
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/mapToGroups.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+module.exports = function mapToGroups(fn) {
+  var collection = {};
+
+  this.items.forEach(function (item, key) {
+    var _fn = fn(item, key),
+        _fn2 = _slicedToArray(_fn, 2),
+        keyed = _fn2[0],
+        value = _fn2[1];
+
+    if (collection[keyed] === undefined) {
+      collection[keyed] = [value];
+    } else {
+      collection[keyed].push(value);
+    }
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/mapWithKeys.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+module.exports = function mapWithKeys(fn) {
+  var _this = this;
+
+  var collection = {};
+
+  if (Array.isArray(this.items)) {
+    this.items.forEach(function (item, index) {
+      var _fn = fn(item, index),
+          _fn2 = _slicedToArray(_fn, 2),
+          keyed = _fn2[0],
+          value = _fn2[1];
+
+      collection[keyed] = value;
+    });
+  } else {
+    Object.keys(this.items).forEach(function (key) {
+      var _fn3 = fn(_this.items[key], key),
+          _fn4 = _slicedToArray(_fn3, 2),
+          keyed = _fn4[0],
+          value = _fn4[1];
+
+      collection[keyed] = value;
+    });
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/max.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+module.exports = function max(key) {
+  if (typeof key === 'string') {
+    var filtered = this.items.filter(function (item) {
+      return item[key] !== undefined;
+    });
+
+    return Math.max.apply(Math, _toConsumableArray(filtered.map(function (item) {
+      return item[key];
+    })));
+  }
+
+  return Math.max.apply(Math, _toConsumableArray(this.items));
+};

app/code/node_modules/collect.js/dist/methods/median.js

@@ -0,0 +1,20 @@
+'use strict';
+
+module.exports = function median(key) {
+  var length = this.items.length;
+
+
+  if (key === undefined) {
+    if (length % 2 === 0) {
+      return (this.items[length / 2 - 1] + this.items[length / 2]) / 2;
+    }
+
+    return this.items[Math.floor(length / 2)];
+  }
+
+  if (length % 2 === 0) {
+    return (this.items[length / 2 - 1][key] + this.items[length / 2][key]) / 2;
+  }
+
+  return this.items[Math.floor(length / 2)][key];
+};

app/code/node_modules/collect.js/dist/methods/merge.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = function merge(value) {
+  var arrayOrObject = value;
+
+  if (typeof arrayOrObject === 'string') {
+    arrayOrObject = [arrayOrObject];
+  }
+
+  if (Array.isArray(this.items) && Array.isArray(arrayOrObject)) {
+    return new this.constructor(this.items.concat(arrayOrObject));
+  }
+
+  var collection = JSON.parse(JSON.stringify(this.items));
+
+  Object.keys(arrayOrObject).forEach(function (key) {
+    collection[key] = arrayOrObject[key];
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/mergeRecursive.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+module.exports = function mergeRecursive(items) {
+  var merge = function merge(target, source) {
+    var merged = {};
+
+    var mergedKeys = Object.keys(Object.assign({}, target, source));
+
+    mergedKeys.forEach(function (key) {
+      if (target[key] === undefined && source[key] !== undefined) {
+        merged[key] = source[key];
+      } else if (target[key] !== undefined && source[key] === undefined) {
+        merged[key] = target[key];
+      } else if (target[key] !== undefined && source[key] !== undefined) {
+        if (target[key] === source[key]) {
+          merged[key] = target[key];
+        } else if (!Array.isArray(target[key]) && _typeof(target[key]) === 'object' && !Array.isArray(source[key]) && _typeof(source[key]) === 'object') {
+          merged[key] = merge(target[key], source[key]);
+        } else {
+          merged[key] = [].concat(target[key], source[key]);
+        }
+      }
+    });
+
+    return merged;
+  };
+
+  if (!items) {
+    return this;
+  }
+
+  if (items.constructor.name === 'Collection') {
+    return new this.constructor(merge(this.items, items.all()));
+  }
+
+  return new this.constructor(merge(this.items, items));
+};

app/code/node_modules/collect.js/dist/methods/min.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+module.exports = function min(key) {
+  if (key !== undefined) {
+    var filtered = this.items.filter(function (item) {
+      return item[key] !== undefined;
+    });
+
+    return Math.min.apply(Math, _toConsumableArray(filtered.map(function (item) {
+      return item[key];
+    })));
+  }
+
+  return Math.min.apply(Math, _toConsumableArray(this.items));
+};

app/code/node_modules/collect.js/dist/methods/mode.js

@@ -0,0 +1,42 @@
+'use strict';
+
+module.exports = function mode(key) {
+  var values = [];
+  var highestCount = 1;
+
+  if (!this.items.length) {
+    return null;
+  }
+
+  this.items.forEach(function (item) {
+    var tempValues = values.filter(function (value) {
+      if (key !== undefined) {
+        return value.key === item[key];
+      }
+
+      return value.key === item;
+    });
+
+    if (!tempValues.length) {
+      if (key !== undefined) {
+        values.push({ key: item[key], count: 1 });
+      } else {
+        values.push({ key: item, count: 1 });
+      }
+    } else {
+      tempValues[0].count += 1;
+      var count = tempValues[0].count;
+
+
+      if (count > highestCount) {
+        highestCount = count;
+      }
+    }
+  });
+
+  return values.filter(function (value) {
+    return value.count === highestCount;
+  }).map(function (value) {
+    return value.key;
+  });
+};

app/code/node_modules/collect.js/dist/methods/nth.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var values = require('../helpers/values');
+
+module.exports = function nth(n) {
+  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+  var items = values(this.items);
+
+  var collection = items.slice(offset).filter(function (item, index) {
+    return index % n === 0;
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/only.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var variadic = require('../helpers/variadic');
+
+module.exports = function only() {
+  var _this = this;
+
+  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var properties = variadic(args);
+
+  if (Array.isArray(this.items)) {
+    var _collection = this.items.filter(function (item) {
+      return properties.indexOf(item) !== -1;
+    });
+
+    return new this.constructor(_collection);
+  }
+
+  var collection = {};
+
+  Object.keys(this.items).forEach(function (prop) {
+    if (properties.indexOf(prop) !== -1) {
+      collection[prop] = _this.items[prop];
+    }
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/pad.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var clone = require('../helpers/clone');
+
+module.exports = function pad(size, value) {
+  var abs = Math.abs(size);
+  var count = this.count();
+
+  if (abs <= count) {
+    return this;
+  }
+
+  var diff = abs - count;
+  var items = clone(this.items);
+  var isArray = Array.isArray(this.items);
+  var prepend = size < 0;
+
+  for (var iterator = 0; iterator < diff;) {
+    if (!isArray) {
+      if (items[iterator] !== undefined) {
+        diff += 1;
+      } else {
+        items[iterator] = value;
+      }
+    } else if (prepend) {
+      items.unshift(value);
+    } else {
+      items.push(value);
+    }
+
+    iterator += 1;
+  }
+
+  return new this.constructor(items);
+};

app/code/node_modules/collect.js/dist/methods/partition.js

@@ -0,0 +1,33 @@
+'use strict';
+
+module.exports = function partition(fn) {
+  var _this = this;
+
+  var arrays = void 0;
+
+  if (Array.isArray(this.items)) {
+    arrays = [new this.constructor([]), new this.constructor([])];
+
+    this.items.forEach(function (item) {
+      if (fn(item) === true) {
+        arrays[0].push(item);
+      } else {
+        arrays[1].push(item);
+      }
+    });
+  } else {
+    arrays = [new this.constructor({}), new this.constructor({})];
+
+    Object.keys(this.items).forEach(function (prop) {
+      var value = _this.items[prop];
+
+      if (fn(value) === true) {
+        arrays[0].put(prop, value);
+      } else {
+        arrays[1].put(prop, value);
+      }
+    });
+  }
+
+  return new this.constructor(arrays);
+};

app/code/node_modules/collect.js/dist/methods/pipe.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function pipe(fn) {
+  return fn(this);
+};

app/code/node_modules/collect.js/dist/methods/pluck.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isArray = _require.isArray,
+    isObject = _require.isObject;
+
+var nestedValue = require('../helpers/nestedValue');
+
+var buildKeyPathMap = function buildKeyPathMap(items) {
+  var keyPaths = {};
+
+  items.forEach(function (item, index) {
+    function buildKeyPath(val, keyPath) {
+      if (isObject(val)) {
+        Object.keys(val).forEach(function (prop) {
+          buildKeyPath(val[prop], keyPath + '.' + prop);
+        });
+      } else if (isArray(val)) {
+        val.forEach(function (v, i) {
+          buildKeyPath(v, keyPath + '.' + i);
+        });
+      }
+
+      keyPaths[keyPath] = val;
+    }
+
+    buildKeyPath(item, index);
+  });
+
+  return keyPaths;
+};
+
+module.exports = function pluck(value, key) {
+  if (value.indexOf('*') !== -1) {
+    var keyPathMap = buildKeyPathMap(this.items);
+
+    var keyMatches = [];
+
+    if (key !== undefined) {
+      var keyRegex = new RegExp('0.' + key, 'g');
+      var keyNumberOfLevels = ('0.' + key).split('.').length;
+
+      Object.keys(keyPathMap).forEach(function (k) {
+        var matchingKey = k.match(keyRegex);
+
+        if (matchingKey) {
+          var match = matchingKey[0];
+
+          if (match.split('.').length === keyNumberOfLevels) {
+            keyMatches.push(keyPathMap[match]);
+          }
+        }
+      });
+    }
+
+    var valueMatches = [];
+    var valueRegex = new RegExp('0.' + value, 'g');
+    var valueNumberOfLevels = ('0.' + value).split('.').length;
+
+    Object.keys(keyPathMap).forEach(function (k) {
+      var matchingValue = k.match(valueRegex);
+
+      if (matchingValue) {
+        var match = matchingValue[0];
+
+        if (match.split('.').length === valueNumberOfLevels) {
+          valueMatches.push(keyPathMap[match]);
+        }
+      }
+    });
+
+    if (key !== undefined) {
+      var collection = {};
+
+      this.items.forEach(function (item, index) {
+        collection[keyMatches[index] || ''] = valueMatches;
+      });
+
+      return new this.constructor(collection);
+    }
+
+    return new this.constructor([valueMatches]);
+  }
+
+  if (key !== undefined) {
+    var _collection = {};
+
+    this.items.forEach(function (item) {
+      if (nestedValue(item, value) !== undefined) {
+        _collection[item[key] || ''] = nestedValue(item, value);
+      } else {
+        _collection[item[key] || ''] = null;
+      }
+    });
+
+    return new this.constructor(_collection);
+  }
+
+  return this.map(function (item) {
+    if (nestedValue(item, value) !== undefined) {
+      return nestedValue(item, value);
+    }
+
+    return null;
+  });
+};

app/code/node_modules/collect.js/dist/methods/pop.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isArray = _require.isArray,
+    isObject = _require.isObject;
+
+var deleteKeys = require('../helpers/deleteKeys');
+
+module.exports = function pop() {
+  var _this = this;
+
+  var count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+
+  if (this.isEmpty()) {
+    return null;
+  }
+
+  if (isArray(this.items)) {
+    if (count === 1) {
+      return this.items.pop();
+    }
+
+    return new this.constructor(this.items.splice(-count));
+  }
+
+  if (isObject(this.items)) {
+    var keys = Object.keys(this.items);
+
+    if (count === 1) {
+      var key = keys[keys.length - 1];
+      var last = this.items[key];
+
+      deleteKeys(this.items, key);
+
+      return last;
+    }
+
+    var poppedKeys = keys.slice(-count);
+
+    var newObject = poppedKeys.reduce(function (acc, current) {
+      acc[current] = _this.items[current];
+
+      return acc;
+    }, {});
+
+    deleteKeys(this.items, poppedKeys);
+
+    return new this.constructor(newObject);
+  }
+
+  return null;
+};

app/code/node_modules/collect.js/dist/methods/prepend.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function prepend(value, key) {
+  if (key !== undefined) {
+    return this.put(key, value);
+  }
+
+  this.items.unshift(value);
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/pull.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function pull(key, defaultValue) {
+  var returnValue = this.items[key] || null;
+
+  if (!returnValue && defaultValue !== undefined) {
+    if (isFunction(defaultValue)) {
+      returnValue = defaultValue();
+    } else {
+      returnValue = defaultValue;
+    }
+  }
+
+  delete this.items[key];
+
+  return returnValue;
+};

app/code/node_modules/collect.js/dist/methods/push.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function push() {
+  var _items;
+
+  (_items = this.items).push.apply(_items, arguments);
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/put.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function put(key, value) {
+  this.items[key] = value;
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/random.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var values = require('../helpers/values');
+
+module.exports = function random() {
+  var length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+  var items = values(this.items);
+
+  var collection = new this.constructor(items).shuffle();
+
+  // If not a length was specified
+  if (length !== parseInt(length, 10)) {
+    return collection.first();
+  }
+
+  return collection.take(length);
+};

app/code/node_modules/collect.js/dist/methods/reduce.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = function reduce(fn, carry) {
+  var _this = this;
+
+  var reduceCarry = null;
+
+  if (carry !== undefined) {
+    reduceCarry = carry;
+  }
+
+  if (Array.isArray(this.items)) {
+    this.items.forEach(function (item) {
+      reduceCarry = fn(reduceCarry, item);
+    });
+  } else {
+    Object.keys(this.items).forEach(function (key) {
+      reduceCarry = fn(reduceCarry, _this.items[key], key);
+    });
+  }
+
+  return reduceCarry;
+};

app/code/node_modules/collect.js/dist/methods/reject.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function reject(fn) {
+  return new this.constructor(this.items).filter(function (item) {
+    return !fn(item);
+  });
+};

app/code/node_modules/collect.js/dist/methods/replace.js

@@ -0,0 +1,25 @@
+'use strict';
+
+module.exports = function replace(items) {
+  if (!items) {
+    return this;
+  }
+
+  if (Array.isArray(items)) {
+    var _replaced = this.items.map(function (value, index) {
+      return items[index] || value;
+    });
+
+    return new this.constructor(_replaced);
+  }
+
+  if (items.constructor.name === 'Collection') {
+    var _replaced2 = Object.assign({}, this.items, items.all());
+
+    return new this.constructor(_replaced2);
+  }
+
+  var replaced = Object.assign({}, this.items, items);
+
+  return new this.constructor(replaced);
+};

app/code/node_modules/collect.js/dist/methods/replaceRecursive.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+module.exports = function replaceRecursive(items) {
+  var replace = function replace(target, source) {
+    var replaced = Object.assign({}, target);
+
+    var mergedKeys = Object.keys(Object.assign({}, target, source));
+
+    mergedKeys.forEach(function (key) {
+      if (!Array.isArray(source[key]) && _typeof(source[key]) === 'object') {
+        replaced[key] = replace(target[key], source[key]);
+      } else if (target[key] === undefined && source[key] !== undefined) {
+        if (_typeof(target[key]) === 'object') {
+          replaced[key] = Object.assign({}, source[key]);
+        } else {
+          replaced[key] = source[key];
+        }
+      } else if (target[key] !== undefined && source[key] === undefined) {
+        if (_typeof(target[key]) === 'object') {
+          replaced[key] = Object.assign({}, target[key]);
+        } else {
+          replaced[key] = target[key];
+        }
+      } else if (target[key] !== undefined && source[key] !== undefined) {
+        if (_typeof(source[key]) === 'object') {
+          replaced[key] = Object.assign({}, source[key]);
+        } else {
+          replaced[key] = source[key];
+        }
+      }
+    });
+
+    return replaced;
+  };
+
+  if (!items) {
+    return this;
+  }
+
+  if (!Array.isArray(items) && (typeof items === 'undefined' ? 'undefined' : _typeof(items)) !== 'object') {
+    return new this.constructor(replace(this.items, [items]));
+  }
+
+  if (items.constructor.name === 'Collection') {
+    return new this.constructor(replace(this.items, items.all()));
+  }
+
+  return new this.constructor(replace(this.items, items));
+};

app/code/node_modules/collect.js/dist/methods/reverse.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function reverse() {
+  var collection = [].concat(this.items).reverse();
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/search.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/* eslint-disable eqeqeq */
+
+var _require = require('../helpers/is'),
+    isArray = _require.isArray,
+    isObject = _require.isObject,
+    isFunction = _require.isFunction;
+
+module.exports = function search(valueOrFunction, strict) {
+  var _this = this;
+
+  var result = void 0;
+
+  var find = function find(item, key) {
+    if (isFunction(valueOrFunction)) {
+      return valueOrFunction(_this.items[key], key);
+    }
+
+    if (strict) {
+      return _this.items[key] === valueOrFunction;
+    }
+
+    return _this.items[key] == valueOrFunction;
+  };
+
+  if (isArray(this.items)) {
+    result = this.items.findIndex(find);
+  } else if (isObject(this.items)) {
+    result = Object.keys(this.items).find(function (key) {
+      return find(_this.items[key], key);
+    });
+  }
+
+  if (result === undefined || result < 0) {
+    return false;
+  }
+
+  return result;
+};

app/code/node_modules/collect.js/dist/methods/shift.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isArray = _require.isArray,
+    isObject = _require.isObject;
+
+var deleteKeys = require('../helpers/deleteKeys');
+
+module.exports = function shift() {
+  var _this = this;
+
+  var count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+
+  if (this.isEmpty()) {
+    return null;
+  }
+
+  if (isArray(this.items)) {
+    if (count === 1) {
+      return this.items.shift();
+    }
+
+    return new this.constructor(this.items.splice(0, count));
+  }
+
+  if (isObject(this.items)) {
+    if (count === 1) {
+      var key = Object.keys(this.items)[0];
+      var value = this.items[key];
+      delete this.items[key];
+
+      return value;
+    }
+
+    var keys = Object.keys(this.items);
+    var poppedKeys = keys.slice(0, count);
+
+    var newObject = poppedKeys.reduce(function (acc, current) {
+      acc[current] = _this.items[current];
+
+      return acc;
+    }, {});
+
+    deleteKeys(this.items, poppedKeys);
+
+    return new this.constructor(newObject);
+  }
+
+  return null;
+};

app/code/node_modules/collect.js/dist/methods/shuffle.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var values = require('../helpers/values');
+
+module.exports = function shuffle() {
+  var items = values(this.items);
+
+  var j = void 0;
+  var x = void 0;
+  var i = void 0;
+
+  for (i = items.length; i; i -= 1) {
+    j = Math.floor(Math.random() * i);
+    x = items[i - 1];
+    items[i - 1] = items[j];
+    items[j] = x;
+  }
+
+  this.items = items;
+
+  return this;
+};

app/code/node_modules/collect.js/dist/methods/skip.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isObject = _require.isObject;
+
+module.exports = function skip(number) {
+  var _this = this;
+
+  if (isObject(this.items)) {
+    return new this.constructor(Object.keys(this.items).reduce(function (accumulator, key, index) {
+      if (index + 1 > number) {
+        accumulator[key] = _this.items[key];
+      }
+
+      return accumulator;
+    }, {}));
+  }
+
+  return new this.constructor(this.items.slice(number));
+};

app/code/node_modules/collect.js/dist/methods/skipUntil.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isArray = _require.isArray,
+    isObject = _require.isObject,
+    isFunction = _require.isFunction;
+
+module.exports = function skipUntil(valueOrFunction) {
+  var _this = this;
+
+  var previous = null;
+  var items = void 0;
+
+  var callback = function callback(value) {
+    return value === valueOrFunction;
+  };
+  if (isFunction(valueOrFunction)) {
+    callback = valueOrFunction;
+  }
+
+  if (isArray(this.items)) {
+    items = this.items.filter(function (item) {
+      if (previous !== true) {
+        previous = callback(item);
+      }
+
+      return previous;
+    });
+  }
+
+  if (isObject(this.items)) {
+    items = Object.keys(this.items).reduce(function (acc, key) {
+      if (previous !== true) {
+        previous = callback(_this.items[key]);
+      }
+
+      if (previous !== false) {
+        acc[key] = _this.items[key];
+      }
+
+      return acc;
+    }, {});
+  }
+
+  return new this.constructor(items);
+};

app/code/node_modules/collect.js/dist/methods/skipWhile.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isArray = _require.isArray,
+    isObject = _require.isObject,
+    isFunction = _require.isFunction;
+
+module.exports = function skipWhile(valueOrFunction) {
+  var _this = this;
+
+  var previous = null;
+  var items = void 0;
+
+  var callback = function callback(value) {
+    return value === valueOrFunction;
+  };
+  if (isFunction(valueOrFunction)) {
+    callback = valueOrFunction;
+  }
+
+  if (isArray(this.items)) {
+    items = this.items.filter(function (item) {
+      if (previous !== true) {
+        previous = !callback(item);
+      }
+
+      return previous;
+    });
+  }
+
+  if (isObject(this.items)) {
+    items = Object.keys(this.items).reduce(function (acc, key) {
+      if (previous !== true) {
+        previous = !callback(_this.items[key]);
+      }
+
+      if (previous !== false) {
+        acc[key] = _this.items[key];
+      }
+
+      return acc;
+    }, {});
+  }
+
+  return new this.constructor(items);
+};

app/code/node_modules/collect.js/dist/methods/slice.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function slice(remove, limit) {
+  var collection = this.items.slice(remove);
+
+  if (limit !== undefined) {
+    collection = collection.slice(0, limit);
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/sole.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function sole(key, operator, value) {
+  var collection = void 0;
+
+  if (isFunction(key)) {
+    collection = this.filter(key);
+  } else {
+    collection = this.where(key, operator, value);
+  }
+
+  if (collection.isEmpty()) {
+    throw new Error('Item not found.');
+  }
+
+  if (collection.count() > 1) {
+    throw new Error('Multiple items found.');
+  }
+
+  return collection.first();
+};

app/code/node_modules/collect.js/dist/methods/some.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var contains = require('./contains');
+
+module.exports = contains;

app/code/node_modules/collect.js/dist/methods/sort.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = function sort(fn) {
+  var collection = [].concat(this.items);
+
+  if (fn === undefined) {
+    if (this.every(function (item) {
+      return typeof item === 'number';
+    })) {
+      collection.sort(function (a, b) {
+        return a - b;
+      });
+    } else {
+      collection.sort();
+    }
+  } else {
+    collection.sort(fn);
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/sortBy.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var nestedValue = require('../helpers/nestedValue');
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function sortBy(valueOrFunction) {
+  var collection = [].concat(this.items);
+  var getValue = function getValue(item) {
+    if (isFunction(valueOrFunction)) {
+      return valueOrFunction(item);
+    }
+
+    return nestedValue(item, valueOrFunction);
+  };
+
+  collection.sort(function (a, b) {
+    var valueA = getValue(a);
+    var valueB = getValue(b);
+
+    if (valueA === null || valueA === undefined) {
+      return 1;
+    }
+    if (valueB === null || valueB === undefined) {
+      return -1;
+    }
+
+    if (valueA < valueB) {
+      return -1;
+    }
+    if (valueA > valueB) {
+      return 1;
+    }
+
+    return 0;
+  });
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/sortByDesc.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function sortByDesc(valueOrFunction) {
+  return this.sortBy(valueOrFunction).reverse();
+};

app/code/node_modules/collect.js/dist/methods/sortDesc.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function sortDesc() {
+  return this.sort().reverse();
+};

app/code/node_modules/collect.js/dist/methods/sortKeys.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = function sortKeys() {
+  var _this = this;
+
+  var ordered = {};
+
+  Object.keys(this.items).sort().forEach(function (key) {
+    ordered[key] = _this.items[key];
+  });
+
+  return new this.constructor(ordered);
+};

app/code/node_modules/collect.js/dist/methods/sortKeysDesc.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = function sortKeysDesc() {
+  var _this = this;
+
+  var ordered = {};
+
+  Object.keys(this.items).sort().reverse().forEach(function (key) {
+    ordered[key] = _this.items[key];
+  });
+
+  return new this.constructor(ordered);
+};

app/code/node_modules/collect.js/dist/methods/splice.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = function splice(index, limit, replace) {
+  var slicedCollection = this.slice(index, limit);
+
+  this.items = this.diff(slicedCollection.all()).all();
+
+  if (Array.isArray(replace)) {
+    for (var iterator = 0, length = replace.length; iterator < length; iterator += 1) {
+      this.items.splice(index + iterator, 0, replace[iterator]);
+    }
+  }
+
+  return slicedCollection;
+};

app/code/node_modules/collect.js/dist/methods/split.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = function split(numberOfGroups) {
+  var itemsPerGroup = Math.round(this.items.length / numberOfGroups);
+
+  var items = JSON.parse(JSON.stringify(this.items));
+  var collection = [];
+
+  for (var iterator = 0; iterator < numberOfGroups; iterator += 1) {
+    collection.push(new this.constructor(items.splice(0, itemsPerGroup)));
+  }
+
+  return new this.constructor(collection);
+};

app/code/node_modules/collect.js/dist/methods/sum.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var values = require('../helpers/values');
+
+var _require = require('../helpers/is'),
+    isFunction = _require.isFunction;
+
+module.exports = function sum(key) {
+  var items = values(this.items);
+
+  var total = 0;
+
+  if (key === undefined) {
+    for (var i = 0, length = items.length; i < length; i += 1) {
+      total += parseFloat(items[i]);
+    }
+  } else if (isFunction(key)) {
+    for (var _i = 0, _length = items.length; _i < _length; _i += 1) {
+      total += parseFloat(key(items[_i]));
+    }
+  } else {
+    for (var _i2 = 0, _length2 = items.length; _i2 < _length2; _i2 += 1) {
+      total += parseFloat(items[_i2][key]);
+    }
+  }
+
+  return parseFloat(total.toPrecision(12));
+};

app/code/node_modules/collect.js/dist/methods/symbol.iterator.js

@@ -0,0 +1,18 @@
+'use strict';
+
+module.exports = function SymbolIterator() {
+  var _this = this;
+
+  var index = -1;
+
+  return {
+    next: function next() {
+      index += 1;
+
+      return {
+        value: _this.items[index],
+        done: index >= _this.items.length
+      };
+    }
+  };
+};