rambda 7.3.0 → 7.5.0

package/dist/rambda.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function F() {
   return false;
 }
@@ -28,31 +26,25 @@ function adjustFn(index, replaceFn, list) {
   clone[actualIndex] = replaceFn(clone[actualIndex]);
   return clone;
 }
-
 const adjust = curry(adjustFn);
 
 function all(predicate, list) {
   if (arguments.length === 1) return _list => all(predicate, _list);
-
   for (let i = 0; i < list.length; i++) {
     if (!predicate(list[i])) return false;
   }
-
   return true;
 }
 
 function allPass(predicates) {
   return (...input) => {
     let counter = 0;
-
     while (counter < predicates.length) {
       if (!predicates[counter](...input)) {
         return false;
       }
-
       counter++;
     }
-
     return true;
   };
 }
@@ -69,30 +61,24 @@ function and(a, b) {
 function any(predicate, list) {
   if (arguments.length === 1) return _list => any(predicate, _list);
   let counter = 0;
-
   while (counter < list.length) {
     if (predicate(list[counter], counter)) {
       return true;
     }
-
     counter++;
   }
-
   return false;
 }
 
 function anyPass(predicates) {
   return (...input) => {
     let counter = 0;
-
     while (counter < predicates.length) {
       if (predicates[counter](...input)) {
         return true;
       }
-
       counter++;
     }
-
     return false;
   };
 }
@@ -109,7 +95,6 @@ function apply(fn, args) {
   if (arguments.length === 1) {
     return _args => apply(fn, _args);
   }
-
   return fn.apply(this, args);
 }
 
@@ -120,33 +105,26 @@ const {
 function __findHighestArity(spec, max = 0) {
   for (const key in spec) {
     if (spec.hasOwnProperty(key) === false || key === 'constructor') continue;
-
     if (typeof spec[key] === 'object') {
       max = Math.max(max, __findHighestArity(spec[key]));
     }
-
     if (typeof spec[key] === 'function') {
       max = Math.max(max, spec[key].length);
     }
   }
-
   return max;
 }
-
 function __filterUndefined() {
   const defined = [];
   let i = 0;
   const l = arguments.length;
-
   while (i < l) {
     if (typeof arguments[i] === 'undefined') break;
     defined[i] = arguments[i];
     i++;
   }
-
   return defined;
 }
-
 function __applySpecWithArity(spec, arity, cache) {
   const remaining = arity - cache.length;
   if (remaining === 1) return x => __applySpecWithArity(spec, arity, __filterUndefined(...cache, x));
@@ -154,52 +132,39 @@ function __applySpecWithArity(spec, arity, cache) {
   if (remaining === 3) return (x, y, z) => __applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y, z));
   if (remaining === 4) return (x, y, z, a) => __applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y, z, a));
   if (remaining > 4) return (...args) => __applySpecWithArity(spec, arity, __filterUndefined(...cache, ...args));
-
   if (isArray(spec)) {
     const ret = [];
     let i = 0;
     const l = spec.length;
-
     for (; i < l; i++) {
       if (typeof spec[i] === 'object' || isArray(spec[i])) {
         ret[i] = __applySpecWithArity(spec[i], arity, cache);
       }
-
       if (typeof spec[i] === 'function') {
         ret[i] = spec[i](...cache);
       }
     }
-
     return ret;
   }
-
   const ret = {};
-
   for (const key in spec) {
     if (spec.hasOwnProperty(key) === false || key === 'constructor') continue;
-
     if (typeof spec[key] === 'object') {
       ret[key] = __applySpecWithArity(spec[key], arity, cache);
       continue;
     }
-
     if (typeof spec[key] === 'function') {
       ret[key] = spec[key](...cache);
     }
   }
-
   return ret;
 }
-
 function applySpec(spec, ...args) {
   const arity = __findHighestArity(spec);
-
   if (arity === 0) {
     return () => ({});
   }
-
   const toReturn = __applySpecWithArity(spec, arity, args);
-
   return toReturn;
 }
 
@@ -208,39 +173,31 @@ function assocFn(prop, newValue, obj) {
     [prop]: newValue
   });
 }
-
 const assoc = curry(assocFn);
 
 function _isInteger(n) {
   return n << 0 === n;
 }
-
 const isInteger = Number.isInteger || _isInteger;
 
 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 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];
     newValue = assocPathFn(Array.prototype.slice.call(pathArrValue, 1), newValue, nextInput);
   }
-
   if (isInteger(index) && isArray(input)) {
     const arr = cloneList(input);
     arr[index] = newValue;
     return arr;
   }
-
   return assoc(index, newValue, input);
 }
-
 const assocPath = curry(assocPathFn);
 
 function _curryN(n, cache, fn) {
@@ -250,88 +207,71 @@ function _curryN(n, cache, fn) {
     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) {
   switch (n) {
     case 0:
       return function () {
         return fn.apply(this, arguments);
       };
-
     case 1:
       return function (_1) {
         return fn.apply(this, arguments);
       };
-
     case 2:
       return function (_1, _2) {
         return fn.apply(this, arguments);
       };
-
     case 3:
       return function (_1, _2, _3) {
         return fn.apply(this, arguments);
       };
-
     case 4:
       return function (_1, _2, _3, _4) {
         return fn.apply(this, arguments);
       };
-
     case 5:
       return function (_1, _2, _3, _4, _5) {
         return fn.apply(this, arguments);
       };
-
     case 6:
       return function (_1, _2, _3, _4, _5, _6) {
         return fn.apply(this, arguments);
       };
-
     case 7:
       return function (_1, _2, _3, _4, _5, _6, _7) {
         return fn.apply(this, arguments);
       };
-
     case 8:
       return function (_1, _2, _3, _4, _5, _6, _7, _8) {
         return fn.apply(this, arguments);
       };
-
     case 9:
       return function (_1, _2, _3, _4, _5, _6, _7, _8, _9) {
         return fn.apply(this, arguments);
       };
-
     default:
       return function (_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) {
         return fn.apply(this, arguments);
       };
   }
 }
-
 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));
 }
 
