rambda 7.2.1 → 7.4.0

package/dist/rambda.mjs

@@ -1,11 +1,3 @@
-function F() {
-  return false;
-}
-
-function T() {
-  return true;
-}
-
 function add(a, b) {
   if (arguments.length === 1) return _b => add(a, _b);
   return Number(a) + Number(b);
@@ -24,31 +16,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;
   };
 }
@@ -65,30 +51,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;
   };
 }
@@ -105,42 +85,36 @@ function apply(fn, args) {
   if (arguments.length === 1) {
     return _args => apply(fn, _args);
   }
-
   return fn.apply(this, args);
 }
 
-const _isArray = Array.isArray;
+const {
+  isArray
+} = Array;
 
 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));
@@ -148,52 +122,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)) {
+  if (isArray(spec)) {
     const ret = [];
     let i = 0;
     const l = spec.length;
-
     for (; i < l; i++) {
-      if (typeof spec[i] === 'object' || _isArray(spec[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;
 }
 
@@ -202,38 +163,31 @@ function assocFn(prop, newValue, obj) {
     [prop]: newValue
   });
 }
-
 const assoc = curry(assocFn);
 
 function _isInteger(n) {
   return n << 0 === n;
 }
-var _isInteger$1 = Number.isInteger || _isInteger;
+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;
-
+  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);
+    const nextInput = condition ? isInteger(pathArrValue[1]) ? [] : {} : input[index];
+    newValue = assocPathFn(Array.prototype.slice.call(pathArrValue, 1), newValue, nextInput);
   }
-
-  if (_isInteger(index) && _isArray(input)) {
+  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) {
@@ -243,88 +197,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));
 }
 
@@ -332,7 +269,6 @@ function bind(fn, thisObj) {
   if (arguments.length === 1) {
     return _thisObj => bind(fn, _thisObj);
   }
-
   return curryN(fn.length, (...args) => fn.apply(thisObj, args));
 }
 
@@ -345,7 +281,6 @@ function chain(fn, list) {
   if (arguments.length === 1) {
     return _list => chain(fn, _list);
   }
-
   return [].concat(...list.map(fn));
 }
 
@@ -353,23 +288,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) : {};
+  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;
 }
 
@@ -377,33 +308,24 @@ function complement(fn) {
   return (...input) => !fn(...input);
 }
 
-const _keys = Object.keys;
-
 class ReduceStopper {
   constructor(value) {
     this.value = value;
   }
-
 }
-
 function reduceFn(reducer, acc, list) {
-  if (!_isArray(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);
@@ -415,57 +337,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');
   }
@@ -479,7 +390,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)));
 }
 
@@ -487,7 +397,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());
 }
 
@@ -510,46 +419,41 @@ function cond(conditions) {
   };
 }
 
+const {
+  keys: keys$1
+} = Object;
+
 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 keys = _keys(obj);
-
-  const len = keys.length;
+  const objKeys = keys$1(obj);
+  const len = objKeys.length;
   const willReturn = {};
-
   while (index < len) {
-    const key = keys[index];
+    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');
+    throw new Error(INCORRECT_ITERABLE_INPUT);
   }
-
-  if (_isArray(iterable)) return mapArray(fn, iterable);
+  if (isArray(iterable)) return mapArray(fn, iterable);
   return mapObject(fn, iterable);
 }
 
@@ -570,8 +474,7 @@ function count(predicate, list) {
   if (arguments.length === 1) {
     return _list => count(predicate, _list);
   }
-
-  if (!_isArray(list)) return 0;
+  if (!isArray(list)) return 0;
   return list.filter(x => predicate(x)).length;
 }
 
@@ -579,11 +482,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 {
@@ -598,12 +499,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;
 }
 
@@ -615,16 +514,14 @@ 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;
 }
 
 function _lastIndexOf(valueToFind, list) {
-  if (!_isArray(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 {
@@ -632,20 +529,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)) {
+  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;
@@ -653,85 +547,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) {
@@ -742,45 +615,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;
         }
@@ -788,22 +650,18 @@ 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;
+  if (!isArray(iterable)) return false;
   return _indexOf(valueToFind, iterable) > -1;
 }
 
@@ -812,38 +670,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) {
@@ -866,11 +716,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;
 }
