rambda 8.2.0 → 8.4.0

package/dist/rambda.js

@@ -33,26 +33,7 @@ function _concat(set1, set2) {
   return result;
 }
 
-function _curryN(n, cache, fn) {
-  return function () {
-    let ci = 0;
-    let ai = 0;
-    const cl = cache.length;
-    const al = arguments.length;
-    const args = new Array(cl + al);
-    while (ci < cl) {
-      args[ci] = cache[ci];
-      ci++;
-    }
-    while (ai < al) {
-      args[cl + ai] = arguments[ai];
-      ai++;
-    }
-    const remaining = n - args.length;
-    return args.length >= n ? fn.apply(this, args) : _arity$1(remaining, _curryN(n, args, fn));
-  };
-}
-function _arity$1(n, fn) {
+function _arity(n, fn) {
   switch (n) {
     case 0:
       return function () {
@@ -100,12 +81,32 @@ function _arity$1(n, fn) {
       };
   }
 }
+
+function _curryN(n, cache, fn) {
+  return function () {
+    let ci = 0;
+    let ai = 0;
+    const cl = cache.length;
+    const al = arguments.length;
+    const args = new Array(cl + al);
+    while (ci < cl) {
+      args[ci] = cache[ci];
+      ci++;
+    }
+    while (ai < al) {
+      args[cl + ai] = arguments[ai];
+      ai++;
+    }
+    const remaining = n - args.length;
+    return args.length >= n ? fn.apply(this, args) : _arity(remaining, _curryN(n, args, fn));
+  };
+}
 function curryN(n, fn) {
   if (arguments.length === 1) return _fn => curryN(n, _fn);
   if (n > 10) {
     throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
   }
-  return _arity$1(n, _curryN(n, [], fn));
+  return _arity(n, _curryN(n, [], fn));
 }
 
 function addIndex(originalFunction, initialIndexFn = () => 0, loopIndexChange = x => x + 1) {
@@ -335,27 +336,35 @@ 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);
 
+function binary(fn) {
+  if (fn.length <= 2) return fn;
+  return (a, b) => fn(a, b);
+}
+
 function bind(fn, thisObj) {
   if (arguments.length === 1) {
     return _thisObj => bind(fn, _thisObj);
@@ -368,6 +377,8 @@ function both(f, g) {
   return (...input) => f(...input) && g(...input);
 }
 
+const call = (fn, ...inputs) => fn(...inputs);
+
 function chain(fn, list) {
   if (arguments.length === 1) {
     return _list => chain(fn, _list);
@@ -395,10 +406,6 @@ function clone(input) {
   return out;
 }
 
-function complement(fn) {
-  return (...input) => !fn(...input);
-}
-
 class ReduceStopper {
   constructor(value) {
     this.value = value;
@@ -425,56 +432,35 @@ function reduceFn(reducer, acc, list) {
 const reduce = curry(reduceFn);
 const reduceStopper = value => new ReduceStopper(value);
 
-function _arity(n, fn) {
-  switch (n) {
-    case 0:
-      return function () {
-        return fn.apply(this, arguments);
-      };
-    case 1:
-      return function (a0) {
-        return fn.apply(this, arguments);
-      };
-    case 2:
-      return function (a0, a1) {
-        return fn.apply(this, arguments);
-      };
-    case 3:
-      return function (a0, a1, a2) {
-        return fn.apply(this, arguments);
-      };
-    case 4:
-      return function (a0, a1, a2, a3) {
-        return fn.apply(this, arguments);
-      };
-    case 5:
-      return function (a0, a1, a2, a3, a4) {
-        return fn.apply(this, arguments);
-      };
-    case 6:
-      return function (a0, a1, a2, a3, a4, a5) {
-        return fn.apply(this, arguments);
-      };
-    case 7:
-      return function (a0, a1, a2, a3, a4, a5, a6) {
-        return fn.apply(this, arguments);
-      };
-    case 8:
-      return function (a0, a1, a2, a3, a4, a5, a6, a7) {
-        return fn.apply(this, arguments);
-      };
-    case 9:
-      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
-        return fn.apply(this, arguments);
-      };
-    case 10:
-      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-        return fn.apply(this, arguments);
-      };
-    default:
-      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
+function collectBy(fn, list) {
+  if (arguments.length === 1) {
+    return _list => collectBy(fn, _list);
+  }
+  const group = reduce((o, x) => {
+    const tag = fn(x);
+    if (o[tag] === undefined) {
+      o[tag] = [];
+    }
+    o[tag].push(x);
+    return o;
+  }, {}, list);
+  const newList = [];
+  for (const tag in group) {
+    newList.push(group[tag]);
   }
+  return newList;
 }
+
+function comparator(fn) {
+  return function (a, b) {
+    return fn(a, b) ? -1 : fn(b, a) ? 1 : 0;
+  };
+}
+
+function complement(fn) {
+  return (...input) => !fn(...input);
+}
+
 function _pipe(f, g) {
   return function () {
     return g.call(this, f.apply(this, arguments));
@@ -494,6 +480,49 @@ function compose() {
   return pipe.apply(this, Array.prototype.slice.call(arguments, 0).reverse());
 }
 
+function head(listOrString) {
+  if (typeof listOrString === 'string') return listOrString[0] || '';
+  return listOrString[0];
+}
+
+function identity(x) {
+  return x;
+}
+
+function reverse(listOrString) {
+  if (typeof listOrString === 'string') {
+    return listOrString.split('').reverse().join('');
+  }
+  const clone = listOrString.slice();
+  return clone.reverse();
+}
+
+function drop(howManyToDrop, listOrString) {
+  if (arguments.length === 1) return _list => drop(howManyToDrop, _list);
+  return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0);
+}
+
+function tail(listOrString) {
+  return drop(1, listOrString);
+}
+
+function pipeWith(xf, list) {
+  if (list.length <= 0) {
+    return identity;
+  }
+  const headList = head(list);
+  const tailList = tail(list);
+  return _arity(headList.length, function () {
+    return reduce(function (result, f) {
+      return xf.call(this, f, result);
+    }, headList.apply(this, arguments), tailList);
+  });
+}
+function composeWith(xf, list) {
+  if (arguments.length === 1) return _list => composeWith(xf, _list);
+  return pipeWith.apply(this, [xf, reverse(list)]);
+}
+
 function concat(x, y) {
   if (arguments.length === 1) return _y => concat(x, _y);
   return typeof x === 'string' ? `${x}${y}` : [...x, ...y];
@@ -624,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];
@@ -693,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;
@@ -758,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);
   }
@@ -814,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) {
@@ -841,16 +833,140 @@ 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;
 }
 
-function drop(howManyToDrop, listOrString) {
-  if (arguments.length === 1) return _list => drop(howManyToDrop, _list);
-  return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0);
-}
-
 function dropLast(howManyToDrop, listOrString) {
   if (arguments.length === 1) {
     return _listOrString => dropLast(howManyToDrop, _listOrString);
@@ -1211,32 +1327,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);
@@ -1244,11 +1334,6 @@ function hasPath(pathInput, obj) {
   return path(pathInput, obj) !== undefined;
 }
 
-function head(listOrString) {
-  if (typeof listOrString === 'string') return listOrString[0] || '';
-  return listOrString[0];
-}
-
 function _objectIs(a, b) {
   if (a === b) {
     return a !== 0 || 1 / a === 1 / b;
@@ -1262,10 +1347,6 @@ function identical(a, b) {
   return objectIs(a, b);
 }
 
-function identity(x) {
-  return x;
-}
-
 function ifElseFn(condition, onTrue, onFalse) {
   return (...input) => {
     const conditionResult = typeof condition === 'boolean' ? condition : condition(...input);
@@ -1334,7 +1415,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) {
@@ -1421,13 +1502,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));
 }
@@ -1546,56 +1620,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';
 }
@@ -1679,21 +1703,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);
@@ -1738,11 +1747,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]);
   };
 }
 
@@ -1918,14 +1928,6 @@ function replaceFn(pattern, replacer, str) {
 }
 const replace = curry(replaceFn);
 
-function reverse(listOrString) {
-  if (typeof listOrString === 'string') {
-    return listOrString.split('').reverse().join('');
-  }
-  const clone = listOrString.slice();
-  return clone.reverse();
-}
-
 function setFn(lens, replacer, x) {
   return over(lens, always(replacer), x);
 }
@@ -2042,11 +2044,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));
-}
-
-function tail(listOrString) {
-  return drop(1, listOrString);
+  return concat(filter(value => !includes$1(value, y), x), filter(value => !includes$1(value, x), y));
 }
 
 function takeLast(howMany, listOrString) {
@@ -2170,7 +2168,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;
 }
