es-toolkit 0.0.1-dev.20

package/esm/array/dropRightWhile.mjs

@@ -0,0 +1,26 @@
+import { dropWhile } from './dropWhile.mjs';
+
+/**
+ * Removes elements from the end of an array until the predicate returns false.
+ * 
+ * This function iterates over an array from the end and drops elements until the provided 
+ * predicate function returns false. It then returns a new array with the remaining elements.
+ *
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {function(item: T): boolean} canContinueDropping - A predicate function that determines 
+ * whether to continue dropping elements. The function is called with each element from the end, 
+ * and dropping continues as long as it returns true.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropRightWhile(array, x => x > 3);
+ * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
+ */
+function dropRightWhile(arr, canContinueDropping) {
+  var reversed = arr.slice().reverse();
+  var dropped = dropWhile(reversed, canContinueDropping);
+  return dropped.slice().reverse();
+}
+
+export { dropRightWhile };

package/esm/array/dropWhile.mjs

@@ -0,0 +1,25 @@
+/**
+ * Removes elements from the beginning of an array until the predicate returns false.
+ * 
+ * This function iterates over an array and drops elements from the start until the provided 
+ * predicate function returns false. It then returns a new array with the remaining elements.
+ *
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines 
+ * whether to continue dropping elements. The function is called with each element, and dropping 
+ * continues as long as it returns true.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropWhile(array, x => x < 3);
+ * // result will be [3, 4, 5] since elements less than 3 are dropped.
+ */
+function dropWhile(arr, canContinueDropping) {
+  var dropEndIndex = arr.findIndex(function (item) {
+    return !canContinueDropping(item);
+  });
+  return arr.slice(dropEndIndex);
+}
+
+export { dropWhile };

package/esm/array/groupBy.mjs