@@ -889,7 +737,6 @@ function dropLast(howManyToDrop, listOrString) {
   if (arguments.length === 1) {
     return _listOrString => dropLast(howManyToDrop, _listOrString);
   }
-
   return howManyToDrop > 0 ? listOrString.slice(0, -howManyToDrop) : listOrString.slice();
 }
 
@@ -897,26 +744,19 @@ function dropLastWhile(predicate, iterable) {
   if (arguments.length === 1) {
     return _iterable => dropLastWhile(predicate, _iterable);
   }
-
   if (iterable.length === 0) return iterable;
-
-  const isArray = _isArray(iterable);
-
+  const isArray$1 = isArray(iterable);
   if (typeof predicate !== 'function') {
     throw new Error(`'predicate' is from wrong type ${typeof predicate}`);
   }
-
-  if (!isArray && typeof iterable !== 'string') {
+  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]);
@@ -924,21 +764,18 @@ function dropLastWhile(predicate, iterable) {
       toReturn.push(iterable[counter]);
     }
   }
-
-  return isArray ? toReturn.reverse() : toReturn.reverse().join('');
+  return isArray$1 ? toReturn.reverse() : toReturn.reverse().join('');
 }
 
 function dropRepeats(list) {
-  if (!_isArray(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;
@@ -948,22 +785,18 @@ function dropRepeatsWith(predicate, list) {
   if (arguments.length === 1) {
     return _iterable => dropRepeatsWith(predicate, _iterable);
   }
-
-  if (!_isArray(list)) {
+  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;
@@ -973,17 +806,13 @@ function dropWhile(predicate, iterable) {
   if (arguments.length === 1) {
     return _iterable => dropWhile(predicate, _iterable);
   }
-
-  const isArray = _isArray(iterable);
-
-  if (!isArray && typeof iterable !== 'string') {
+  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]);
@@ -992,26 +821,22 @@ function dropWhile(predicate, iterable) {
       holder.push(iterable[counter]);
     }
   }
-
-  return isArray ? holder : holder.join('');
+  return isArray$1 ? holder : holder.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;
+  if (!isArray(target)) return false;
   const diff = iterable.length - target.length;
   let correct = true;
   const filtered = target.filter((x, index) => {
@@ -1032,7 +857,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) {
@@ -1040,7 +864,6 @@ function evolveArray(rules, list) {
     if (type(rules[i]) === 'Function') {
       return rules[i](x);
     }
-
     return x;
   }, list, true);
 }
@@ -1048,22 +871,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);
 }
@@ -1071,61 +889,52 @@ 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 F() {
+  return false;
+}
+
 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);
+  if (isArray(iterable)) return filterArray(predicate, iterable, false);
   return filterObject(predicate, iterable);
 }
 
@@ -1133,14 +942,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++;
   }
 }
@@ -1149,53 +955,45 @@ 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])) {
+    if (isArray(list[i])) {
       flatten(list[i], willReturn);
     } else {
       willReturn.push(list[i]);
     }
   }
-
   return willReturn;
 }
 
@@ -1210,44 +1008,35 @@ 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)) {
+  if (isArray(list)) {
     let index = 0;
     const len = list.length;
-
     while (index < len) {
       fn(list[index]);
       index++;
     }
   } else {
     let index = 0;
-
-    const keys = _keys(list);
-
-    const len = keys.length;
-
+    const listKeys = keys$1(list);
+    const len = listKeys.length;
     while (index < len) {
-      const key = keys[index];
+      const key = listKeys[index];
       fn(list[key], key, list);
       index++;
     }
   }
-
   return list;
 }
 
@@ -1260,23 +1049,19 @@ 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;
 }
 
 function groupWith(compareFn, list) {
-  if (!_isArray(list)) throw new TypeError('list.reduce is not a function');
+  if (!isArray(list)) throw new TypeError('list.reduce is not a function');
   const clone = cloneList(list);
   if (list.length === 1) return [clone];
   const toReturn = [];
@@ -1286,20 +1071,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 = [];
@@ -1320,25 +1102,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;
 }
 
@@ -1346,7 +1123,6 @@ function hasPath(pathInput, obj) {
   if (arguments.length === 1) {
     return objHolder => hasPath(pathInput, objHolder);
   }
-
   return path(pathInput, obj) !== undefined;
 }
 
@@ -1359,14 +1135,13 @@ function _objectIs(a, b) {
   if (a === b) {
     return a !== 0 || 1 / a === 1 / b;
   }
-
   return a !== a && b !== b;
 }