@@ -339,7 +279,6 @@ function bind(fn, thisObj) {
   if (arguments.length === 1) {
     return _thisObj => bind(fn, _thisObj);
   }
-
   return curryN(fn.length, (...args) => fn.apply(thisObj, args));
 }
 
@@ -352,7 +291,6 @@ function chain(fn, list) {
   if (arguments.length === 1) {
     return _list => chain(fn, _list);
   }
-
   return [].concat(...list.map(fn));
 }
 
@@ -360,23 +298,19 @@ function clampFn(min, max, input) {
   if (min > max) {
     throw new Error('min must not be greater than max in clamp(min, max, value)');
   }
-
   if (input >= min && input <= max) return input;
   if (input > max) return max;
   if (input < min) return min;
 }
-
 const clamp = curry(clampFn);
 
 function clone(input) {
   const out = isArray(input) ? Array(input.length) : {};
   if (input && input.getTime) return new Date(input.getTime());
-
   for (const key in input) {
     const v = input[key];
     out[key] = typeof v === 'object' && v !== null ? v.getTime ? new Date(v.getTime()) : clone(v) : v;
   }
-
   return out;
 }
 
@@ -388,27 +322,20 @@ class ReduceStopper {
   constructor(value) {
     this.value = value;
   }
-
 }
-
 function reduceFn(reducer, acc, list) {
   if (!isArray(list)) {
     throw new TypeError('reduce: list must be array or iterable');
   }
-
   let index = 0;
   const len = list.length;
-
   while (index < len) {
     acc = reducer(acc, list[index], index, list);
-
     if (acc instanceof ReduceStopper) {
       return acc.value;
     }
-
     index++;
   }
-
   return acc;
 }
 const reduce = curry(reduceFn);
@@ -420,57 +347,46 @@ function _arity(n, fn) {
       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');
   }
@@ -484,7 +400,6 @@ function pipe() {
   if (arguments.length === 0) {
     throw new Error('pipe requires at least one argument');
   }
-
   return _arity(arguments[0].length, reduceFn(_pipe, arguments[0], Array.prototype.slice.call(arguments, 1, Infinity)));
 }
 
@@ -492,7 +407,6 @@ function compose() {
   if (arguments.length === 0) {
     throw new Error('compose requires at least one argument');
   }
-
   return pipe.apply(this, Array.prototype.slice.call(arguments, 0).reverse());
 }
 
@@ -515,6 +429,8 @@ function cond(conditions) {
   };
 }
 
+const INCORRECT_ITERABLE_INPUT = 'Incorrect iterable input';
+
 const {
   keys: keys$1
 } = Object;