@@ -0,0 +1,54 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * Groups the elements of an array based on a provided key-generating function.
+ * 
+ * This function takes an array and a function that generates a key from each element. It returns 
+ * an object where the keys are the generated keys and the values are arrays of elements that share 
+ * the same key.
+ *
+ * @param {T[]} arr - The array to group.
+ * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that 
+ * share that key.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = groupBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: [
+ * //     { category: 'fruit', name: 'apple' },
+ * //     { category: 'fruit', name: 'banana' }
+ * //   ],
+ * //   vegetable: [
+ * //     { category: 'vegetable', name: 'carrot' }
+ * //   ]
+ * // }
+ */
+function groupBy(arr, getKeyFromItem) {
+  var result = {};
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var key = getKeyFromItem(item);
+      if (result[key] == null) {
+        result[key] = [];
+      }
+      result[key].push(item);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { groupBy };

package/esm/array/index.mjs

@@ -0,0 +1,30 @@
+export { chunk } from './chunk.mjs';
+export { difference } from './difference.mjs';
+export { differenceBy } from './differenceBy.mjs';
+export { differenceWith } from './differenceWith.mjs';
+export { drop } from './drop.mjs';
+export { dropRight } from './dropRight.mjs';
+export { dropRightWhile } from './dropRightWhile.mjs';
+export { dropWhile } from './dropWhile.mjs';
+export { groupBy } from './groupBy.mjs';
+export { intersection } from './intersection.mjs';
+export { intersectionBy } from './intersectionBy.mjs';
+export { intersectionWith } from './intersectionWith.mjs';
+export { partition } from './partition.mjs';
+export { sample } from './sample.mjs';
+export { shuffle } from './shuffle.mjs';
+export { take } from './take.mjs';
+export { takeRight } from './takeRight.mjs';
+export { takeRightWhile } from './takeRightWhile.mjs';
+export { takeWhile } from './takeWhile.mjs';
+export { union } from './union.mjs';
+export { unionBy } from './unionBy.mjs';
+export { unionWith } from './unionWith.mjs';
+export { uniq } from './uniq.mjs';
+export { uniqBy } from './uniqBy.mjs';
+export { uniqWith } from './uniqWith.mjs';
+export { xor } from './xor.mjs';
+export { xorBy } from './xorBy.mjs';
+export { xorWith } from './xorWith.mjs';
+export { zip } from './zip.mjs';
+export { zipWith } from './zipWith.mjs';

package/esm/array/intersection.mjs

@@ -0,0 +1,24 @@
+/**
+ * Returns the intersection of two arrays.
+ * 
+ * This function takes two arrays and returns a new array containing the elements that are 
+ * present in both arrays. It effectively filters out any elements from the first array that 
+ * are not found in the second array.
+ *
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @returns {T[]} A new array containing the elements that are present in both arrays.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [3, 4, 5, 6, 7];
+ * const result = intersection(array1, array2);
+ * // result will be [3, 4, 5] since these elements are in both arrays.
+ */
+function intersection(firstArr, secondArr) {
+  return firstArr.filter(function (item) {
+    return secondArr.includes(item);
+  });
+}
+
+export { intersection };

package/esm/array/intersectionBy.mjs

@@ -0,0 +1,30 @@
+/**
+ * Returns the intersection of two arrays based on a mapping function.
+ * 
+ * This function takes two arrays and a mapping function. It returns a new array containing 
+ * the elements from the first array that, when mapped using the provided function, have matching 
+ * mapped elements in the second array. It effectively filters out any elements from the first array 
+ * that do not have corresponding mapped values in the second array.
+ *
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const mapper = item => item.id;
+ * const result = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
+ */
+function intersectionBy(firstArr, secondArr, mapper) {
+  var mappedSecondArr = secondArr.map(function (x) {
+    return mapper(x);
+  });
+  return firstArr.filter(function (item) {
+    return mappedSecondArr.includes(mapper(item));
+  });
+}
+
+export { intersectionBy };

package/esm/array/intersectionWith.mjs

@@ -0,0 +1,30 @@
+/**
+ * Returns the intersection of two arrays based on a custom equality function.
+ * 
+ * This function takes two arrays and a custom equality function. It returns a new array containing 
+ * the elements from the first array that have matching elements in the second array, as determined 
+ * by the custom equality function. It effectively filters out any elements from the first array that 
+ * do not have corresponding matches in the second array according to the equality function.
+ *
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @param {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. 
+ * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
+ *
+ * @example
+ *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
+ */
+function intersectionWith(firstArr, secondArr, areItemsEqual) {
+  return firstArr.filter(function (firstItem) {
+    return secondArr.some(function (secondItem) {
+      return areItemsEqual(firstItem, secondItem);
+    });
+  });
+}
+
+export { intersectionWith };

package/esm/array/partition.mjs

@@ -0,0 +1,46 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * Splits an array into two groups based on a predicate function.
+ * 
+ * This function takes an array and a predicate function. It returns a tuple of two arrays: 
+ * the first array contains elements for which the predicate function returns true, and 
+ * the second array contains elements for which the predicate function returns false.
+ *
+ * @param {T[]} arr - The array to partition.
+ * @param {(value: T) => boolean} isInTruthy - A predicate function that determines 
+ * whether an element should be placed in the truthy array. The function is called with each 
+ * element of the array.
+ * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for 
+ * which the predicate returned true, and the second array contains elements for which the 
+ * predicate returned false.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const isEven = x => x % 2 === 0;
+ * const [even, odd] = partition(array, isEven);
+ * // even will be [2, 4], and odd will be [1, 3, 5]
+ */
+function partition(arr, isInTruthy) {
+  var truthy = [];
+  var falsy = [];
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      if (isInTruthy(item)) {
+        truthy.push(item);
+      } else {
+        falsy.push(item);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return [truthy, falsy];
+}
+
+export { partition };

package/esm/array/sample.mjs

@@ -0,0 +1,19 @@
+/**
+ * Returns a random element from an array.
+ * 
+ * This function takes an array and returns a single element selected randomly from the array.
+ *
+ * @param {T[]} arr - The array to sample from.
+ * @returns {T} A random element from the array.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const randomElement = sample(array);
+ * // randomElement will be one of the elements from the array, selected randomly.
+ */
+function sample(arr) {
+  var randomIndex = Math.floor(Math.random() * arr.length);
+  return arr[randomIndex];
+}
+
+export { sample };

package/esm/array/shuffle.mjs

@@ -0,0 +1,27 @@
+/**
+ * Randomizes the order of elements in an array using the Fisher-Yates algorithm.
+ * 
+ * This function takes an array and returns a new array with its elements shuffled in a random order.
+ *
+ * @param {T[]} arr - The array to shuffle.
+ * @returns {T[]} A new array with its elements shuffled in random order.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const shuffledArray = shuffle(array);
+ * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
+ */
+function shuffle(arr) {
+  /**
+   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm
+   */
+  for (var i = arr.length - 1; i >= 1; i--) {
+    var j = Math.floor(Math.random() * (i + 1));
+    var _ref = [arr[j], arr[i]];
+    arr[i] = _ref[0];
+    arr[j] = _ref[1];
+  }
+  return arr;
+}
+
+export { shuffle };

package/esm/array/take.mjs

@@ -0,0 +1,27 @@
+/**
+ * Returns a new array containing the first `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ *
+ * @template T - Type of elements in the input array.
+ * 
+ * @param {T[]} arr - The array to take elements from.
+ * @param {number} count - The number of elements to take.
+ * @returns {T[]} A new array containing the first `count` elements from `arr`.
+ * 
+ * @example
+ * // Returns [1, 2, 3]
+ * take([1, 2, 3, 4, 5], 3);
+ * 
+ * @example
+ * // Returns ['a', 'b']
+ * take(['a', 'b', 'c'], 2);
+ * 
+ * @example
+ * // Returns [1, 2, 3]
+ * take([1, 2, 3], 5);
+ */
+function take(arr, count) {
+  return arr.slice(0, count);
+}
+
+export { take };

package/esm/array/takeRight.mjs

@@ -0,0 +1,28 @@
+/**
+ * Returns a new array containing the last `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ * 
+ * @param {T[]} arr - The array to take elements from.
+ * @param {number} count - The number of elements to take.
+ * @returns {T[]} A new array containing the last `count` elements from `arr`.
+ * 
+ * @example
+ * // Returns [4, 5]
+ * takeRight([1, 2, 3, 4, 5], 2);
+ * 
+ * @example
+ * // Returns ['b', 'c']
+ * takeRight(['a', 'b', 'c'], 2);
+ * 
+ * @example
+ * // Returns [1, 2, 3]
+ * takeRight([1, 2, 3], 5);
+ */
+function takeRight(arr, count) {
+  if (count === 0) {
+    return [];
+  }
+  return arr.slice(-count);
+}
+
+export { takeRight };

package/esm/array/takeRightWhile.mjs

@@ -0,0 +1,27 @@
+/**
+ * Takes elements from the end of the array while the predicate function returns `true`.
+ * 
+ * @template T - Type of elements in the input array.
+ * 
+ * @param {T[]} arr - The array to take elements from.
+ * @param {function(T): boolean} shouldContinueTaking - The function invoked per element.
+ * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.
+ * 
+ * @example
+ * // Returns [3, 2, 1]
+ * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
+ * 
+ * @example
+ * // Returns []
+ * takeRightWhile([1, 2, 3], n => n > 3);
+ */
+function takeRightWhile(arr, shouldContinueTaking) {
+  for (var i = arr.length - 1; i >= 0; i--) {
+    if (!shouldContinueTaking(arr[i])) {
+      return arr.slice(i + 1);
+    }
+  }
+  return arr.slice();
+}
+
+export { takeRightWhile };

package/esm/array/takeWhile.mjs

@@ -0,0 +1,41 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * Returns a new array containing the leading elements of the provided array
+ * that satisfy the provided predicate function. It stops taking elements as soon
+ * as an element does not satisfy the predicate.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to process.
+ * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true.
+ * @returns {T[]} A new array containing the leading elements that satisfy the predicate.
+ *
+ * @example
+ * // Returns [1, 2]
+ * takeWhile([1, 2, 3, 4], x => x < 3);
+ *
+ * @example
+ * // Returns []
+ * takeWhile([1, 2, 3, 4], x => x > 3);
+ */
+function takeWhile(arr, shouldContinueTaking) {
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      if (!shouldContinueTaking(item)) {
+        break;
+      }
+      result.push(item);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { takeWhile };

package/esm/array/union.mjs

@@ -0,0 +1,23 @@
+import { uniq } from './uniq.mjs';
+
+/**
+ * Creates an array of unique values from all given arrays.
+ * 
+ * This function takes two arrays, merges them into a single array, and returns a new array 
+ * containing only the unique values from the merged array.
+ *
+ * @param {T[]} arr1 - The first array to merge and filter for unique values.
+ * @param {T[]} arr2 - The second array to merge and filter for unique values.
+ * @returns {T[]} A new array of unique values.
+ *
+ * @example
+ * const array1 = [1, 2, 3];
+ * const array2 = [3, 4, 5];
+ * const result = union(array1, array2);
+ * // result will be [1, 2, 3, 4, 5]
+ */
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
+}
+
+export { union };

package/esm/array/unionBy.mjs

@@ -0,0 +1,35 @@
+import { toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.
+ * 
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @param {function(item: T): U} mapper - The function to map array elements to comparison values.
+ * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function.
+ * 
+ * @example
+ * // Custom mapping function for numbers (modulo comparison)
+ * const moduloMapper = (x) => x % 3;
+ * unionBy([1, 2, 3], [4, 5, 6], moduloMapper);
+ * // Returns [1, 2, 3]
+ * 
+ * @example
+ * // Custom mapping function for objects with an 'id' property
+ * const idMapper = (obj) => obj.id;
+ * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
+ * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]
+ */
+function unionBy(arr1, arr2, mapper) {
+  var map = new Map();
+  for (var _i = 0, _arr = [].concat(_toConsumableArray(arr1), _toConsumableArray(arr2)); _i < _arr.length; _i++) {
+    var item = _arr[_i];
+    var key = mapper(item);
+    if (!map.has(key)) {
+      map.set(key, item);
+    }
+  }
+  return _toConsumableArray(map.values());
+}
+
+export { unionBy };

package/esm/array/unionWith.mjs

@@ -0,0 +1,26 @@
+import { uniqWith } from './uniqWith.mjs';
+
+/**
+ * Creates an array of unique values from two given arrays based on a custom equality function.
+ * 
+ * This function takes two arrays and a custom equality function, merges the arrays, and returns 
+ * a new array containing only the unique values as determined by the custom equality function.
+ *
+ * @param {T[]} arr1 - The first array to merge and filter for unique values.
+ * @param {T[]} arr2 - The second array to merge and filter for unique values.
+ * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. 
+ * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array of unique values based on the custom equality function.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }];
+ * const array2 = [{ id: 2 }, { id: 3 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = unionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
+ */
+function unionWith(arr1, arr2, areItemsEqual) {
+  return uniqWith(arr1.concat(arr2), areItemsEqual);
+}
+
+export { unionWith };

package/esm/array/uniq.mjs

@@ -0,0 +1,37 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * Creates a duplicate-free version of an array.
+ * 
+ * This function takes an array and returns a new array containing only the unique values 
+ * from the original array, preserving the order of first occurrence.
+ *
+ * @param {T[]} arr - The array to process.
+ * @returns {T[]} A new array with only unique values from the original array.
+ *
+ * @example
+ *  * const array = [1, 2, 2, 3, 4, 4, 5];
+ * const result = uniq(array);
+ * // result will be [1, 2, 3, 4, 5]
+ */
+function uniq(arr) {
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      if (result.includes(item)) {
+        continue;
+      }
+      result.push(item);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { uniq };

package/esm/array/uniqBy.mjs

@@ -0,0 +1,20 @@
+import { uniqWith } from './uniqWith.mjs';
+
+/**
+ * The `uniqBy` function takes an array as its first argument and a 'converter' function as the second. It maps the array elements using the converter function, then removes any duplicates.
+ *
+ * It filters out elements with the same value, meaning it does not check for duplicates in data types like Objects.
+ *
+ * @example
+ * ```ts
+ * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
+ * // [1.2, 2.1, 3.3, 5.7, 7.19]
+ * ```
+ */
+function uniqBy(arr, converter) {
+  return uniqWith(arr, function (item1, item2) {
+    return converter(item1) === converter(item2);
+  });
+}
+
+export { uniqBy };

package/esm/array/uniqWith.mjs

@@ -0,0 +1,39 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+/**
+ * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.
+ *
+ * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.
+ *
+ * @example
+ * ```ts
+ * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => );
+ * // [1, 2, 3, 5, 7]
+ * ```
+ */
+function uniqWith(arr, areItemsEqual) {
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var item = _step.value;
+      var isUniq = result.every(function (v) {
+        return !areItemsEqual(v, item);
+      });
+      if (isUniq) {
+        result.push(item);
+      }
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+export { uniqWith };

package/esm/array/xor.mjs

@@ -0,0 +1,25 @@
+import { difference } from './difference.mjs';
+import { intersection } from './intersection.mjs';
+import { union } from './union.mjs';
+
+/**
+ * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements
+ * which are in either of the arrays, but not in their intersection.
+ * 
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.
+ * 
+ * @example
+ * // Returns [1, 2, 5, 6]
+ * xor([1, 2, 3, 4], [3, 4, 5, 6]);
+ * 
+ * @example
+ * // Returns ['a', 'c']
+ * xor(['a', 'b'], ['b', 'c']);
+ */
+function xor(arr1, arr2) {
+  return difference(union(arr1, arr2), intersection(arr1, arr2));
+}
+
+export { xor };