-var _objectIs$1 = Object.is || _objectIs;
+const objectIs = Object.is || _objectIs;
 
 function identical(a, b) {
   if (arguments.length === 1) return _b => identical(a, _b);
-  return _objectIs$1(a, b);
+  return objectIs(a, b);
 }
 
 function identity(x) {
@@ -1376,46 +1151,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;
 }
 
@@ -1423,7 +1188,6 @@ function indexOf(valueToFind, list) {
   if (arguments.length === 1) {
     return _list => _indexOf(valueToFind, _list);
   }
-
   return _indexOf(valueToFind, list);
 }
 
@@ -1433,19 +1197,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;
 }
 
@@ -1464,7 +1224,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]);
@@ -1472,7 +1231,6 @@ function intersperse(separator, list) {
       willReturn.push(list[index], separator);
     }
   }
-
   return willReturn;
 }
 
@@ -1485,15 +1243,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;
 }
 
@@ -1518,7 +1273,6 @@ function last(listOrString) {
   if (typeof listOrString === 'string') {
     return listOrString[listOrString.length - 1] || '';
   }
-
   return listOrString[listOrString.length - 1];
 }
 
@@ -1526,12 +1280,11 @@ function lastIndexOf(valueToFind, list) {
   if (arguments.length === 1) {
     return _list => _lastIndexOf(valueToFind, _list);
   }
-
   return _lastIndexOf(valueToFind, list);
 }
 
 function length(x) {
-  if (_isArray(x)) return x.length;
+  if (isArray(x)) return x.length;
   if (typeof x === 'string') return x.length;
   return NaN;
 }
@@ -1555,7 +1308,6 @@ function updateFn(index, newValue, list) {
   if (index === -1) return clone.fill(newValue, index);
   return clone.fill(newValue, index, index + 1);
 }
-
 const update = curry(updateFn);
 
 function lensIndex(index) {
@@ -1578,7 +1330,7 @@ function match(pattern, input) {
 
 function mathMod(x, y) {
   if (arguments.length === 1) return _y => mathMod(x, _y);
-  if (!_isInteger$1(x) || !_isInteger$1(y) || y < 1) return NaN;
+  if (!isInteger(x) || !isInteger(y) || y < 1) return NaN;
   return (x % y + y) % y;
 }
 
@@ -1623,8 +1375,7 @@ function mergeDeepRight(target, source) {
   if (arguments.length === 1) {
     return sourceHolder => mergeDeepRight(target, sourceHolder);
   }
-
-  const willReturn = JSON.parse(JSON.stringify(target));
+  const willReturn = clone(target);
   Object.keys(source).forEach(key => {
     if (type(source[key]) === 'Object') {
       if (type(target[key]) === 'Object') {
@@ -1655,7 +1406,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 {
@@ -1664,7 +1414,6 @@ function mergeWithFn(mergeFn, a, b) {
   });
   return willReturn;
 }
-
 const mergeWith = curry(mergeWithFn);
 
 function min(x, y) {
@@ -1679,17 +1428,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] : {};
@@ -1699,10 +1445,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, {
@@ -1714,26 +1458,37 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
+function isIterable(input) {
+  return Array.isArray(input) || type(input) === 'Object';
+}
+
+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);
@@ -1747,14 +1502,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) {
@@ -1768,11 +1521,9 @@ 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;
 }
 
@@ -1784,7 +1535,6 @@ function objOf(key, value) {
   if (arguments.length === 1) {
     return _value => objOf(key, _value);
   }
-
   return {
     [key]: value
   };
@@ -1796,20 +1546,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;
 }
 
@@ -1817,11 +1563,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));
 }
 
@@ -1832,17 +1576,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);
 }
 
@@ -1855,11 +1596,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) {
@@ -1868,21 +1607,12 @@ function partial(fn, ...args) {
     if (args.length + rest.length >= len) {
       return fn(...args, ...rest);
     }
-
     return partial(fn, ...[...args, ...rest]);
   };
 }
 
 function partialObject(fn, input) {
-  return rest => {
-    if (type(fn) === 'Async') {
-      return new Promise((resolve, reject) => {
-        fn(mergeDeepRight(rest, input)).then(resolve).catch(reject);
-      });
-    }
-
-    return fn(mergeDeepRight(rest, input));
-  };
+  return nextInput => fn(mergeDeepRight(nextInput, input));
 }
 
 function partitionObject(predicate, iterable) {
@@ -1901,7 +1631,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]);
@@ -1909,81 +1638,66 @@ 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);
+  if (!isArray(iterable)) return partitionObject(predicate, iterable);
   return partitionArray(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;
 }
 
