rambda 8.3.0 → 8.5.0

package/dist/rambda.js

@@ -336,24 +336,27 @@ function _isInteger(n) {
   return n << 0 === n;
 }
 const isInteger = Number.isInteger || _isInteger;
+const isIndexInteger = index => Number.isInteger(Number(index));
+
+function createPath(path, delimiter = '.') {
+  return typeof path === 'string' ? path.split(delimiter).map(x => isInteger(x) ? Number(x) : x) : path;
+}
 
 function assocPathFn(path, newValue, input) {
-  const pathArrValue = typeof path === 'string' ? path.split('.').map(x => isInteger(Number(x)) ? Number(x) : x) : path;
-  if (pathArrValue.length === 0) {
-    return newValue;
-  }
+  const pathArrValue = createPath(path);
+  if (pathArrValue.length === 0) return newValue;
   const index = pathArrValue[0];
   if (pathArrValue.length > 1) {
     const condition = typeof input !== 'object' || input === null || !input.hasOwnProperty(index);
-    const nextInput = condition ? isInteger(pathArrValue[1]) ? [] : {} : input[index];
+    const nextInput = condition ? isIndexInteger(pathArrValue[1]) ? [] : {} : input[index];
     newValue = assocPathFn(Array.prototype.slice.call(pathArrValue, 1), newValue, nextInput);
   }
-  if (isInteger(index) && isArray(input)) {
+  if (isIndexInteger(index) && isArray(input)) {
     const arr = cloneList(input);
     arr[index] = newValue;
     return arr;
   }
-  return assoc(index, newValue, input);
+  return assocFn(index, newValue, input);
 }
 const assocPath = curry(assocPathFn);
 
@@ -650,62 +653,46 @@ function type(input) {
 }
 
 function _lastIndexOf(valueToFind, list) {
-  if (!isArray(list)) {
-    throw new Error(`Cannot read property 'indexOf' of ${list}`);
-  }
+  if (!isArray(list)) throw new Error(`Cannot read property 'indexOf' of ${list}`);
   const typeOfValue = type(valueToFind);
-  if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue)) return list.lastIndexOf(valueToFind);
+  if (!['Array', 'NaN', 'Object', 'RegExp'].includes(typeOfValue)) return list.lastIndexOf(valueToFind);
   const {
     length
   } = list;
   let index = length;
   let foundIndex = -1;
-  while (--index > -1 && foundIndex === -1) {
-    if (equals(list[index], valueToFind)) {
-      foundIndex = index;
-    }
-  }
+  while (--index > -1 && foundIndex === -1) if (equals(list[index], valueToFind)) foundIndex = index;
   return foundIndex;
 }
 function _indexOf(valueToFind, list) {
-  if (!isArray(list)) {
-    throw new Error(`Cannot read property 'indexOf' of ${list}`);
-  }
+  if (!isArray(list)) throw new Error(`Cannot read property 'indexOf' of ${list}`);
   const typeOfValue = type(valueToFind);
-  if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue)) return list.indexOf(valueToFind);
+  if (!['Array', 'NaN', 'Object', 'RegExp'].includes(typeOfValue)) return list.indexOf(valueToFind);
   let index = -1;
   let foundIndex = -1;
   const {
     length
   } = list;
-  while (++index < length && foundIndex === -1) {
-    if (equals(list[index], valueToFind)) {
-      foundIndex = index;
-    }
-  }
+  while (++index < length && foundIndex === -1) if (equals(list[index], valueToFind)) foundIndex = index;
   return foundIndex;
 }
 function _arrayFromIterator(iter) {
   const list = [];
   let next;
-  while (!(next = iter.next()).done) {
-    list.push(next.value);
-  }
+  while (!(next = iter.next()).done) list.push(next.value);
   return list;
 }
