up n_m

node_modules/algoliasearch-helper/src/functions/compact.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function compact(array) {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+
+  return array.filter(Boolean);
+};

node_modules/algoliasearch-helper/src/functions/defaultsPure.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// NOTE: this behaves like lodash/defaults, but doesn't mutate the target
+// it also preserve keys order
+module.exports = function defaultsPure() {
+  var sources = Array.prototype.slice.call(arguments);
+
+  return sources.reduceRight(function (acc, source) {
+    Object.keys(Object(source)).forEach(function (key) {
+      if (source[key] === undefined) {
+        return;
+      }
+      if (acc[key] !== undefined) {
+        // remove if already added, so that we can add it in correct order
+        delete acc[key];
+      }
+      acc[key] = source[key];
+    });
+    return acc;
+  }, {});
+};

node_modules/algoliasearch-helper/src/functions/escapeFacetValue.js

@@ -0,0 +1,30 @@
+'use strict';
+
+/**
+ * Replaces a leading - with \-
+ * @private
+ * @param {any} value the facet value to replace
+ * @returns {any} the escaped facet value or the value if it was not a string
+ */
+function escapeFacetValue(value) {
+  if (typeof value !== 'string') return value;
+
+  return String(value).replace(/^-/, '\\-');
+}
+
+/**
+ * Replaces a leading \- with -
+ * @private
+ * @param {any} value the escaped facet value
+ * @returns {any} the unescaped facet value or the value if it was not a string
+ */
+function unescapeFacetValue(value) {
+  if (typeof value !== 'string') return value;
+
+  return value.replace(/^\\-/, '-');
+}
+
+module.exports = {
+  escapeFacetValue: escapeFacetValue,
+  unescapeFacetValue: unescapeFacetValue,
+};

node_modules/algoliasearch-helper/src/functions/find.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// @MAJOR can be replaced by native Array#find when we change support
+module.exports = function find(array, comparator) {
+  if (!Array.isArray(array)) {
+    return undefined;
+  }
+
+  for (var i = 0; i < array.length; i++) {
+    if (comparator(array[i])) {
+      return array[i];
+    }
+  }
+
+  return undefined;
+};

node_modules/algoliasearch-helper/src/functions/findIndex.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// @MAJOR can be replaced by native Array#findIndex when we change support
+module.exports = function find(array, comparator) {
+  if (!Array.isArray(array)) {
+    return -1;
+  }
+
+  for (var i = 0; i < array.length; i++) {
+    if (comparator(array[i])) {
+      return i;
+    }
+  }
+  return -1;
+};

node_modules/algoliasearch-helper/src/functions/formatSort.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var find = require('./find');
+
+/**
+ * Transform sort format from user friendly notation to lodash format
+ * @param {string[]} sortBy array of predicate of the form "attribute:order"
+ * @param {string[]} [defaults] array of predicate of the form "attribute:order"
+ * @return {array.<string[]>} array containing 2 elements : attributes, orders
+ */
+module.exports = function formatSort(sortBy, defaults) {
+  var defaultInstructions = (defaults || []).map(function (sort) {
+    return sort.split(':');
+  });
+
+  return sortBy.reduce(
+    function preparePredicate(out, sort) {
+      var sortInstruction = sort.split(':');
+
+      var matchingDefault = find(
+        defaultInstructions,
+        function (defaultInstruction) {
+          return defaultInstruction[0] === sortInstruction[0];
+        }
+      );
+
+      if (sortInstruction.length > 1 || !matchingDefault) {
+        out[0].push(sortInstruction[0]);
+        out[1].push(sortInstruction[1]);
+        return out;
+      }
+
+      out[0].push(matchingDefault[0]);
+      out[1].push(matchingDefault[1]);
+      return out;
+    },
+    [[], []]
+  );
+};

node_modules/algoliasearch-helper/src/functions/inherits.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function inherits(ctor, superCtor) {
+  ctor.prototype = Object.create(superCtor.prototype, {
+    constructor: {
+      value: ctor,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    },
+  });
+}
+
+module.exports = inherits;

node_modules/algoliasearch-helper/src/functions/intersection.js

@@ -0,0 +1,12 @@
+'use strict';
+
+function intersection(arr1, arr2) {
+  return arr1.filter(function (value, index) {
+    return (
+      arr2.indexOf(value) > -1 &&
+      arr1.indexOf(value) === index /* skips duplicates */
+    );
+  });
+}
+
+module.exports = intersection;

node_modules/algoliasearch-helper/src/functions/merge.js