@@ -2010,55 +1724,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)) {
+  if (!isArray(propsToPick)) {
     throw new Error('propsToPick is not a list');
   }
-
   return mapArray(prop => obj[prop], propsToPick);
 }
 
+function propSatisfiesFn(predicate, property, obj) {
+  return predicate(prop(property, obj));
+}
+const propSatisfies = curry(propSatisfiesFn);
+
 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;
 }
 
@@ -2071,21 +1775,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();
 }
@@ -2093,13 +1794,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) {
@@ -2140,9 +1839,8 @@ 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 [[], []];
+  if (!isArray(input) && typeof input !== 'string') return [[], []];
   const correctIndex = maybe(index < 0, input.length + index < 0 ? 0 : input.length + index, index);
   return [take(correctIndex, input), drop(correctIndex, input)];
 }
@@ -2151,18 +1849,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;
 }
 
@@ -2170,13 +1864,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]);
@@ -2187,18 +1879,15 @@ 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;
+  if (!isArray(target)) return false;
   let correct = true;
   const filtered = target.filter((x, index) => {
     if (!correct) return false;
@@ -2218,10 +1907,13 @@ 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 T() {
+  return true;
+}
+
 function tail(listOrString) {
   return drop(1, listOrString);
 }
@@ -2240,40 +1932,32 @@ 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]);
     }
   }
-
-  return _isArray(input) ? toReturn.reverse() : toReturn.reverse().join('');
+  return isArray(input) ? toReturn.reverse() : toReturn.reverse().join('');
 }
 
 function takeWhile(predicate, iterable) {
   if (arguments.length === 1) {
     return _iterable => takeWhile(predicate, _iterable);
   }
-
-  const isArray = _isArray(iterable);
-
-  if (!isArray && typeof iterable !== 'string') {
+  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;
@@ -2281,7 +1965,7 @@ function takeWhile(predicate, iterable) {
       holder.push(iterable[counter]);
     }
   }
-  return isArray ? holder : holder.join('');
+  return isArray$1 ? holder : holder.join('');
 }
 
 function tap(fn, x) {
@@ -2292,21 +1976,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}"`);
   }
-
   return str.search(pattern) !== -1;
 }
 
 function times(fn, howMany) {
   if (arguments.length === 1) return _howMany => times(fn, _howMany);
-
-  if (!Number.isInteger(howMany) || howMany < 0) {
+  if (!isInteger(howMany) || howMany < 0) {
     throw new RangeError('n must be an integer');
   }
-
   return map(fn, range(0, howMany));
 }
 
@@ -2328,7 +2008,7 @@ function toUpper(str) {
 
 function transpose(array) {
   return array.reduce((acc, el) => {
-    el.forEach((nestedEl, i) => _isArray(acc[i]) ? acc[i].push(nestedEl) : acc.push([nestedEl]));
+    el.forEach((nestedEl, i) => isArray(acc[i]) ? acc[i].push(nestedEl) : acc.push([nestedEl]));
     return acc;
   }, []);
 }
@@ -2338,12 +2018,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 {
@@ -2373,7 +2051,6 @@ 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;
@@ -2385,31 +2062,24 @@ function uniqBy(fn, list) {
 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;
 }
 
@@ -2417,7 +2087,6 @@ function unless(predicate, whenFalse) {
   if (arguments.length === 1) {
     return _whenFalse => unless(predicate, _whenFalse);
   }
-
   return input => predicate(input) ? input : whenFalse(input);
 }
 
@@ -2425,8 +2094,7 @@ function unwind(property, obj) {
   if (arguments.length === 1) {
     return _obj => unwind(property, _obj);
   }
-
-  if (!_isArray(obj[property])) return [obj];
+  if (!isArray(obj[property])) return [obj];
   return mapArray(x => _objectSpread2(_objectSpread2({}, obj), {}, {
     [property]: x
   }), obj[property]);
@@ -2441,7 +2109,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;
@@ -2451,24 +2118,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;
 }
 
@@ -2476,13 +2139,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;
 }
 
@@ -2490,7 +2151,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;
 }
@@ -2499,7 +2159,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);
 }
 