@@ -2326,7 +2324,6 @@ const zipWith = curry(zipWithFn);
 exports.F = F;
 exports.T = T;
 exports.__findHighestArity = __findHighestArity;
-exports._arity = _arity;
 exports._indexOf = _indexOf;
 exports._lastIndexOf = _lastIndexOf;
 exports._pipe = _pipe;
@@ -2348,14 +2345,21 @@ 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;
+exports.call = call;
 exports.chain = chain;
 exports.clamp = clamp;
 exports.clone = clone;
+exports.collectBy = collectBy;
+exports.comparator = comparator;
 exports.complement = complement;
 exports.compose = compose;
+exports.composeWith = composeWith;
 exports.concat = concat;
 exports.cond = cond;
 exports.converge = converge;
@@ -2371,6 +2375,7 @@ exports.difference = difference;
 exports.differenceWith = differenceWith;
 exports.differenceWithFn = differenceWithFn;
 exports.dissoc = dissoc;
+exports.dissocPath = dissocPath;
 exports.divide = divide;
 exports.drop = drop;
 exports.dropLast = dropLast;
@@ -2405,7 +2410,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;
@@ -2474,6 +2479,7 @@ exports.paths = paths;
 exports.pick = pick;
 exports.pickAll = pickAll;
 exports.pipe = pipe;
+exports.pipeWith = pipeWith;
 exports.pluck = pluck;
 exports.prepend = prepend;
 exports.product = product;
@@ -2488,6 +2494,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;