@@ -0,0 +1,84 @@
+'use strict';
+
+function clone(value) {
+  if (typeof value === 'object' && value !== null) {
+    return _merge(Array.isArray(value) ? [] : {}, value);
+  }
+  return value;
+}
+
+function isObjectOrArrayOrFunction(value) {
+  return (
+    typeof value === 'function' ||
+    Array.isArray(value) ||
+    Object.prototype.toString.call(value) === '[object Object]'
+  );
+}
+
+function _merge(target, source) {
+  if (target === source) {
+    return target;
+  }
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (var key in source) {
+    if (
+      !Object.prototype.hasOwnProperty.call(source, key) ||
+      key === '__proto__' ||
+      key === 'constructor'
+    ) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    var sourceVal = source[key];
+    var targetVal = target[key];
+
+    if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    if (
+      isObjectOrArrayOrFunction(targetVal) &&
+      isObjectOrArrayOrFunction(sourceVal)
+    ) {
+      target[key] = _merge(targetVal, sourceVal);
+    } else {
+      target[key] = clone(sourceVal);
+    }
+  }
+  return target;
+}
+
+/**
+ * This method is like Object.assign, but recursively merges own and inherited
+ * enumerable keyed properties of source objects into the destination object.
+ *
+ * NOTE: this behaves like lodash/merge, but:
+ * - does mutate functions if they are a source
+ * - treats non-plain objects as plain
+ * - does not work for circular objects
+ * - treats sparse arrays as sparse
+ * - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays
+ *
+ * @param {Object} target The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ */
+function merge(target) {
+  if (!isObjectOrArrayOrFunction(target)) {
+    target = {};
+  }
+
+  for (var i = 1, l = arguments.length; i < l; i++) {
+    var source = arguments[i];
+
+    if (isObjectOrArrayOrFunction(source)) {
+      _merge(target, source);
+    }
+  }
+  return target;
+}
+
+module.exports = merge;

node_modules/algoliasearch-helper/src/functions/objectHasKeys.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function objectHasKeys(obj) {
+  return obj && Object.keys(obj).length > 0;
+}
+
+module.exports = objectHasKeys;

node_modules/algoliasearch-helper/src/functions/omit.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source === null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key;
+  var i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    // eslint-disable-next-line no-continue
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+module.exports = _objectWithoutPropertiesLoose;

node_modules/algoliasearch-helper/src/functions/orderBy.js

@@ -0,0 +1,80 @@
+'use strict';
+
+function compareAscending(value, other) {
+  if (value !== other) {
+    var valIsDefined = value !== undefined;
+    var valIsNull = value === null;
+
+    var othIsDefined = other !== undefined;
+    var othIsNull = other === null;
+
+    if (
+      (!othIsNull && value > other) ||
+      (valIsNull && othIsDefined) ||
+      !valIsDefined
+    ) {
+      return 1;
+    }
+    if (
+      (!valIsNull && value < other) ||
+      (othIsNull && valIsDefined) ||
+      !othIsDefined
+    ) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+/**
+ * @param {Array<object>} collection object with keys in attributes
+ * @param {Array<string>} iteratees attributes
+ * @param {Array<string>} orders asc | desc
+ * @return {Array<object>} sorted collection
+ */
+function orderBy(collection, iteratees, orders) {
+  if (!Array.isArray(collection)) {
+    return [];
+  }
+
+  if (!Array.isArray(orders)) {
+    orders = [];
+  }
+
+  var result = collection.map(function (value, index) {
+    return {
+      criteria: iteratees.map(function (iteratee) {
+        return value[iteratee];
+      }),
+      index: index,
+      value: value,
+    };
+  });
+
+  result.sort(function comparer(object, other) {
+    var index = -1;
+
+    while (++index < object.criteria.length) {
+      var res = compareAscending(object.criteria[index], other.criteria[index]);
+      if (res) {
+        if (index >= orders.length) {
+          return res;
+        }
+        if (orders[index] === 'desc') {
+          return -res;
+        }
+        return res;
+      }
+    }
+
+    // This ensures a stable sort in V8 and other engines.
+    // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
+    return object.index - other.index;
+  });
+
+  return result.map(function (res) {
+    return res.value;
+  });
+}
+
+module.exports = orderBy;

node_modules/algoliasearch-helper/src/functions/valToNumber.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function valToNumber(v) {
+  if (typeof v === 'number') {
+    return v;
+  } else if (typeof v === 'string') {
+    return parseFloat(v);
+  } else if (Array.isArray(v)) {
+    return v.map(valToNumber);
+  }
+
+  throw new Error(
+    'The value should be a number, a parsable string or an array of those.'
+  );
+}
+
+module.exports = valToNumber;