@@ -2512,11 +2171,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;
 }
 
@@ -2531,7 +2188,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);
 
-export { F, T, __findHighestArity, _arity, _indexOf, _lastIndexOf, _pipe, add, adjust, all, allPass, always, and, any, anyPass, append, apply, applySpec, assoc, assocPath, bind, both, chain, clamp, clone, complement, compose, concat, cond, converge, count, countBy, curry, curryN, dec, defaultTo, difference, dissoc, divide, drop, dropLast, dropLastWhile, dropRepeats, dropRepeatsWith, dropWhile, either, endsWith, eqProps, equals, evolve, evolveArray, evolveObject, filter, filterArray, filterObject, find, findIndex, findLast, findLastIndex, flatten, flip, forEach, fromPairs, groupBy, groupWith, has, hasPath, head, identical, identity, ifElse, inc, includes, indexBy, indexOf, init, intersection, intersperse, is, isEmpty, isNil, join, juxt, keys, last, lastIndexOf, length, lens, lensIndex, lensPath, lensProp, map, mapArray, mapObjIndexed, mapObject, match, mathMod, max, maxBy, maxByFn, mean, median, mergeRight as merge, mergeAll, mergeDeepRight, mergeLeft, mergeRight, mergeWith, min, minBy, minByFn, modifyPath, modifyPathFn, modulo, move, multiply, negate, none, not, nth, objOf, of, omit, on, once, or, over, partial, partialObject, partition, partitionArray, partitionObject, path, pathEq, pathOr, paths, pick, pickAll, pipe, pluck, prepend, product, prop, propEq, propIs, propOr, propSatisfies, props, range, reduce, reduceFn, reduceStopper, reject, repeat, replace, reverse, set, slice, sort, sortBy, split, splitAt, splitEvery, splitWhen, startsWith, subtract, sum, symmetricDifference, tail, take, takeLast, takeLastWhile, takeWhile, tap, test, times, toLower, toPairs, toString, toUpper, transpose, trim, tryCatch, type, unapply, union, uniq, uniqBy, uniqWith, unless, unwind, update, values, view, when, where, whereAny, whereEq, without, xor, zip, zipObj, zipWith };
+export { F, T, __findHighestArity, _arity, _indexOf, _lastIndexOf, _pipe, add, adjust, all, allPass, always, and, any, anyPass, append, apply, applySpec, assoc, assocPath, bind, both, chain, clamp, clone, complement, compose, concat, cond, converge, count, countBy, curry, curryN, dec, defaultTo, difference, dissoc, divide, drop, dropLast, dropLastWhile, dropRepeats, dropRepeatsWith, dropWhile, either, endsWith, eqProps, equals, evolve, evolveArray, evolveObject, filter, filterArray, filterObject, find, findIndex, findLast, findLastIndex, flatten, flip, forEach, fromPairs, groupBy, groupWith, has, hasPath, head, identical, identity, ifElse, inc, includes, indexBy, indexOf, init, intersection, intersperse, is, isEmpty, isNil, join, juxt, keys, last, lastIndexOf, length, lens, lensIndex, lensPath, lensProp, map, mapArray, mapObjIndexed, mapObject, match, mathMod, max, maxBy, maxByFn, mean, median, mergeRight as merge, mergeAll, mergeDeepRight, mergeLeft, mergeRight, mergeWith, min, minBy, minByFn, modify, modifyPath, modifyPathFn, modulo, move, multiply, negate, none, not, nth, objOf, of, omit, on, once, or, over, partial, partialObject, partition, partitionArray, partitionObject, path, pathEq, pathOr, paths, pick, pickAll, pipe, pluck, prepend, product, prop, propEq, propIs, propOr, propSatisfies, props, range, reduce, reduceFn, reduceStopper, reject, repeat, replace, reverse, set, slice, sort, sortBy, split, splitAt, splitEvery, splitWhen, startsWith, subtract, sum, symmetricDifference, tail, take, takeLast, takeLastWhile, takeWhile, tap, test, times, toLower, toPairs, toString, toUpper, transpose, trim, tryCatch, type, unapply, union, uniq, uniqBy, uniqWith, unless, unwind, update, updateFn, values, view, when, where, whereAny, whereEq, without, xor, zip, zipObj, zipWith };