rambda 10.0.0-alpha.0 → 10.0.0-beta.3

package/dist/{rambda.esm.js → rambda.cjs}

@@ -1,3 +1,38 @@
+'use strict';
+
+function addProp(key, value) {
+  return obj => ({ ...obj, [key]: value })
+}
+
+function mapFn(
+	fn, list
+){
+	let index = 0;
+	const willReturn = Array(list.length);
+	while (index < list.length) {
+		willReturn[index] = fn(list[index], index);
+		index++;
+	}
+	return willReturn
+}
+
+function map(fn) {
+  return list => mapFn(fn, list)
+}
+
+function addPropToObjects (
+	property, 
+	fn
+){
+	return listOfObjects => mapFn(
+		(obj) => ({
+			...(obj),
+			[property]: fn(obj)
+		}), 
+		listOfObjects
+	)
+}
+
 function all(predicate) {
   return list => {
     for (let i = 0; i < list.length; i++) {
@@ -52,15 +87,32 @@ function anyPass(predicates) {
   }
 }
 
-const cloneList = list => Array.prototype.slice.call(list);
+const cloneList$1 = list => Array.prototype.slice.call(list);
 
 function append(x) {
-  return list=> {
-		const clone = cloneList(list);
-  clone.push(x);
+  return list => {
+    const clone = cloneList$1(list);
+    clone.push(x);
 
-  return clone
-	}
+    return clone
+  }
+}
+
+function createCompareFunction(a, b, winner, loser) {
+  if (a === b) {
+    return 0
+  }
+
+  return a < b ? winner : loser
+}
+
+function ascend(getFunction) {
+	return (a, b) => {
+  const aValue = getFunction(a);
+  const bValue = getFunction(b);
+
+  return createCompareFunction(aValue, bValue, -1, 1)
+}
 }
 
 function checkObjectWithSpec(conditions) {
@@ -80,67 +132,125 @@ function checkObjectWithSpec(conditions) {
   }
 }
 
+const { isArray } = Array;
+
+function filter(predicate) {
+  return list => {
+    if (!list) {
+      throw new Error('Incorrect iterable input')
+    }
+    let index = 0;
+    const len = list.length;
+    const willReturn = [];
+
+    while (index < len) {
+      if (predicate(list[index], index)) {
+        willReturn.push(list[index]);
+      }
+
+      index++;
+    }
+
+    return willReturn
+  }
+}
+
+function reject(predicate) {
+  return list => filter(x => !predicate(x))(list)
+}
+
+function rejectObject(predicate) {
+  return obj => {
+    const willReturn = {};
+
+    for (const prop in obj) {
+      if (!predicate(obj[prop], prop, obj)) {
+        willReturn[prop] = obj[prop];
+      }
+    }
+
+    return willReturn
+  }
+}
+
+const isNullOrUndefined = x => x === null || x === undefined;
+
+function compact(input){
+	if(isArray(input)){
+		return reject(isNullOrUndefined)(input)
+	}
+	return rejectObject(isNullOrUndefined)(input)
+}
+
 function complement(fn) {
   return (...input) => !fn(...input)
 }
 
 function concat(x) {
-  return y => typeof x === 'string' ? `${x}${y}` : [...x, ...y]
+  return y => (typeof x === 'string' ? `${x}${y}` : [...x, ...y])
 }
 
-const { isArray } = Array;
+function count(predicate) {
+  return list => {
+    if (!isArray(list)) {
+      return 0
+    }
 
-function count(predicate, ) {
- return list => {
-  if (!isArray(list)) {
-    return 0
+    return list.filter(x => predicate(x)).length
   }
-
-  return list.filter(x => predicate(x)).length
-}
 }
 
 function countBy(fn) {
-	return list => {
-  const willReturn = {};
+  return list => {
+    const willReturn = {};
 
-  list.forEach(item => {
-    const key = fn(item);
-    if (!willReturn[key]) {
-      willReturn[key] = 1;
-    } else {
-      willReturn[key]++;
-    }
-  });
+    list.forEach(item => {
+      const key = fn(item);
+      if (!willReturn[key]) {
+        willReturn[key] = 1;
+      } else {
+        willReturn[key]++;
+      }
+    });
 
-  return willReturn
+    return willReturn
+  }
 }
+
+function createObjectFromKeys(keys) {
+	return fn => {
+		const result = {};
+		keys.forEach((key, index) => {
+			result[key] = fn(key, index);
+		});
+
+		return result
+	}
 }
 
 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
+function defaultTo(defaultArgument) {
+  return input => isFalsy(input) ? defaultArgument : input
 }
 
-function drop(howManyToDrop, listOrString) {
-  if (arguments.length === 1) {
-    return _list => drop(howManyToDrop, _list)
+function descend(getFunction) {
+  return (a, b) => {
+    const aValue = getFunction(a);
+    const bValue = getFunction(b);
+
+    return createCompareFunction(aValue, bValue, 1, -1)
   }
+}
 
-  return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0)
+function drop(howManyToDrop, ) {
+  return list => list.slice(howManyToDrop > 0 ? howManyToDrop : 0)
 }
 
 function dropLast(numberItems) {
-	return list => numberItems > 0
-    ? list.slice(0, -numberItems)
-    : list.slice()
+  return list => (numberItems > 0 ? list.slice(0, -numberItems) : list.slice())
 }
 
 function dropLastWhile(predicate) {
@@ -300,7 +410,7 @@ function parseRegex(maybeRegex) {
 }
 
 function equalsFn(a, b) {
-	if (Object.is(a, b)) {
+  if (Object.is(a, b)) {
     return true
   }
 
@@ -409,19 +519,15 @@ function equalsFn(a, b) {
   return false
 }
 function equals(a) {
-	return b => equalsFn(a, b)
+  return b => equalsFn(a, b)
 }
 
 function eqBy(fn, a) {
   return b => equalsFn(fn(a), fn(b))
 }
 
-function prop(searchProperty) {
-  return obj => (obj ? obj[searchProperty] : undefined)
-}
-
 function eqProps(property, objA) {
-  return objB => equalsFn(prop(property)(objA), prop(property)(objB))
+  return objB => equalsFn( objA[property], objB[property] )
 }
 
 const { keys } = Object;
@@ -443,73 +549,30 @@ function mapObject(fn) {
   }
 }
 
-function evolveFn(rules, obj) {
-    return mapObject((x, prop) => {
-      if (type(x) === 'Object') {
-        const typeRule = type(rules[prop]);
-        if (typeRule === 'Function') {
-          return rules[prop](x)
-        }
-        if (typeRule === 'Object') {
-          return evolveFn(rules[prop], x)
-        }
-
-        return x
-      }
-      if (type(rules[prop]) === 'Function') {
-        return rules[prop](x)
-      }
-
-      return x
-    })(obj)
-}
-
 function evolve(rules) {
-  return obj =>	evolveFn(rules, obj)
-		}
+  return mapObject((x, prop) => type(rules[prop]) === 'Function' ? rules[prop](x): x)
+}
 
 function includes(valueToFind) {
-	return 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 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
-}
+    return _indexOf(valueToFind, iterable) > -1
+  }
 }
 
 function excludes(valueToFind) {
   return iterable => !includes(valueToFind)(iterable)
 }
 
-function filter(predicate) {
-	return list => {
-  if (!list) {
-    throw new Error('Incorrect iterable input')
-  }
-	let index = 0;
-  const len = list.length;
-  const willReturn = [];
-
-  while (index < len) {
-    if (predicate(list[index], index)) {
-      willReturn.push(list[index]);
-    }
-
-    index++;
-  }
-	
-  return willReturn
-	}
-}
-
 function filterObject(predicate) {
   return obj => {
     const willReturn = {};
@@ -525,62 +588,79 @@ function filterObject(predicate) {
 }
 
 function find(predicate) {
-	return list => {
-  let index = 0;
-  const len = list.length;
+  return list => {
+    let index = 0;
+    const len = list.length;
 
-  while (index < len) {
-    const x = list[index];
-    if (predicate(x)) {
-      return x
-    }
+    while (index < len) {
+      const x = list[index];
+      if (predicate(x)) {
+        return x
+      }
 
-    index++;
+      index++;
+    }
   }
 }
-}
 
 function findIndex(predicate) {
-	return list => {
-  const len = list.length;
-  let index = -1;
+  return list => {
+    const len = list.length;
+    let index = -1;
 
-  while (++index < len) {
-    if (predicate(list[index])) {
-      return index
+    while (++index < len) {
+      if (predicate(list[index])) {
+        return index
+      }
     }
-  }
 
-  return -1
-}
+    return -1
+  }
 }
 
 function findLast(predicate) {
-	return list => {
-  let index = list.length;
+  return list => {
+    let index = list.length;
 
-  while (--index >= 0) {
-    if (predicate(list[index])) {
-      return list[index]
+    while (--index >= 0) {
+      if (predicate(list[index])) {
+        return list[index]
+      }
     }
-  }
 
-  return undefined
-}
+    return undefined
+  }
 }
 
 function findLastIndex(fn) {
-	return list => {
-  let index = list.length;
+  return list => {
+    let index = list.length;
 
-  while (--index >= 0) {
-    if (fn(list[index])) {
-      return index
+    while (--index >= 0) {
+      if (fn(list[index])) {
+        return index
+      }
     }
-  }
 
-  return -1
+    return -1
+  }
 }
+
+function findNth(predicate, nth) {
+  return list => {
+    let index = 0;
+    const len = list.length;
+
+    while (index < len) {
+      const x = list[index];
+      if (predicate(x)) {
+				if (nth === 0) return x
+				nth--;
+      }
+
+      index++;
+    }
+  }
 }
 
 function flatMap(fn) {
@@ -601,24 +681,100 @@ function flatten(list, input) {
   return willReturn
 }
 
-function groupBy(groupFn, list) {
-  if (arguments.length === 1) {
-    return _list => groupBy(groupFn, _list)
-  }
+function flattenObjectHelper(obj, accumulator = []){
+  const willReturn = {};
+  Object.keys(obj).forEach(key => {
+    const typeIs = type(obj[ key ]);
+    if (typeIs === 'Object'){
+      const [ flatResultValue, flatResultPath ] = flattenObjectHelper(obj[ key ],
+        [ ...accumulator, key ]);
+      willReturn[ flatResultPath.join('.') ] = flatResultValue;
 
-  const result = {};
-  for (let i = 0; i < list.length; i++) {
-    const item = list[i];
-    const key = groupFn(item);
+      return
+    } else if (accumulator.length > 0){
+      const finalKey = [ ...accumulator, key ].join('.');
+      willReturn[ finalKey ] = obj[ key ];
 
-    if (!result[key]) {
-      result[key] = [];
+      return
     }
+    willReturn[ key ] = obj[ key ];
+  });
+  if (accumulator.length > 0) return [ willReturn, accumulator ]
 
-    result[key].push(item);
-  }
+  return willReturn
+}
 
-  return result
+function transformFlatObject(obj){
+  const willReturn = {};
+
+  const transformFlatObjectFn = objLocal => {
+    const willReturnLocal = {};
+    Object.keys(objLocal).forEach(key => {
+      const typeIs = type(objLocal[ key ]);
+      if (typeIs === 'Object'){
+        transformFlatObjectFn(objLocal[ key ]);
+
+        return
+      }
+      willReturnLocal[ key ] = objLocal[ key ];
+      willReturn[ key ] = objLocal[ key ];
+    });
+
+    return willReturnLocal
+  };
+
+  Object.keys(obj).forEach(key => {
+    const typeIs = type(obj[ key ]);
+    if (typeIs === 'Object'){
+      transformFlatObjectFn(obj[ key ]);
+
+      return
+    }
+    willReturn[ key ] = obj[ key ];
+  });
+
+  return willReturn
+}
+
+function flattenObject(obj){
+  const willReturn = {};
+
+  Object.keys(obj).forEach(key => {
+    const typeIs = type(obj[ key ]);
+    if (typeIs === 'Object'){
+      const flatObject = flattenObjectHelper(obj[ key ]);
+      const transformed = transformFlatObject(flatObject);
+
+      Object.keys(transformed).forEach(keyTransformed => {
+        willReturn[ `${ key }.${ keyTransformed }` ] = transformed[ keyTransformed ];
+      });
+    } else {
+      willReturn[ key ] = obj[ key ];
+    }
+  });
+
+  return willReturn
+}
+
+function groupByFallback(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 groupBy(groupFn) {
+  return iterable => Object.groupBy ? Object.groupBy(iterable,groupFn) : groupByFallback(groupFn, iterable)
 }
 
 function head(listOrString) {
@@ -695,30 +851,60 @@ function innerJoin(pred, xs) {
   return ys => _filter(x => _includesWith(pred, x, ys), xs)
 }
 
+const getOccurrences = input => input.match(/{{\s*.+?\s*}}/g);
+const getOccurrenceProp = occurrence => occurrence.replace(/{{\s*|\s*}}/g, '');
+
+const replace$1 = ({ inputHolder, prop, replacer }) => {
+  const regexBase = `{{${prop}}}`;
+  const regex = new RegExp(regexBase, 'g');
+  return inputHolder.replace(regex, replacer)
+};
+
+function interpolate(input) {
+  return templateInput => {
+    const occurrences = getOccurrences(input);
+    if (occurrences === null) {
+      return input
+    }
+    let inputHolder = input;
+
+    for (const occurrence of occurrences) {
+      const prop = getOccurrenceProp(occurrence);
+      inputHolder = replace$1({
+        inputHolder,
+        prop,
+        replacer: templateInput[prop],
+      });
+    }
+
+    return inputHolder
+  }
+}
+
 function intersection(listA) {
-  return listB =>filter(x => includes(x)(listA))(listB)
+  return listB => filter(x => includes(x)(listA))(listB)
 }
 
 function intersperse(separator) {
-	return list => {
-  let index = -1;
-  const len = list.length;
-  const willReturn = [];
+  return list => {
+    let index = -1;
+    const len = list.length;
+    const willReturn = [];
 
-  while (++index < len) {
-    if (index === len - 1) {
-      willReturn.push(list[index]);
-    } else {
-      willReturn.push(list[index], separator);
+    while (++index < len) {
+      if (index === len - 1) {
+        willReturn.push(list[index]);
+      } else {
+        willReturn.push(list[index], separator);
+      }
     }
-  }
 
-  return willReturn
-}
+    return willReturn
+  }
 }
 
 function join(glue) {
-  return list=> list.join(glue)
+  return list => list.join(glue)
 }
 
 function last(listOrString) {
@@ -733,47 +919,51 @@ function lastIndexOf(valueToFind) {
   return list => _lastIndexOf(valueToFind, list)
 }
 
-function map(fn) {
-  return list => {
-    let index = 0;
-    const willReturn = Array(list.length);
-    while (index < list.length) {
-      willReturn[index] = fn(list[index], index);
-      index++;
-    }
-    return willReturn
-  }
-}
-
 function mapAsync(fn) {
-	return async list => {
-		const willReturn = [];
+  return async list => {
+    const willReturn = [];
     let i = 0;
     for (const a of list) {
       willReturn.push(await fn(a, i++));
     }
 
     return willReturn
-	}
+  }
 }
 
-function mapObjectAsync(fn) {
-	return async obj => {
+function mapKeys(fn) {
+  return obj => {
 		const willReturn = {};
-		for (const prop in obj){
-			willReturn[ prop ] = await fn(obj[ prop ], prop);
-		}
-	
+
+		Object.keys(obj).forEach(key => {
+			willReturn[fn(key, obj[key])] = obj[key];
+		});
+
 		return willReturn
 	}
 }
 
+function mapObjectAsync(fn) {
+  return async obj => {
+    const willReturn = {};
+    for (const prop in obj) {
+      willReturn[prop] = await fn(obj[prop], prop);
+    }
+
+    return willReturn
+  }
+}
+
+function mapParallelAsync(fn) {
+  return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+}
+
 function match(pattern) {
-	return input => {
-		const willReturn = input.match(pattern);
-	
-		return willReturn === null ? [] : willReturn
-	}
+  return input => {
+    const willReturn = input.match(pattern);
+
+    return willReturn === null ? [] : willReturn
+  }
 }
 
 function maxBy(compareFn, x) {
@@ -793,66 +983,47 @@ function minBy(compareFn, x) {
   return y => (compareFn(y) < compareFn(x) ? y : x)
 }
 
-function createPath(path, delimiter = '.') {
-  return typeof path === 'string'
-    ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
-    : path
-}
+function modifyItemAtIndex(index, replaceFn) {
+  return list => {
+    const actualIndex = index < 0 ? list.length + index : index;
+    if (index >= list.length || actualIndex < 0) {
+      return list
+    }
 
-function path(pathInput, obj) {
-  if (arguments.length === 1) {
-    return _obj => path(pathInput, _obj)
-  }
+    const clone = cloneList$1(list);
+    clone[actualIndex] = replaceFn(clone[actualIndex]);
 
-  if (!obj) {
-    return undefined
+    return clone
   }
-  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
+function update(index, newValue) {
+  return list => {
+    const clone = cloneList$1(list);
+    if (index === -1) {
+      return clone.fill(newValue, index)
     }
 
-    willReturn = willReturn[pathArrValue[counter]];
-    counter++;
+    return clone.fill(newValue, index, index + 1)
   }
-
-  return willReturn
-}
-
-function assoc(prop, newValue) {
-  return obj => Object.assign({}, obj, { [prop]: newValue })
 }
 
-function modifyPathFn(pathInput, fn, obj) {
-    const path$1 = createPath(pathInput);
-    if (path$1.length === 1) {
-      return {
-        ...obj,
-        [path$1[0]]: fn(obj[path$1[0]]),
-      }
-    }
-    if (path(path$1)(obj) === undefined) {
-      return obj
-    }
-
-    const val = modifyPathFn(Array.prototype.slice.call(path$1, 1), fn, obj[path$1[0]]);
-    if (val === obj[path$1[0]]) {
-      return obj
-    }
+function modifyFn(property, fn, list) {
+  if (list[property] === undefined) {
+    return list
+  }
+  if (isArray(list)) {
+    return update(property, fn(list[property]))(list)
+  }
 
-    return assoc(path$1[0], val)(obj)
+  return {
+    ...list,
+    [property]: fn(list[property]),
+  }
 }
 
-function modifyPath(pathInput, fn) {
-  return obj => modifyPathFn(pathInput, fn, obj)
+function modifyProp(property, fn) {
+  return obj => modifyFn(property, fn, obj)
 }
 
 function none(predicate) {
@@ -871,6 +1042,22 @@ function objOf(key) {
   return value => ({ [key]: value })
 }
 
+function objectIncludes(condition) {
+  return obj => {
+    const result = filterObject((conditionValue, conditionProp) =>
+      equals(conditionValue)(obj[conditionProp]),
+    )(condition);
+
+    return Object.keys(result).length === Object.keys(condition).length
+  }
+}
+
+function createPath(path, delimiter = '.') {
+  return typeof path === 'string'
+    ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
+    : path
+}
+
 function _includes(x, list) {
   let index = -1;
   const { length } = list;
@@ -903,10 +1090,29 @@ function omit(propsToOmit) {
   }
 }
 
-function partitionObject(predicate, iterable) {
+function partition(predicate) {
+  return list => {
+		const yes = [];
+		const no = [];
+		let counter = -1;
+	
+		while (counter++ < list.length - 1) {
+			if (predicate(list[counter], counter)) {
+				yes.push(list[counter]);
+			} else {
+				no.push(list[counter]);
+			}
+		}
+	
+		return [yes, no]
+  }
+}
+
+function partitionObject(predicate) {
+	return obj => {
   const yes = {};
   const no = {};
-  Object.entries(iterable).forEach(([prop, value]) => {
+  Object.entries(obj).forEach(([prop, value]) => {
     if (predicate(value, prop)) {
       yes[prop] = value;
     } else {
@@ -916,31 +1122,75 @@ function partitionObject(predicate, iterable) {
 
   return [yes, no]
 }
+}
 
-function partitionArray(predicate, list, indexed = false) {
-  const yes = [];
-  const no = [];
-  let counter = -1;
+function path(pathInput) {
+	return (obj)  => {
+		if (!obj) {
+			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
+	}
+}
+
+function pathSatisfies(fn, pathInput) {
+  return obj => Boolean(fn(path(pathInput)(obj)))
+}
 
-  while (counter++ < list.length - 1) {
-    if (indexed ? predicate(list[counter], counter) : predicate(list[counter])) {
-      yes.push(list[counter]);
+/**
+ * Source:
+ * https://github.com/denoland/std/blob/main/collections/permutations.ts
+ */
+function permutations(inputArray) {
+  const result = [];
+  const array = cloneList$1(inputArray);
+  const k = array.length;
+  if (k === 0) {
+    return result;
+  }
+
+  const c = new Array(k).fill(0);
+
+  result.push([...array]);
+
+  let i = 1;
+
+  while (i < k) {
+    if (c[i] < i) {
+      if (i % 2 === 0) {
+        [array[0], array[i]] = [array[i], array[0]];
+      } else {
+        [array[c[i]], array[i]] = [array[i], array[c[i]]];
+      }
+
+      result.push([...array]);
+
+      c[i] += 1;
+      i = 1;
     } else {
-      no.push(list[counter]);
+      c[i] = 0;
+      i += 1;
     }
   }
 
-  return [yes, no]
-}
-
-function partition(predicate) {
-	return iterable => {
-		if (!isArray(iterable)) {
-			return partitionObject(predicate, iterable)
-		}
-	
-		return partitionArray(predicate, iterable)
-	}
+  return result;
 }
 
 function pick(propsToPick) {
@@ -1063,30 +1313,35 @@ function pipe(...inputs) {
 }
 
 async function pipeAsync(input, ...fnList) {
-		let willReturn = input;
-		for (const fn of fnList) {
-			const initialResult = fn(willReturn);
-			willReturn = type(initialResult) === 'Promise' ? await initialResult : initialResult;
-    }
-		return willReturn
+  let willReturn = input;
+  for (const fn of fnList) {
+    const initialResult = fn(willReturn);
+    willReturn =
+      type(initialResult) === 'Promise' ? await initialResult : initialResult;
+  }
+  return willReturn
 }
 
 function pluck(property) {
-	return list => {
-  const willReturn = [];
+  return list => {
+    const willReturn = [];
 
-  list.forEach(x => {
-    if (x[property] !== undefined) {
-      willReturn.push(x[property]);
-    }
-  });
+    list.forEach(x => {
+      if (x[property] !== undefined) {
+        willReturn.push(x[property]);
+      }
+    });
 
-  return willReturn
-}
+    return willReturn
+  }
 }
 
 function prepend(x) {
-  return list=> [x].concat(list)
+  return list => [x].concat(list)
+}
+
+function prop(searchProperty) {
+  return obj => (obj ? obj[searchProperty] : undefined)
 }
 
 function propEq(valueToMatch, propToFind) {
@@ -1105,72 +1360,119 @@ function propOr(defaultValue, property) {
       return defaultValue
     }
 
-    return defaultTo(defaultValue, obj[property])
+    return defaultTo(defaultValue)(obj[property])
   }
 }
 
 function propSatisfies(predicate, property) {
-  return obj => predicate(prop(property))
+  return obj => predicate(obj[property])
 }
 
-function range(start){
-	return end => {
-  if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){
-    throw new TypeError('Both arguments to range must be numbers')
-  }
+function rangeDescending(start, end) {
+	const len = start - end;
+	const willReturn = Array(len);
+
+	for (let i = 0; i < len; i++) {
+		willReturn[i] = start - i;
+	}
 
-  if (end < start) return []
+	return willReturn
+}
 
-  const len = end - start;
-  const willReturn = Array(len);
+function range(start) {
+  return end => {
+    if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
+      throw new TypeError('Both arguments to range must be numbers')
+    }
 
-  for (let i = 0; i < len; i++){
-    willReturn[ i ] = start + i;
-  }
+    if (end === start) {
+      return []
+    }
+		if (end < start) return rangeDescending(start,end)
 
-  return willReturn
-}
-}
+    const len = end - start;
+    const willReturn = Array(len);
 
-function reject(predicate) {
-  return list => filter(x => !predicate(x))
+    for (let i = 0; i < len; i++) {
+      willReturn[i] = start + i;
+    }
+
+    return willReturn
+  }
 }
 
 function replace(pattern, replacer) {
   return str => str.replace(pattern, replacer)
 }
 
-function replaceItemAtIndex(index, replaceFn) {
-  return list => {
-    const actualIndex = index < 0 ? list.length + index : index;
-    if (index >= list.length || actualIndex < 0) {
-      return list
-    }
+function shuffle(listInput) {
+  const list = cloneList(listInput);
+  let counter = list.length;
+  while (counter > 0) {
+    const index = Math.floor(Math.random() * counter);
+    counter--;
+    const temp = list[counter];
+    list[counter] = list[index];
+    list[index] = temp;
+  }
 
-    const clone = cloneList(list);
-    clone[actualIndex] = replaceFn(clone[actualIndex]);
+  return list
+}
 
-    return clone
-  }
+function sort(sortFn) {
+  return list => cloneList$1(list).sort(sortFn)
 }
 
-function sort(sortFn){
-  return list => cloneList(list).sort(sortFn)
+function sortByFn (
+	sortFn,
+	list,
+	descending
+){
+	const clone = cloneList$1(list);
+
+	return clone.sort((a, b) => {
+		const aSortResult = sortFn(a);
+		const bSortResult = sortFn(b);
+
+		if (aSortResult === bSortResult) {
+			return 0
+		}
+		if(
+			descending
+		) return aSortResult > bSortResult ? -1 : 1
+
+		return aSortResult < bSortResult ? -1 : 1
+	})
 }
 
-function sortBy(sortFn){
-	return list => {
-  const clone = cloneList(list);
+function sortBy(sortFn) {
+  return list => sortByFn(sortFn, list, false)
+}
 
-  return clone.sort((a, b) => {
-    const aSortResult = sortFn(a);
-    const bSortResult = sortFn(b);
+function sortByDescending(sortFn) {
+  return list => sortByFn(sortFn, list, true)
+}
 
-    if (aSortResult === bSortResult) return 0
+function sortByPath(sortPath) {
+  return list => sortBy(path(sortPath))(list)
+}
 
-    return aSortResult < bSortResult ? -1 : 1
-  })
+function sortByPathDescending(sortPath) {
+  return list => sortByDescending(path(sortPath))(list)
 }
+
+function sortObject(predicate) {
+  return obj => {
+    const keys = Object.keys(obj);
+    const sortedKeys = sort((a, b) => predicate(a, b, obj[a], obj[b]))(keys);
+
+    const toReturn = {};
+    sortedKeys.forEach(singleKey => {
+      toReturn[singleKey] = obj[singleKey];
+    });
+
+    return toReturn
+  }
 }
 
 function sortHelper(a, b, listOfSortingFns) {
@@ -1185,37 +1487,37 @@ function sortHelper(a, b, listOfSortingFns) {
 }
 
 function sortWith(listOfSortingFns) {
-	return list => {
-  if (Array.isArray(list) === false) {
-    return []
-  }
+  return list => {
+    if (Array.isArray(list) === false) {
+      return []
+    }
 
-  const clone = list.slice();
-  clone.sort((a, b) => sortHelper(a, b, listOfSortingFns));
+    const clone = list.slice();
+    clone.sort((a, b) => sortHelper(a, b, listOfSortingFns));
 
-  return clone
-}
+    return clone
+  }
 }
 
-function split(separator){
-	return str => str.split(separator)
+function split(separator) {
+  return str => str.split(separator)
 }
 
 function splitEvery(sliceLength) {
-	return list => {
-  if (sliceLength < 1) {
-    throw new Error('First argument to splitEvery must be a positive integer')
-  }
+  return list => {
+    if (sliceLength < 1) {
+      throw new Error('First argument to splitEvery must be a positive integer')
+    }
 
-  const willReturn = [];
-  let counter = 0;
+    const willReturn = [];
+    let counter = 0;
 
-  while (counter < list.length) {
-    willReturn.push(list.slice(counter, (counter += sliceLength)));
-  }
+    while (counter < list.length) {
+      willReturn.push(list.slice(counter, (counter += sliceLength)));
+    }
 
-  return willReturn
-}
+    return willReturn
+  }
 }
 
 function symmetricDifference(x) {
@@ -1261,24 +1563,24 @@ function takeLast(numberOfItems) {
 }
 
 function takeLastWhile(predicate) {
-	return input => {
-		if (input.length === 0) {
-			return input
-		}
-	
-		const toReturn = [];
-		let counter = input.length;
-	
-		while (counter) {
-			const item = input[--counter];
-			if (!predicate(item)) {
-				break
-			}
-			toReturn.push(item);
-		}
-	
-		return toReturn.reverse() 
-	}
+  return input => {
+    if (input.length === 0) {
+      return input
+    }
+
+    const toReturn = [];
+    let counter = input.length;
+
+    while (counter) {
+      const item = input[--counter];
+      if (!predicate(item)) {
+        break
+      }
+      toReturn.push(item);
+    }
+
+    return toReturn.reverse()
+  }
 }
 
 function takeWhile(predicate) {
@@ -1298,15 +1600,15 @@ function takeWhile(predicate) {
 }
 
 function tap(fn) {
-	return x => {
-  fn(x);
+  return x => {
+    fn(x);
 
-  return x
-}
+    return x
+  }
 }
 
 function test(pattern) {
-	return str => str.search(pattern) !== -1
+  return str => str.search(pattern) !== -1
 }
 
 function tryCatch(fn, fallback) {
@@ -1321,7 +1623,7 @@ function tryCatch(fn, fallback) {
 
 function union(x) {
   return y => {
-    const toReturn = cloneList(x);
+    const toReturn = cloneList$1(x);
 
     y.forEach(yInstance => {
       if (!includes(yInstance)(x)) {
@@ -1385,11 +1687,11 @@ function uniq(list) {
 }
 
 function uniqBy(fn) {
-	return list => {
-		const set = new _Set();
+  return list => {
+    const set = new _Set();
 
-		return list.filter(item => set.checkUniqueness(fn(item)))
-	}
+    return list.filter(item => set.checkUniqueness(fn(item)))
+  }
 }
 
 function includesWith(predicate, target, list) {
@@ -1408,20 +1710,20 @@ function includesWith(predicate, target, list) {
 }
 
 function uniqWith(predicate) {
-	return list => {
-  let index = -1;
-  const willReturn = [];
+  return list => {
+    let index = -1;
+    const willReturn = [];
 
-  while (++index < list.length) {
-    const value = list[index];
+    while (++index < list.length) {
+      const value = list[index];
 
-    if (!includesWith(predicate, value, willReturn)) {
-      willReturn.push(value);
+      if (!includesWith(predicate, value, willReturn)) {
+        willReturn.push(value);
+      }
     }
-  }
 
-  return willReturn
-}
+    return willReturn
+  }
 }
 
 function unless(predicate, whenFalseFn) {
@@ -1443,17 +1745,6 @@ function unwind(property) {
   }
 }
 
-function update(index, newValue) {
-  return list => {
-    const clone = cloneList(list);
-    if (index === -1) {
-      return clone.fill(newValue, index)
-    }
-
-    return clone.fill(newValue, index, index + 1)
-  }
-}
-
 function when(predicate, whenTrueFn) {
   return input => {
     if (!predicate(input)) {
@@ -1484,4 +1775,128 @@ function zipWith(fn, x) {
     )
 }
 
-export { _arity, _includes, _indexOf, _lastIndexOf, all, allPass, any, anyPass, append, checkObjectWithSpec, complement, concat, count, countBy, defaultTo, drop, dropLast, dropLastWhile, dropWhile, eqBy, eqProps, equals, equalsFn, evolve, evolveFn, excludes, filter, filterObject, find, findIndex, findLast, findLastIndex, flatMap, flatten, groupBy, head, includes, indexOf, init, innerJoin, intersection, intersperse, join, last, lastIndexOf, map, mapAsync, mapObject, mapObjectAsync, match, maxBy, merge, mergeTypes, minBy, modifyPath, none, objOf, omit, partition, partitionArray, partitionObject, path, pick, pipe, pipeAsync, pluck, prepend, prop, propEq, propOr, propSatisfies, range, reduce, reject, replace, replaceItemAtIndex, sort, sortBy, sortWith, split, splitEvery, symmetricDifference, tail, take, takeLast, takeLastWhile, takeWhile, tap, test, tryCatch, type, union, uniq, uniqBy, uniqWith, unless, unwind, update, when, zip, zipWith };
+exports._arity = _arity;
+exports._includes = _includes;
+exports._indexOf = _indexOf;
+exports._lastIndexOf = _lastIndexOf;
+exports.addProp = addProp;
+exports.addPropToObjects = addPropToObjects;
+exports.all = all;
+exports.allPass = allPass;
+exports.any = any;
+exports.anyPass = anyPass;
+exports.append = append;
+exports.ascend = ascend;
+exports.checkObjectWithSpec = checkObjectWithSpec;
+exports.compact = compact;
+exports.complement = complement;
+exports.concat = concat;
+exports.count = count;
+exports.countBy = countBy;
+exports.createCompareFunction = createCompareFunction;
+exports.createObjectFromKeys = createObjectFromKeys;
+exports.defaultTo = defaultTo;
+exports.descend = descend;
+exports.drop = drop;
+exports.dropLast = dropLast;
+exports.dropLastWhile = dropLastWhile;
+exports.dropWhile = dropWhile;
+exports.eqBy = eqBy;
+exports.eqProps = eqProps;
+exports.equals = equals;
+exports.equalsFn = equalsFn;
+exports.evolve = evolve;
+exports.excludes = excludes;
+exports.filter = filter;
+exports.filterObject = filterObject;
+exports.find = find;
+exports.findIndex = findIndex;
+exports.findLast = findLast;
+exports.findLastIndex = findLastIndex;
+exports.findNth = findNth;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.flattenObject = flattenObject;
+exports.flattenObjectHelper = flattenObjectHelper;
+exports.groupBy = groupBy;
+exports.groupByFallback = groupByFallback;
+exports.head = head;
+exports.includes = includes;
+exports.indexOf = indexOf;
+exports.init = init;
+exports.innerJoin = innerJoin;
+exports.interpolate = interpolate;
+exports.intersection = intersection;
+exports.intersperse = intersperse;
+exports.join = join;
+exports.last = last;
+exports.lastIndexOf = lastIndexOf;
+exports.map = map;
+exports.mapAsync = mapAsync;
+exports.mapFn = mapFn;
+exports.mapKeys = mapKeys;
+exports.mapObject = mapObject;
+exports.mapObjectAsync = mapObjectAsync;
+exports.mapParallelAsync = mapParallelAsync;
+exports.match = match;
+exports.maxBy = maxBy;
+exports.merge = merge;
+exports.mergeTypes = mergeTypes;
+exports.minBy = minBy;
+exports.modifyItemAtIndex = modifyItemAtIndex;
+exports.modifyProp = modifyProp;
+exports.none = none;
+exports.objOf = objOf;
+exports.objectIncludes = objectIncludes;
+exports.omit = omit;
+exports.partition = partition;
+exports.partitionObject = partitionObject;
+exports.path = path;
+exports.pathSatisfies = pathSatisfies;
+exports.permutations = permutations;
+exports.pick = pick;
+exports.pipe = pipe;
+exports.pipeAsync = pipeAsync;
+exports.pluck = pluck;
+exports.prepend = prepend;
+exports.prop = prop;
+exports.propEq = propEq;
+exports.propOr = propOr;
+exports.propSatisfies = propSatisfies;
+exports.range = range;
+exports.reduce = reduce;
+exports.reject = reject;
+exports.rejectObject = rejectObject;
+exports.replace = replace;
+exports.shuffle = shuffle;
+exports.sort = sort;
+exports.sortBy = sortBy;
+exports.sortByDescending = sortByDescending;
+exports.sortByFn = sortByFn;
+exports.sortByPath = sortByPath;
+exports.sortByPathDescending = sortByPathDescending;
+exports.sortObject = sortObject;
+exports.sortWith = sortWith;
+exports.split = split;
+exports.splitEvery = splitEvery;
+exports.symmetricDifference = symmetricDifference;
+exports.tail = tail;
+exports.take = take;
+exports.takeLast = takeLast;
+exports.takeLastWhile = takeLastWhile;
+exports.takeWhile = takeWhile;
+exports.tap = tap;
+exports.test = test;
+exports.transformFlatObject = transformFlatObject;
+exports.tryCatch = tryCatch;
+exports.type = type;
+exports.union = union;
+exports.uniq = uniq;
+exports.uniqBy = uniqBy;
+exports.uniqWith = uniqWith;
+exports.unless = unless;
+exports.unwind = unwind;
+exports.update = update;
+exports.when = when;
+exports.zip = zip;
+exports.zipWith = zipWith;