@@ -522,40 +438,33 @@ const {
 function mapArray(fn, list, isIndexed = false) {
   let index = 0;
   const willReturn = Array(list.length);
-
   while (index < list.length) {
     willReturn[index] = isIndexed ? fn(list[index], index) : fn(list[index]);
     index++;
   }
-
   return willReturn;
 }
 function mapObject(fn, obj) {
   if (arguments.length === 1) {
     return _obj => mapObject(fn, _obj);
   }
-
   let index = 0;
   const objKeys = keys$1(obj);
   const len = objKeys.length;
   const willReturn = {};
-
   while (index < len) {
     const key = objKeys[index];
     willReturn[key] = fn(obj[key], key, obj);
     index++;
   }
-
   return willReturn;
 }
 const mapObjIndexed = mapObject;
 function map(fn, iterable) {
   if (arguments.length === 1) return _iterable => map(fn, _iterable);
-
   if (!iterable) {
     throw new Error(INCORRECT_ITERABLE_INPUT);
   }
-
   if (isArray(iterable)) return mapArray(fn, iterable);
   return mapObject(fn, iterable);
 }
@@ -577,7 +486,6 @@ function count(predicate, list) {
   if (arguments.length === 1) {
     return _list => count(predicate, _list);
   }
-
   if (!isArray(list)) return 0;
   return list.filter(x => predicate(x)).length;
 }
@@ -586,11 +494,9 @@ function countBy(fn, list) {
   if (arguments.length === 1) {
     return _list => countBy(fn, _list);
   }
-
   const willReturn = {};
   list.forEach(item => {
     const key = fn(item);
-
     if (!willReturn[key]) {
       willReturn[key] = 1;
     } else {
@@ -605,12 +511,10 @@ const dec = x => x - 1;
 function isFalsy(input) {
   return input === undefined || input === null || Number.isNaN(input) === true;
 }
-
 function defaultTo(defaultArgument, input) {
   if (arguments.length === 1) {
     return _input => defaultTo(defaultArgument, _input);
   }
-
   return isFalsy(input) ? defaultArgument : input;
 }
 
@@ -622,7 +526,6 @@ function type(input) {
   } else if (Number.isNaN(input)) {
     return 'NaN';
   }
-
   const typeResult = Object.prototype.toString.call(input).slice(8, -1);
   return typeResult === 'AsyncFunction' ? 'Promise' : typeResult;
 }
@@ -631,7 +534,6 @@ function _lastIndexOf(valueToFind, 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);
   const {
@@ -639,20 +541,17 @@ function _lastIndexOf(valueToFind, list) {
   } = list;
   let index = length;
   let foundIndex = -1;
-
   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}`);
   }
-
   const typeOfValue = type(valueToFind);
   if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue)) return list.indexOf(valueToFind);
   let index = -1;
@@ -660,85 +559,64 @@ function _indexOf(valueToFind, list) {
   const {
     length
   } = list;
-
   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);
   }
-
   return list;
 }
-
 function _equalsSets(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 parseDate(maybeDate) {
   if (!maybeDate.toDateString) return [false];
   return [true, maybeDate.getTime()];
 }
-
 function parseRegex(maybeRegex) {
   if (maybeRegex.constructor !== RegExp) return [false];
   return [true, maybeRegex.toString()];
 }
-
 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 (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 (aType === 'Array') {
     const aClone = Array.from(a);
     const bClone = Array.from(b);
-
     if (aClone.toString() !== bClone.toString()) {
       return false;
     }
-
     let loopArrayFlag = true;
     aClone.forEach((aCloneInstance, aCloneIndex) => {
       if (loopArrayFlag) {
@@ -749,45 +627,34 @@ function equals(a, b) {
     });
     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;
-
   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 (aType === 'Object') {
     const aKeys = Object.keys(a);
-
     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;
         }
@@ -795,21 +662,17 @@ function equals(a, b) {
     });
     return loopObjectFlag;
   }
-
   return false;
 }
 
 function includes(valueToFind, iterable) {
   if (arguments.length === 1) return _iterable => includes(valueToFind, _iterable);
-
   if (typeof iterable === 'string') {
     return iterable.includes(valueToFind);
   }
-
   if (!iterable) {
     throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`);
   }
-
   if (!isArray(iterable)) return false;
   return _indexOf(valueToFind, iterable) > -1;
 }
@@ -819,38 +682,30 @@ class _Set {
     this.set = new Set();
     this.items = {};
   }
-
   checkUniqueness(item) {
     const type$1 = type(item);
-
     if (['Null', 'Undefined', 'NaN'].includes(type$1)) {
       if (type$1 in this.items) {
         return false;
       }
-
       this.items[type$1] = true;
       return true;
     }
-
     if (!['Object', 'Array'].includes(type$1)) {
       const prevSize = this.set.size;
       this.set.add(item);
       return this.set.size !== prevSize;
     }
-
     if (!(type$1 in this.items)) {
       this.items[type$1] = [item];
       return true;
     }
-
     if (_indexOf(item, this.items[type$1]) === -1) {
       this.items[type$1].push(item);
       return true;
     }
-
     return false;
   }
-
 }
 
 function uniq(list) {
@@ -873,11 +728,9 @@ function dissoc(prop, obj) {
   if (arguments.length === 1) return _obj => dissoc(prop, _obj);
   if (obj === null || obj === undefined) return {};
   const willReturn = {};
-
   for (const p in obj) {
     willReturn[p] = obj[p];
   }
-
   delete willReturn[prop];
   return willReturn;
 }
@@ -896,7 +749,6 @@ function dropLast(howManyToDrop, listOrString) {
   if (arguments.length === 1) {
     return _listOrString => dropLast(howManyToDrop, _listOrString);
   }
-
   return howManyToDrop > 0 ? listOrString.slice(0, -howManyToDrop) : listOrString.slice();
 }
 
@@ -904,33 +756,26 @@ function dropLastWhile(predicate, iterable) {
   if (arguments.length === 1) {
     return _iterable => dropLastWhile(predicate, _iterable);
   }
-
   if (iterable.length === 0) return iterable;
   const isArray$1 = isArray(iterable);
-
   if (typeof predicate !== 'function') {
     throw new Error(`'predicate' is from wrong type ${typeof predicate}`);
   }
-
   if (!isArray$1 && typeof iterable !== 'string') {
     throw new Error(`'iterable' is from wrong type ${typeof iterable}`);
   }
-
-  let found = false;
   const toReturn = [];
   let counter = iterable.length;
-
-  while (counter > 0) {
-    counter--;
-
-    if (!found && predicate(iterable[counter]) === false) {
-      found = true;
-      toReturn.push(iterable[counter]);
-    } else if (found) {
-      toReturn.push(iterable[counter]);
+  while (counter) {
+    const item = iterable[--counter];
+    if (!predicate(item)) {
+      toReturn.push(item);
+      break;
     }
   }
-
+  while (counter) {
+    toReturn.push(iterable[--counter]);
+  }
   return isArray$1 ? toReturn.reverse() : toReturn.reverse().join('');
 }
 
@@ -938,13 +783,11 @@ function dropRepeats(list) {
   if (!isArray(list)) {
     throw new Error(`${list} is not a list`);
   }
-
   const toReturn = [];
   list.reduce((prev, current) => {
     if (!equals(prev, current)) {
       toReturn.push(current);
     }
-
     return current;
   }, undefined);
   return toReturn;
@@ -954,22 +797,18 @@ function dropRepeatsWith(predicate, list) {
   if (arguments.length === 1) {
     return _iterable => dropRepeatsWith(predicate, _iterable);
   }
-
   if (!isArray(list)) {
     throw new Error(`${list} is not a list`);
   }
-
   const toReturn = [];
   list.reduce((prev, current) => {
     if (prev === undefined) {
       toReturn.push(current);
       return current;
     }
-
     if (!predicate(prev, current)) {
       toReturn.push(current);
     }
-
     return current;
   }, undefined);
   return toReturn;
@@ -979,44 +818,37 @@ function dropWhile(predicate, iterable) {
   if (arguments.length === 1) {
     return _iterable => dropWhile(predicate, _iterable);
   }
-
   const isArray$1 = isArray(iterable);
-
   if (!isArray$1 && typeof iterable !== 'string') {
     throw new Error('`iterable` is neither list nor a string');
   }
-
-  let flag = false;
-  const holder = [];
-  let counter = -1;
-
-  while (counter++ < iterable.length - 1) {
-    if (flag) {
-      holder.push(iterable[counter]);
-    } else if (!predicate(iterable[counter])) {
-      if (!flag) flag = true;
-      holder.push(iterable[counter]);
+  const toReturn = [];
+  let counter = 0;
+  while (counter < iterable.length) {
+    const item = iterable[counter++];
+    if (!predicate(item)) {
+      toReturn.push(item);
+      break;
     }
   }
-
-  return isArray$1 ? holder : holder.join('');
+  while (counter < iterable.length) {
+    toReturn.push(iterable[counter++]);
+  }
+  return isArray$1 ? toReturn : toReturn.join('');
 }
 
 function either(firstPredicate, secondPredicate) {
   if (arguments.length === 1) {
     return _secondPredicate => either(firstPredicate, _secondPredicate);
   }
-
   return (...input) => Boolean(firstPredicate(...input) || secondPredicate(...input));
 }
 
 function endsWith(target, iterable) {
   if (arguments.length === 1) return _iterable => endsWith(target, _iterable);
-
   if (typeof iterable === 'string') {
     return iterable.endsWith(target);
   }
-
   if (!isArray(target)) return false;
   const diff = iterable.length - target.length;
   let correct = true;
@@ -1038,7 +870,6 @@ function prop(propToFind, obj) {
 function eqPropsFn(property, objA, objB) {
   return equals(prop(property, objA), prop(property, objB));
 }
-
 const eqProps = curry(eqPropsFn);
 
 function evolveArray(rules, list) {
@@ -1046,7 +877,6 @@ function evolveArray(rules, list) {
     if (type(rules[i]) === 'Function') {
       return rules[i](x);
     }
-
     return x;
   }, list, true);
 }
@@ -1054,22 +884,17 @@ function evolveObject(rules, iterable) {
   return mapObject((x, prop) => {
     if (type(x) === 'Object') {
       const typeRule = type(rules[prop]);
-
       if (typeRule === 'Function') {
         return rules[prop](x);
       }
-
       if (typeRule === 'Object') {
         return evolve(rules[prop], x);
       }
-
       return x;
     }
-
     if (type(rules[prop]) === 'Function') {
       return rules[prop](x);
     }
-
     return x;
   }, iterable);
 }
@@ -1077,60 +902,47 @@ function evolve(rules, iterable) {
   if (arguments.length === 1) {
     return _iterable => evolve(rules, _iterable);
   }
-
   const rulesType = type(rules);
   const iterableType = type(iterable);
-
   if (iterableType !== rulesType) {
     throw new Error('iterableType !== rulesType');
   }
-
   if (!['Object', 'Array'].includes(rulesType)) {
     throw new Error(`'iterable' and 'rules' are from wrong type ${rulesType}`);
   }
-
   if (iterableType === 'Object') {
     return evolveObject(rules, iterable);
   }
-
   return evolveArray(rules, iterable);
 }
 
 function filterObject(predicate, obj) {
   const willReturn = {};
-
   for (const prop in obj) {
     if (predicate(obj[prop], prop, obj)) {
       willReturn[prop] = obj[prop];
     }
   }
-
   return willReturn;
 }
 function filterArray(predicate, list, indexed = false) {
   let index = 0;
   const len = list.length;
   const willReturn = [];
-
   while (index < len) {
     const predicateResult = indexed ? predicate(list[index], index) : predicate(list[index]);
-
     if (predicateResult) {
       willReturn.push(list[index]);
     }
-
     index++;
   }
-
   return willReturn;
 }
 function filter(predicate, iterable) {
   if (arguments.length === 1) return _iterable => filter(predicate, _iterable);
-
   if (!iterable) {
     throw new Error('Incorrect iterable input');
   }
-
   if (isArray(iterable)) return filterArray(predicate, iterable, false);
   return filterObject(predicate, iterable);
 }
@@ -1139,14 +951,11 @@ function find(predicate, list) {
   if (arguments.length === 1) return _list => find(predicate, _list);
   let index = 0;
   const len = list.length;
-
   while (index < len) {
     const x = list[index];
-
     if (predicate(x)) {
       return x;
     }
-
     index++;
   }
 }
@@ -1155,45 +964,38 @@ function findIndex(predicate, list) {
   if (arguments.length === 1) return _list => findIndex(predicate, _list);
   const len = list.length;
   let index = -1;
-
   while (++index < len) {
     if (predicate(list[index])) {
       return index;
     }
   }
-
   return -1;
 }
 
 function findLast(predicate, list) {
   if (arguments.length === 1) return _list => findLast(predicate, _list);
   let index = list.length;
-
   while (--index >= 0) {
     if (predicate(list[index])) {
       return list[index];
     }
   }
-
   return undefined;
 }
 
 function findLastIndex(fn, list) {
   if (arguments.length === 1) return _list => findLastIndex(fn, _list);
   let index = list.length;
-
   while (--index >= 0) {
     if (fn(list[index])) {
       return index;
     }
   }
-
   return -1;
 }
 
 function flatten(list, input) {
   const willReturn = input === undefined ? [] : input;
-
   for (let i = 0; i < list.length; i++) {
     if (isArray(list[i])) {
       flatten(list[i], willReturn);
@@ -1201,7 +1003,6 @@ function flatten(list, input) {
       willReturn.push(list[i]);
     }
   }
-
   return willReturn;
 }
 
@@ -1216,26 +1017,21 @@ function flipFn(fn) {
     } else if (input.length === 4) {
       return fn(input[1], input[0], input[2], input[3]);
     }
-
     throw new Error('R.flip doesn\'t work with arity > 4');
   };
 }
-
 function flip(fn) {
   return flipFn(fn);
 }
 
 function forEach(fn, list) {
   if (arguments.length === 1) return _list => forEach(fn, _list);
-
   if (list === undefined) {
     return;
   }
-
   if (isArray(list)) {
     let index = 0;
     const len = list.length;
-
     while (index < len) {
       fn(list[index]);
       index++;
@@ -1244,14 +1040,12 @@ function forEach(fn, list) {
     let index = 0;
     const listKeys = keys$1(list);
     const len = listKeys.length;
-
     while (index < len) {
       const key = listKeys[index];
       fn(list[key], key, list);
       index++;
     }
   }
-
   return list;
 }
 
@@ -1264,18 +1058,14 @@ function fromPairs(listOfPairs) {
 function groupBy(groupFn, list) {
   if (arguments.length === 1) return _list => groupBy(groupFn, _list);
   const result = {};
-
   for (let i = 0; i < list.length; i++) {
     const item = list[i];
     const key = groupFn(item);
-
     if (!result[key]) {
       result[key] = [];
     }
-
     result[key].push(item);
   }
-
   return result;
 }
 
@@ -1290,20 +1080,17 @@ function groupWith(compareFn, list) {
     const okCompare = compareFn(prev, current);
     const holderIsEmpty = holder.length === 0;
     const lastCall = i === list.length - 1;
-
     if (okCompare) {
       if (holderIsEmpty) holder.push(prev);
       holder.push(current);
       if (lastCall) toReturn.push(holder);
       return current;
     }
-
     if (holderIsEmpty) {
       toReturn.push([prev]);
       if (lastCall) toReturn.push([current]);
       return current;
     }
-
     toReturn.push(holder);
     if (lastCall) toReturn.push([current]);
     holder = [];
@@ -1324,25 +1111,20 @@ function createPath(path, delimiter = '.') {
 
 function path(pathInput, obj) {
   if (arguments.length === 1) return _obj => path(pathInput, _obj);
-
   if (obj === null || obj === undefined) {
     return undefined;
   }
-
   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;
 }
 
@@ -1350,7 +1132,6 @@ function hasPath(pathInput, obj) {
   if (arguments.length === 1) {
     return objHolder => hasPath(pathInput, objHolder);
   }
-
   return path(pathInput, obj) !== undefined;
 }
 
@@ -1363,10 +1144,8 @@ function _objectIs(a, b) {
   if (a === b) {
     return a !== 0 || 1 / a === 1 / b;
   }
-
   return a !== a && b !== b;
 }
-
 const objectIs = Object.is || _objectIs;
 
 function identical(a, b) {
@@ -1381,46 +1160,36 @@ function identity(x) {
 function ifElseFn(condition, onTrue, onFalse) {
   return (...input) => {
     const conditionResult = typeof condition === 'boolean' ? condition : condition(...input);
-
     if (conditionResult === true) {
       return onTrue(...input);
     }
-
     return onFalse(...input);
   };
 }
-
 const ifElse = curry(ifElseFn);
 
 const inc = x => x + 1;
 
 function indexByPath(pathInput, list) {
   const toReturn = {};
-
   for (let i = 0; i < list.length; i++) {
     const item = list[i];
     toReturn[path(pathInput, item)] = item;
   }
-
   return toReturn;
 }
-
 function indexBy(condition, list) {
   if (arguments.length === 1) {
     return _list => indexBy(condition, _list);
   }
-
   if (typeof condition === 'string') {
     return indexByPath(condition, list);
   }
-
   const toReturn = {};
-
   for (let i = 0; i < list.length; i++) {
     const item = list[i];
     toReturn[condition(item)] = item;
   }
-
   return toReturn;
 }
 
@@ -1428,7 +1197,6 @@ function indexOf(valueToFind, list) {
   if (arguments.length === 1) {
     return _list => _indexOf(valueToFind, _list);
   }
-
   return _indexOf(valueToFind, list);
 }
 
@@ -1438,19 +1206,15 @@ function baseSlice(array, start, end) {
     length
   } = array;
   end = end > length ? length : end;
-
   if (end < 0) {
     end += length;
   }
-
   length = start > end ? 0 : end - start >>> 0;
   start >>>= 0;
   const result = Array(length);
-
   while (++index < length) {
     result[index] = array[index + start];
   }
-
   return result;
 }
 
@@ -1469,7 +1233,6 @@ function intersperse(separator, list) {
   let index = -1;
   const len = list.length;
   const willReturn = [];
-
   while (++index < len) {
     if (index === len - 1) {
       willReturn.push(list[index]);
@@ -1477,7 +1240,6 @@ function intersperse(separator, list) {
       willReturn.push(list[index], separator);
     }
   }
-
   return willReturn;
 }
 
@@ -1490,15 +1252,12 @@ function isEmpty(input) {
   const inputType = type(input);
   if (['Undefined', 'NaN', 'Number', 'Null'].includes(inputType)) return false;
   if (!input) return true;
-
   if (inputType === 'Object') {
     return Object.keys(input).length === 0;
   }
-
   if (inputType === 'Array') {
     return input.length === 0;
   }
-
   return false;
 }
 
@@ -1523,7 +1282,6 @@ function last(listOrString) {
   if (typeof listOrString === 'string') {
     return listOrString[listOrString.length - 1] || '';
   }
-
   return listOrString[listOrString.length - 1];
 }
 
@@ -1531,7 +1289,6 @@ function lastIndexOf(valueToFind, list) {
   if (arguments.length === 1) {
     return _list => _lastIndexOf(valueToFind, _list);
   }
-
   return _lastIndexOf(valueToFind, list);
 }
 
@@ -1627,7 +1384,6 @@ function mergeDeepRight(target, source) {
   if (arguments.length === 1) {
     return sourceHolder => mergeDeepRight(target, sourceHolder);
   }
-
   const willReturn = clone(target);
   Object.keys(source).forEach(key => {
     if (type(source[key]) === 'Object') {
@@ -1659,7 +1415,6 @@ function mergeWithFn(mergeFn, a, b) {
   });
   Object.keys(b).forEach(key => {
     if (willReturn[key] !== undefined) return;
-
     if (a[key] === undefined) {
       willReturn[key] = b[key];
     } else {
@@ -1668,7 +1423,6 @@ function mergeWithFn(mergeFn, a, b) {
   });
   return willReturn;
 }
-
 const mergeWith = curry(mergeWithFn);
 
 function min(x, y) {
@@ -1683,17 +1437,14 @@ 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] : {};
@@ -1703,10 +1454,8 @@ function _objectSpread2(target) {
       Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
     });
   }
-
   return target;
 }
-
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -1718,7 +1467,6 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
@@ -1729,34 +1477,27 @@ function isIterable(input) {
 function modifyFn(property, fn, iterable) {
   if (!isIterable(iterable)) return iterable;
   if (iterable[property] === undefined) return iterable;
-
   if (isArray(iterable)) {
     return updateFn(property, fn(iterable[property]), iterable);
   }
-
   return _objectSpread2(_objectSpread2({}, iterable), {}, {
     [property]: fn(iterable[property])
   });
 }
-
 const modify = curry(modifyFn);
 
 function modifyPathFn(pathInput, fn, object) {
   const path$1 = createPath(pathInput);
-
   if (path$1.length === 1) {
     return _objectSpread2(_objectSpread2({}, object), {}, {
       [path$1[0]]: fn(object[path$1[0]])
     });
   }
-
   if (path(path$1, object) === undefined) return object;
   const val = modifyPath(Array.prototype.slice.call(path$1, 1), fn, object[path$1[0]]);
-
   if (val === object[path$1[0]]) {
     return object;
   }
-
   return assoc(path$1[0], val, object);
 }
 const modifyPath = curry(modifyPathFn);
@@ -1770,14 +1511,12 @@ function moveFn(fromIndex, toIndex, list) {
   if (fromIndex < 0 || toIndex < 0) {
     throw new Error('Rambda.move does not support negative indexes');
   }
-
   if (fromIndex > list.length - 1 || toIndex > list.length - 1) return list;
   const clone = cloneList(list);
   clone[fromIndex] = list[toIndex];
   clone[toIndex] = list[fromIndex];
   return clone;
 }
-
 const move = curry(moveFn);
 
 function multiply(x, y) {
@@ -1791,14 +1530,14 @@ function negate(x) {
 
 function none(predicate, list) {
   if (arguments.length === 1) return _list => none(predicate, _list);
-
   for (let i = 0; i < list.length; i++) {
     if (predicate(list[i])) return false;
   }
-
   return true;
 }
 
+function nop() {}
+
 function not(input) {
   return !input;
 }
@@ -1807,7 +1546,6 @@ function objOf(key, value) {
   if (arguments.length === 1) {
     return _value => objOf(key, _value);
   }
-
   return {
     [key]: value
   };
@@ -1819,20 +1557,16 @@ function of(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;
 }
 
@@ -1840,11 +1574,9 @@ function on(binaryFn, unaryFn, a, b) {
   if (arguments.length === 3) {
     return _b => on(binaryFn, unaryFn, a, _b);
   }
-
   if (arguments.length === 2) {
     return (_a, _b) => on(binaryFn, unaryFn, _a, _b);
   }
-
   return binaryFn(unaryFn(a), unaryFn(b));
 }
 
@@ -1855,17 +1587,14 @@ function onceFn(fn, context) {
       result = fn.apply(context || this, arguments);
       fn = null;
     }
-
     return result;
   };
 }
-
 function once(fn, context) {
   if (arguments.length === 1) {
     const wrap = onceFn(fn, context);
     return curry(wrap);
   }
-
   return onceFn(fn, context);
 }
 
@@ -1878,11 +1607,9 @@ const Identity = x => ({
   x,
   map: fn => Identity(fn(x))
 });
-
 function overFn(lens, fn, object) {
   return lens(x => Identity(fn(x)))(object).x;
 }
-
 const over = curry(overFn);
 
 function partial(fn, ...args) {
@@ -1891,7 +1618,6 @@ function partial(fn, ...args) {
     if (args.length + rest.length >= len) {
       return fn(...args, ...rest);
     }
-
     return partial(fn, ...[...args, ...rest]);
   };
 }
@@ -1916,7 +1642,6 @@ function partitionArray(predicate, list, indexed = false) {
   const yes = [];
   const no = [];
   let counter = -1;
-
   while (counter++ < list.length - 1) {
     if (indexed ? predicate(list[counter], counter) : predicate(list[counter])) {
       yes.push(list[counter]);
@@ -1924,14 +1649,12 @@ function partitionArray(predicate, list, indexed = false) {
       no.push(list[counter]);
     }
   }
-
   return [yes, no];
 }
 function partition(predicate, iterable) {
   if (arguments.length === 1) {
     return listHolder => partition(predicate, listHolder);
   }
-
   if (!isArray(iterable)) return partitionObject(predicate, iterable);
   return partitionArray(predicate, iterable);
 }
@@ -1939,66 +1662,53 @@ function partition(predicate, iterable) {
 function pathEqFn(pathToSearch, target, input) {
   return equals(path(pathToSearch, input), target);
 }
-
 const pathEq = curry(pathEqFn);
 
 function pathOrFn(defaultValue, pathInput, obj) {
   return defaultTo(defaultValue, path(pathInput, obj));
 }
-
 const pathOr = curry(pathOrFn);
 
 function paths(pathsToSearch, obj) {
   if (arguments.length === 1) {
     return _obj => paths(pathsToSearch, _obj);
   }
-
   return pathsToSearch.map(singlePath => path(singlePath, obj));
 }
 
 function pick(propsToPick, input) {
   if (arguments.length === 1) return _input => pick(propsToPick, _input);
-
   if (input === null || input === undefined) {
     return undefined;
   }
-
   const keys = createPath(propsToPick, ',');
   const willReturn = {};
   let counter = 0;
-
   while (counter < keys.length) {
     if (keys[counter] in input) {
       willReturn[keys[counter]] = input[keys[counter]];
     }
-
     counter++;
   }
-
   return willReturn;
 }
 
 function pickAll(propsToPick, obj) {
   if (arguments.length === 1) return _obj => pickAll(propsToPick, _obj);
-
   if (obj === null || obj === undefined) {
     return undefined;
   }
-
   const keysValue = createPath(propsToPick, ',');
   const willReturn = {};
   let counter = 0;
-
   while (counter < keysValue.length) {
     if (keysValue[counter] in obj) {
       willReturn[keysValue[counter]] = obj[keysValue[counter]];
     } else {
       willReturn[keysValue[counter]] = undefined;
     }
-
     counter++;
   }
-
   return willReturn;
 }
 
@@ -2025,55 +1735,45 @@ function propEqFn(propToFind, valueToMatch, obj) {
   if (!obj) return false;
   return equals(valueToMatch, prop(propToFind, obj));
 }
-
 const propEq = curry(propEqFn);
 
 function propIsFn(targetPrototype, property, obj) {
   return is(targetPrototype, obj[property]);
 }
-
 const propIs = curry(propIsFn);
 
 function propOrFn(defaultValue, property, obj) {
   if (!obj) return defaultValue;
   return defaultTo(defaultValue, obj[property]);
 }
-
 const propOr = curry(propOrFn);
 
 function propSatisfiesFn(predicate, property, obj) {
   return predicate(prop(property, obj));
 }
-
 const propSatisfies = curry(propSatisfiesFn);
 
 function props(propsToPick, obj) {
   if (arguments.length === 1) {
     return _obj => props(propsToPick, _obj);
   }
-
   if (!isArray(propsToPick)) {
     throw new Error('propsToPick is not a list');
   }
-
   return mapArray(prop => obj[prop], propsToPick);
 }
 
 function range(start, end) {
   if (arguments.length === 1) return _end => range(start, _end);
-
   if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
     throw new TypeError('Both arguments to range must be numbers');
   }
-
   if (end < start) return [];
   const len = end - start;
   const willReturn = Array(len);
-
   for (let i = 0; i < len; i++) {
     willReturn[i] = start + i;
   }
-
   return willReturn;
 }
 
@@ -2086,21 +1786,18 @@ function repeat(x, timesToRepeat) {
   if (arguments.length === 1) {
     return _timesToRepeat => repeat(x, _timesToRepeat);
   }
-
   return Array(timesToRepeat).fill(x);
 }
 
 function replaceFn(pattern, replacer, str) {
   return str.replace(pattern, replacer);
 }
-
 const replace = curry(replaceFn);
 
 function reverse(listOrString) {
   if (typeof listOrString === 'string') {
     return listOrString.split('').reverse().join('');
   }
-
   const clone = listOrString.slice();
   return clone.reverse();
 }
@@ -2108,13 +1805,11 @@ function reverse(listOrString) {
 function setFn(lens, replacer, x) {
   return over(lens, always(replacer), x);
 }
-
 const set = curry(setFn);
 
 function sliceFn(from, to, list) {
   return list.slice(from, to);
 }
-
 const slice = curry(sliceFn);
 
 function sort(sortFn, list) {
@@ -2155,7 +1850,6 @@ function splitAt(index, input) {
   if (arguments.length === 1) {
     return _list => splitAt(index, _list);
   }
-
   if (!input) throw new TypeError(`Cannot read property 'slice' of ${input}`);
   if (!isArray(input) && typeof input !== 'string') return [[], []];
   const correctIndex = maybe(index < 0, input.length + index < 0 ? 0 : input.length + index, index);
@@ -2166,18 +1860,14 @@ function splitEvery(sliceLength, listOrString) {
   if (arguments.length === 1) {
     return _listOrString => splitEvery(sliceLength, _listOrString);
   }
-
   if (sliceLength < 1) {
     throw new Error('First argument to splitEvery must be a positive integer');
   }
-
   const willReturn = [];
   let counter = 0;
-
   while (counter < listOrString.length) {
     willReturn.push(listOrString.slice(counter, counter += sliceLength));
   }
-
   return willReturn;
 }
 
@@ -2185,13 +1875,11 @@ function splitWhen(predicate, input) {
   if (arguments.length === 1) {
     return _input => splitWhen(predicate, _input);
   }
-
   if (!input) throw new TypeError(`Cannot read property 'length' of ${input}`);
   const preFound = [];
   const postFound = [];
   let found = false;
   let counter = -1;
-
   while (counter++ < input.length - 1) {
     if (found) {
       postFound.push(input[counter]);
@@ -2202,17 +1890,14 @@ function splitWhen(predicate, input) {
       preFound.push(input[counter]);
     }
   }
-
   return [preFound, postFound];
 }
 
 function startsWith(target, iterable) {
   if (arguments.length === 1) return _iterable => startsWith(target, _iterable);
-
   if (typeof iterable === 'string') {
     return iterable.startsWith(target);
   }
-
   if (!isArray(target)) return false;
   let correct = true;
   const filtered = target.filter((x, index) => {
@@ -2233,7 +1918,6 @@ 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));
 }
 
@@ -2255,22 +1939,16 @@ function takeLastWhile(predicate, input) {
   if (arguments.length === 1) {
     return _input => takeLastWhile(predicate, _input);
   }
-
   if (input.length === 0) return input;
-  let found = false;
   const toReturn = [];
   let counter = input.length;
-
-  while (!found || counter === 0) {
-    counter--;
-
-    if (predicate(input[counter]) === false) {
-      found = true;
-    } else if (!found) {
-      toReturn.push(input[counter]);
+  while (counter) {
+    const item = input[--counter];
+    if (!predicate(item)) {
+      break;
     }
+    toReturn.push(item);
   }
-
   return isArray(input) ? toReturn.reverse() : toReturn.reverse().join('');
 }
 
@@ -2278,25 +1956,20 @@ function takeWhile(predicate, iterable) {
   if (arguments.length === 1) {
     return _iterable => takeWhile(predicate, _iterable);
   }
-
   const isArray$1 = isArray(iterable);
-
   if (!isArray$1 && typeof iterable !== 'string') {
     throw new Error('`iterable` is neither list nor a string');
   }
-
-  let flag = true;
-  const holder = [];
-  let counter = -1;
-
-  while (counter++ < iterable.length - 1) {
-    if (!predicate(iterable[counter])) {
-      if (flag) flag = false;
-    } else if (flag) {
-      holder.push(iterable[counter]);
+  const toReturn = [];
+  let counter = 0;
+  while (counter < iterable.length) {
+    const item = iterable[counter++];
+    if (!predicate(item)) {
+      break;
     }
+    toReturn.push(item);
   }
-  return isArray$1 ? holder : holder.join('');
+  return isArray$1 ? toReturn : toReturn.join('');
 }
 
 function tap(fn, x) {
@@ -2307,21 +1980,17 @@ function tap(fn, x) {
 
 function test(pattern, str) {
   if (arguments.length === 1) return _str => test(pattern, _str);
-
   if (typeof pattern === 'string') {
-    throw new TypeError(`‘test’ requires a value of type RegExp as its first argument; received "${pattern}"`);
+    throw new TypeError(`R.test requires a value of type RegExp as its first argument; received "${pattern}"`);
   }
-
   return str.search(pattern) !== -1;
 }
 
 function times(fn, howMany) {
   if (arguments.length === 1) return _howMany => times(fn, _howMany);
-
   if (!isInteger(howMany) || howMany < 0) {
     throw new RangeError('n must be an integer');
   }
-
   return map(fn, range(0, howMany));
 }
 
@@ -2353,12 +2022,10 @@ function trim(str) {
 }
 
 const isFunction = x => ['Promise', 'Function'].includes(type(x));
-
 function tryCatch(fn, fallback) {
   if (!isFunction(fn)) {
     throw new Error(`R.tryCatch | fn '${fn}'`);
   }
-
   const passFallback = isFunction(fallback);
   return (...inputs) => {
     try {
@@ -2388,43 +2055,31 @@ function uniqBy(fn, list) {
   if (arguments.length === 1) {
     return _list => uniqBy(fn, _list);
   }
-
-  const set = new Set();
-  return list.filter(item => {
-    if (set.has(fn(item))) return false;
-    set.add(fn(item));
-    return true;
-  });
+  const set = new _Set();
+  return list.filter(item => set.checkUniqueness(fn(item)));
 }
 
 function includesWith(predicate, target, list) {
   let willReturn = false;
   let index = -1;
-
   while (++index < list.length && !willReturn) {
     const value = list[index];
-
     if (predicate(target, value)) {
       willReturn = true;
     }
   }
-
   return willReturn;
 }
-
 function uniqWith(predicate, list) {
   if (arguments.length === 1) return _list => uniqWith(predicate, _list);
   let index = -1;
   const willReturn = [];
-
   while (++index < list.length) {
     const value = list[index];
-
     if (!includesWith(predicate, value, willReturn)) {
       willReturn.push(value);
     }
   }
-
   return willReturn;
 }
 
@@ -2432,15 +2087,22 @@ function unless(predicate, whenFalse) {
   if (arguments.length === 1) {
     return _whenFalse => unless(predicate, _whenFalse);
   }
-
   return input => predicate(input) ? input : whenFalse(input);
 }
 
+function unnest(list) {
+  return list.reduce((acc, item) => {
+    if (Array.isArray(item)) {
+      return [...acc, ...item];
+    }
+    return [...acc, item];
+  }, []);
+}
+
 function unwind(property, obj) {
   if (arguments.length === 1) {
     return _obj => unwind(property, _obj);
   }
-
   if (!isArray(obj[property])) return [obj];
   return mapArray(x => _objectSpread2(_objectSpread2({}, obj), {}, {
     [property]: x
@@ -2456,7 +2118,6 @@ const Const = x => ({
   x,
   map: fn => Const(x)
 });
-
 function view(lens, target) {
   if (arguments.length === 1) return _target => view(lens, _target);
   return lens(Const)(target).x;
@@ -2466,25 +2127,20 @@ function whenFn(predicate, whenTrueFn, input) {
   if (!predicate(input)) return input;
   return whenTrueFn(input);
 }
-
 const when = curry(whenFn);
 
 function where(conditions, input) {
   if (input === undefined) {
     return _input => where(conditions, _input);
   }
-
   let flag = true;
-
   for (const prop in conditions) {
     if (!flag) continue;
     const result = conditions[prop](input[prop]);
-
     if (flag && result === false) {
       flag = false;
     }
   }
-
   return flag;
 }
 
@@ -2492,13 +2148,11 @@ function whereAny(conditions, input) {
   if (input === undefined) {
     return _input => whereAny(conditions, _input);
   }
-
   for (const prop in conditions) {
     if (conditions[prop](input[prop])) {
       return true;
     }
   }
-
   return false;
 }
 
@@ -2506,7 +2160,6 @@ function whereEq(condition, input) {
   if (arguments.length === 1) {
     return _input => whereEq(condition, _input);
   }
-
   const result = filter((conditionValue, conditionProp) => equals(conditionValue, input[conditionProp]), condition);
   return Object.keys(result).length === Object.keys(condition).length;
 }
@@ -2515,7 +2168,6 @@ function without(matchAgainst, source) {
   if (source === undefined) {
     return _source => without(matchAgainst, _source);
   }
-
   return reduce((prev, current) => _indexOf(current, matchAgainst) > -1 ? prev : prev.concat(current), [], source);
 }
 
@@ -2528,11 +2180,9 @@ function zip(left, right) {
   if (arguments.length === 1) return _right => zip(left, _right);
   const result = [];
   const length = Math.min(left.length, right.length);
-
   for (let i = 0; i < length; i++) {
     result[i] = [left[i], right[i]];
   }
-
   return result;
 }
 
@@ -2547,7 +2197,6 @@ function zipObj(keys, values) {
 function zipWithFn(fn, x, y) {
   return take(x.length > y.length ? y.length : x.length, x).map((xInstance, i) => fn(xInstance, y[i]));
 }
-
 const zipWith = curry(zipWithFn);
 
 exports.F = F;
@@ -2669,6 +2318,7 @@ exports.move = move;
 exports.multiply = multiply;
 exports.negate = negate;
 exports.none = none;
+exports.nop = nop;
 exports.not = not;
 exports.nth = nth;
 exports.objOf = objOf;
@@ -2741,6 +2391,7 @@ exports.uniq = uniq;
 exports.uniqBy = uniqBy;
 exports.uniqWith = uniqWith;
 exports.unless = unless;
+exports.unnest = unnest;
 exports.unwind = unwind;
 exports.update = update;
 exports.updateFn = updateFn;