-function _equalsSets(a, b) {
-  if (a.size !== b.size) {
-    return false;
-  }
+function _compareSets(a, b) {
+  if (a.size !== b.size) return false;
   const aList = _arrayFromIterator(a.values());
   const bList = _arrayFromIterator(b.values());
   const filtered = aList.filter(aInstance => _indexOf(aInstance, bList) === -1);
   return filtered.length === 0;
 }
-function parseError(maybeError) {
-  const typeofError = maybeError.__proto__.toString();
-  if (!['Error', 'TypeError'].includes(typeofError)) return [];
-  return [typeofError, maybeError.message];
+function compareErrors(a, b) {
+  if (a.message !== b.message) return false;
+  if (a.toString !== b.toString) return false;
+  return a.toString() === b.toString();
 }
 function parseDate(maybeDate) {
   if (!maybeDate.toDateString) return [false];
@@ -719,64 +706,43 @@ function equals(a, b) {
   if (arguments.length === 1) return _b => equals(a, _b);
   const aType = type(a);
   if (aType !== type(b)) return false;
-  if (aType === 'Function') {
-    return a.name === undefined ? false : a.name === b.name;
-  }
-  if (['NaN', 'Undefined', 'Null'].includes(aType)) return true;
-  if (aType === 'Number') {
+  if (aType === 'Function') return a.name === undefined ? false : a.name === b.name;
+  if (['NaN', 'Null', 'Undefined'].includes(aType)) return true;
+  if (['BigInt', 'Number'].includes(aType)) {
     if (Object.is(-0, a) !== Object.is(-0, b)) return false;
     return a.toString() === b.toString();
   }
-  if (['String', 'Boolean'].includes(aType)) {
-    return a.toString() === b.toString();
-  }
+  if (['Boolean', 'String'].includes(aType)) return a.toString() === b.toString();
   if (aType === 'Array') {
     const aClone = Array.from(a);
     const bClone = Array.from(b);
-    if (aClone.toString() !== bClone.toString()) {
-      return false;
-    }
+    if (aClone.toString() !== bClone.toString()) return false;
     let loopArrayFlag = true;
     aClone.forEach((aCloneInstance, aCloneIndex) => {
-      if (loopArrayFlag) {
-        if (aCloneInstance !== bClone[aCloneIndex] && !equals(aCloneInstance, bClone[aCloneIndex])) {
-          loopArrayFlag = false;
-        }
-      }
+      if (loopArrayFlag) if (aCloneInstance !== bClone[aCloneIndex] && !equals(aCloneInstance, bClone[aCloneIndex])) loopArrayFlag = false;
     });
     return loopArrayFlag;
   }
   const aRegex = parseRegex(a);
   const bRegex = parseRegex(b);
-  if (aRegex[0]) {
-    return bRegex[0] ? aRegex[1] === bRegex[1] : false;
-  } else if (bRegex[0]) return false;
+  if (aRegex[0]) return bRegex[0] ? aRegex[1] === bRegex[1] : false;else if (bRegex[0]) return false;
   const aDate = parseDate(a);
   const bDate = parseDate(b);
-  if (aDate[0]) {
-    return bDate[0] ? aDate[1] === bDate[1] : false;
-  } else if (bDate[0]) return false;
-  const aError = parseError(a);
-  const bError = parseError(b);
-  if (aError[0]) {
-    return bError[0] ? aError[0] === bError[0] && aError[1] === bError[1] : false;
-  }
-  if (aType === 'Set') {
-    return _equalsSets(a, b);
+  if (aDate[0]) return bDate[0] ? aDate[1] === bDate[1] : false;else if (bDate[0]) return false;
+  if (a instanceof Error) {
+    if (!(b instanceof Error)) return false;
+    return compareErrors(a, b);
   }
+  if (aType === 'Set') return _compareSets(a, b);
   if (aType === 'Object') {
     const aKeys = Object.keys(a);
-    if (aKeys.length !== Object.keys(b).length) {
-      return false;
-    }
+    if (aKeys.length !== Object.keys(b).length) return false;
     let loopObjectFlag = true;
     aKeys.forEach(aKeyInstance => {
       if (loopObjectFlag) {
         const aValue = a[aKeyInstance];
         const bValue = b[aKeyInstance];
-        if (aValue !== bValue && !equals(aValue, bValue)) {
-          loopObjectFlag = false;
-        }
+        if (aValue !== bValue && !equals(aValue, bValue)) loopObjectFlag = false;
       }
     });
     return loopObjectFlag;
@@ -784,8 +750,8 @@ function equals(a, b) {
   return false;
 }
 
-function includes(valueToFind, iterable) {
-  if (arguments.length === 1) return _iterable => includes(valueToFind, _iterable);
+function includes$1(valueToFind, iterable) {
+  if (arguments.length === 1) return _iterable => includes$1(valueToFind, _iterable);
   if (typeof iterable === 'string') {
     return iterable.includes(valueToFind);
   }
@@ -840,7 +806,7 @@ function uniq(list) {
 
 function difference(a, b) {
   if (arguments.length === 1) return _b => difference(a, _b);
-  return uniq(a).filter(aInstance => !includes(aInstance, b));
+  return uniq(a).filter(aInstance => !includes$1(aInstance, b));
 }
 
 function differenceWithFn(fn, a, b) {
@@ -867,6 +833,135 @@ function dissoc(prop, obj) {
   return willReturn;
 }
 
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+function compare(a, b) {
+  return String(a) === String(b);
+}
+
+function includes(a, list) {
+  let index = -1;
+  const {
+    length
+  } = list;
+  while (++index < length) if (compare(list[index], a)) return true;
+  return false;
+}
+
+function omit(propsToOmit, obj) {
+  if (arguments.length === 1) return _obj => omit(propsToOmit, _obj);
+  if (obj === null || obj === undefined) return undefined;
+  const propsToOmitValue = createPath(propsToOmit, ',');
+  const willReturn = {};
+  for (const key in obj) if (!includes(key, propsToOmitValue)) willReturn[key] = obj[key];
+  return willReturn;
+}
+
+function pathFn(pathInput, obj) {
+  let willReturn = obj;
+  let counter = 0;
+  const pathArrValue = createPath(pathInput);
+  while (counter < pathArrValue.length) {
+    if (willReturn === null || willReturn === undefined) {
+      return undefined;
+    }
+    if (willReturn[pathArrValue[counter]] === null) return undefined;
+    willReturn = willReturn[pathArrValue[counter]];
+    counter++;
+  }
+  return willReturn;
+}
+function path(pathInput, obj) {
+  if (arguments.length === 1) return _obj => path(pathInput, _obj);
+  if (obj === null || obj === undefined) {
+    return undefined;
+  }
+  return pathFn(pathInput, obj);
+}
+
+function removeIndex(index, list) {
+  if (arguments.length === 1) return _list => removeIndex(index, _list);
+  if (index <= 0) return list.slice(1);
+  if (index >= list.length - 1) return list.slice(0, list.length - 1);
+  return [...list.slice(0, index), ...list.slice(index + 1)];
+}
+
+function updateFn(index, newValue, list) {
+  const clone = cloneList(list);
+  if (index === -1) return clone.fill(newValue, index);
+  return clone.fill(newValue, index, index + 1);
+}
+const update = curry(updateFn);
+
+function dissocPath(pathInput, input) {
+  if (arguments.length === 1) return _obj => dissocPath(pathInput, _obj);
+  const pathArrValue = createPath(pathInput);
+  if (pathArrValue.length === 0) return input;
+  const pathResult = path(pathArrValue, input);
+  if (pathResult === undefined) return input;
+  const index = pathArrValue[0];
+  const condition = typeof input !== 'object' || input === null || !input.hasOwnProperty(index);
+  if (pathArrValue.length > 1) {
+    const nextInput = condition ? isIndexInteger(pathArrValue[1]) ? [] : {} : input[index];
+    const nextPathInput = Array.prototype.slice.call(pathArrValue, 1);
+    const intermediateResult = dissocPath(nextPathInput, nextInput, input);
+    if (isArray(input)) return update(index, intermediateResult, input);
+    return _objectSpread2(_objectSpread2({}, input), {}, {
+      [index]: intermediateResult
+    });
+  }
+  if (isArray(input)) return removeIndex(index, input);
+  return omit([index], input);
+}
+
 function divide(a, b) {
   if (arguments.length === 1) return _b => divide(a, _b);
   return a / b;
@@ -920,6 +1015,21 @@ function dropRepeats(list) {
   return toReturn;
 }
 
+function dropRepeatsBy(fn, list) {
+  if (arguments.length === 1) return _list => dropRepeatsBy(fn, _list);
+  let lastEvaluated = null;
+  return list.slice().filter(item => {
+    if (lastEvaluated === null) {
+      lastEvaluated = fn(item);
+      return true;
+    }
+    const evaluatedResult = fn(item);
+    if (equals(lastEvaluated, evaluatedResult)) return false;
+    lastEvaluated = evaluatedResult;
+    return true;
+  });
+}
+
 function dropRepeatsWith(predicate, list) {
   if (arguments.length === 1) {
     return _iterable => dropRepeatsWith(predicate, _iterable);
@@ -971,6 +1081,19 @@ function either(firstPredicate, secondPredicate) {
   return (...input) => Boolean(firstPredicate(...input) || secondPredicate(...input));
 }
 
+function empty(list) {
+  if (typeof list === 'string') return '';
+  if (Array.isArray(list)) {
+    const {
+      name
+    } = list.constructor;
+    if (name === 'Uint8Array') return Uint8Array.from('');
+    if (name === 'Float32Array') return new Float32Array([]);
+    return [];
+  }
+  if (type(list) === 'Object') return {};
+}
+
 function endsWith(target, iterable) {
   if (arguments.length === 1) return _iterable => endsWith(target, _iterable);
   if (typeof iterable === 'string') {
@@ -988,6 +1111,11 @@ function endsWith(target, iterable) {
   return filtered.length === target.length;
 }
 
+function eqByFn(fn, a, b) {
+  return equals(fn(a), fn(b));
+}
+const eqBy = curry(eqByFn);
+
 function prop(propToFind, obj) {
   if (arguments.length === 1) return _obj => prop(propToFind, _obj);
   if (!obj) return undefined;
@@ -1151,29 +1279,34 @@ function flip(fn) {
   return flipFn(fn);
 }
 
-function forEach(fn, list) {
-  if (arguments.length === 1) return _list => forEach(fn, _list);
-  if (list === undefined) {
-    return;
+function forEachObjIndexedFn(fn, obj) {
+  let index = 0;
+  const listKeys = keys$1(obj);
+  const len = listKeys.length;
+  while (index < len) {
+    const key = listKeys[index];
+    fn(obj[key], key, obj);
+    index++;
   }
-  if (isArray(list)) {
-    let index = 0;
-    const len = list.length;
-    while (index < len) {
-      fn(list[index]);
-      index++;
-    }
-  } else {
+  return obj;
+}
+function forEachObjIndexed(fn, list) {
+  if (arguments.length === 1) return _list => forEachObjIndexed(fn, _list);
+  if (list === undefined) return;
+  return forEachObjIndexedFn(fn, list);
+}
+function forEach(fn, iterable) {
+  if (arguments.length === 1) return _list => forEach(fn, _list);
+  if (iterable === undefined) return;
+  if (isArray(iterable)) {
     let index = 0;
-    const listKeys = keys$1(list);
-    const len = listKeys.length;
+    const len = iterable.length;
     while (index < len) {
-      const key = listKeys[index];
-      fn(list[key], key, list);
+      fn(iterable[index]);
       index++;
     }
-  }
-  return list;
+  } else return forEachObjIndexedFn(fn, iterable);
+  return iterable;
 }
 
 function fromPairs(listOfPairs) {
@@ -1232,32 +1365,6 @@ function has(prop, obj) {
   return obj.hasOwnProperty(prop);
 }
 
-function createPath(path, delimiter = '.') {
-  return typeof path === 'string' ? path.split(delimiter) : path;
-}
-
-function pathFn(pathInput, obj) {
-  let willReturn = obj;
-  let counter = 0;
-  const pathArrValue = createPath(pathInput);
-  while (counter < pathArrValue.length) {
-    if (willReturn === null || willReturn === undefined) {
-      return undefined;
-    }
-    if (willReturn[pathArrValue[counter]] === null) return undefined;
-    willReturn = willReturn[pathArrValue[counter]];
-    counter++;
-  }
-  return willReturn;
-}
-function path(pathInput, obj) {
-  if (arguments.length === 1) return _obj => path(pathInput, _obj);
-  if (obj === null || obj === undefined) {
-    return undefined;
-  }
-  return pathFn(pathInput, obj);
-}
-
 function hasPath(pathInput, obj) {
   if (arguments.length === 1) {
     return objHolder => hasPath(pathInput, objHolder);
@@ -1346,7 +1453,7 @@ function init(listOrString) {
 
 function intersection(listA, listB) {
   if (arguments.length === 1) return _list => intersection(listA, _list);
-  return filter(x => includes(x, listA), listB);
+  return filter(x => includes$1(x, listA), listB);
 }
 
 function intersperse(separator, list) {
@@ -1433,13 +1540,6 @@ function nth(index, input) {
   return Object.prototype.toString.call(input) === '[object String]' ? input.charAt(idx) : input[idx];
 }
 
-function updateFn(index, newValue, list) {
-  const clone = cloneList(list);
-  if (index === -1) return clone.fill(newValue, index);
-  return clone.fill(newValue, index, index + 1);
-}
-const update = curry(updateFn);
-
 function lensIndex(index) {
   return lens(nth(index), update(index));
 }
@@ -1530,19 +1630,11 @@ function mergeWithFn(mergeFn, aInput, bInput) {
   const b = bInput !== null && bInput !== void 0 ? bInput : {};
   const willReturn = {};
   Object.keys(a).forEach(key => {
-    if (b[key] === undefined) {
-      willReturn[key] = a[key];
-    } else {
-      willReturn[key] = mergeFn(a[key], b[key]);
-    }
+    if (b[key] === undefined) willReturn[key] = a[key];else willReturn[key] = mergeFn(a[key], b[key]);
   });
   Object.keys(b).forEach(key => {
     if (willReturn[key] !== undefined) return;
-    if (a[key] === undefined) {
-      willReturn[key] = b[key];
-    } else {
-      willReturn[key] = mergeFn(a[key], b[key]);
-    }
+    if (a[key] === undefined) willReturn[key] = b[key];else willReturn[key] = mergeFn(a[key], b[key]);
   });
   return willReturn;
 }
@@ -1558,56 +1650,6 @@ function minByFn(compareFn, x, y) {
 }
 const minBy = curry(minByFn);
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-  return target;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return (hint === "string" ? String : Number)(input);
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
-}
-
 function isIterable(input) {
   return Array.isArray(input) || type(input) === 'Object';
 }
@@ -1691,21 +1733,6 @@ function of(value) {
   return [value];
 }
 
-function omit(propsToOmit, obj) {
-  if (arguments.length === 1) return _obj => omit(propsToOmit, _obj);
-  if (obj === null || obj === undefined) {
-    return undefined;
-  }
-  const propsToOmitValue = createPath(propsToOmit, ',');
-  const willReturn = {};
-  for (const key in obj) {
-    if (!propsToOmitValue.includes(key)) {
-      willReturn[key] = obj[key];
-    }
-  }
-  return willReturn;
-}
-
 function on(binaryFn, unaryFn, a, b) {
   if (arguments.length === 3) {
     return _b => on(binaryFn, unaryFn, a, _b);
@@ -1750,11 +1777,12 @@ const over = curry(overFn);
 
 function partial(fn, ...args) {
   const len = fn.length;
+  const argList = args.length === 1 && isArray(args[0]) ? args[0] : args;
   return (...rest) => {
-    if (args.length + rest.length >= len) {
-      return fn(...args, ...rest);
+    if (argList.length + rest.length >= len) {
+      return fn(...argList, ...rest);
     }
-    return partial(fn, ...[...args, ...rest]);
+    return partial(fn, ...[...argList, ...rest]);
   };
 }
 
@@ -2046,7 +2074,7 @@ function symmetricDifference(x, y) {
   if (arguments.length === 1) {
     return _y => symmetricDifference(x, _y);
   }
-  return concat(filter(value => !includes(value, y), x), filter(value => !includes(value, x), y));
+  return concat(filter(value => !includes$1(value, y), x), filter(value => !includes$1(value, x), y));
 }
 
 function takeLast(howMany, listOrString) {
@@ -2170,7 +2198,7 @@ function union(x, y) {
   if (arguments.length === 1) return _y => union(x, _y);
   const toReturn = cloneList(x);
   y.forEach(yInstance => {
-    if (!includes(yInstance, x)) toReturn.push(yInstance);
+    if (!includes$1(yInstance, x)) toReturn.push(yInstance);
   });
   return toReturn;
 }
@@ -2347,7 +2375,9 @@ exports.applySpec = applySpec;
 exports.applyTo = applyTo;
 exports.ascend = ascend;
 exports.assoc = assoc;
+exports.assocFn = assocFn;
 exports.assocPath = assocPath;
+exports.assocPathFn = assocPathFn;
 exports.binary = binary;
 exports.bind = bind;
 exports.both = both;
@@ -2375,15 +2405,20 @@ exports.difference = difference;
 exports.differenceWith = differenceWith;
 exports.differenceWithFn = differenceWithFn;
 exports.dissoc = dissoc;
+exports.dissocPath = dissocPath;
 exports.divide = divide;
 exports.drop = drop;
 exports.dropLast = dropLast;
 exports.dropLastWhile = dropLastWhile;
 exports.dropRepeats = dropRepeats;
+exports.dropRepeatsBy = dropRepeatsBy;
 exports.dropRepeatsWith = dropRepeatsWith;
 exports.dropWhile = dropWhile;
 exports.either = either;
+exports.empty = empty;
 exports.endsWith = endsWith;
+exports.eqBy = eqBy;
+exports.eqByFn = eqByFn;
 exports.eqProps = eqProps;
 exports.equals = equals;
 exports.evolve = evolve;
@@ -2399,6 +2434,8 @@ exports.findLastIndex = findLastIndex;
 exports.flatten = flatten;
 exports.flip = flip;
 exports.forEach = forEach;
+exports.forEachObjIndexed = forEachObjIndexed;
+exports.forEachObjIndexedFn = forEachObjIndexedFn;
 exports.fromPairs = fromPairs;
 exports.groupBy = groupBy;
 exports.groupWith = groupWith;
@@ -2409,7 +2446,7 @@ exports.identical = identical;
 exports.identity = identity;
 exports.ifElse = ifElse;
 exports.inc = inc;
-exports.includes = includes;
+exports.includes = includes$1;
 exports.indexBy = indexBy;
 exports.indexOf = indexOf;
 exports.init = init;
@@ -2445,6 +2482,7 @@ exports.mergeDeepRight = mergeDeepRight;
 exports.mergeLeft = mergeLeft;
 exports.mergeRight = mergeRight;
 exports.mergeWith = mergeWith;
+exports.mergeWithFn = mergeWithFn;
 exports.min = min;
 exports.minBy = minBy;
 exports.minByFn = minByFn;
@@ -2493,6 +2531,7 @@ exports.reduce = reduce;
 exports.reduceFn = reduceFn;
 exports.reduceStopper = reduceStopper;
 exports.reject = reject;
+exports.removeIndex = removeIndex;
 exports.repeat = repeat;
 exports.replace = replace;
 exports.reverse = reverse;