@vinicunca/perkakas 0.4.5 → 0.5.4

package/dist/index.cjs

@@ -1,28 +1,5 @@
 'use strict';
 
-const KEY_CODES = {
-  ALT: "Alt",
-  ARROW_DOWN: "ArrowDown",
-  ARROW_LEFT: "ArrowLeft",
-  ARROW_RIGHT: "ArrowRight",
-  ARROW_UP: "ArrowUp",
-  AT: "@",
-  BACKSPACE: "Backspace",
-  CTRL: "Control",
-  DELETE: "Delete",
-  END: "End",
-  ENTER: "Enter",
-  ESC: "Escape",
-  HOME: "Home",
-  KEY_F: "KEY_F",
-  META: "Meta",
-  PAGE_DOWN: "PageDown",
-  PAGE_UP: "PageUp",
-  SHIFT: "Shift",
-  SPACE: "Space",
-  TAB: "Tab"
-};
-
 function purry(fn, args, lazyFactory) {
   const callArgs = Array.from(args);
   const diff = fn.length - args.length;
@@ -37,6 +14,23 @@ function purry(fn, args, lazyFactory) {
   throw new Error("Wrong number of arguments");
 }
 
+function addProp(...args) {
+  return purry(addProp_, args);
+}
+function addProp_(obj, prop, value) {
+  return {
+    ...obj,
+    [prop]: value
+  };
+}
+
+function add(...args) {
+  return purry(add_, args);
+}
+function add_(value, addend) {
+  return value + addend;
+}
+
 function allPass(...args) {
   return purry(allPass_, args);
 }
@@ -51,6 +45,113 @@ function anyPass_(data, fns) {
   return fns.some((fn) => fn(data));
 }
 
+function isString(data) {
+  return typeof data === "string";
+}
+
+const RE_NUMBER_CHAR = /\d/;
+const STR_SPLITTERS = ["-", "_", "/", "."];
+function isUppercase(char = "") {
+  if (RE_NUMBER_CHAR.test(char)) {
+    return void 0;
+  }
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || !isString(str)) {
+    return parts;
+  }
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function toUpperFirst(str) {
+  var _a;
+  return str ? ((_a = str[0]) == null ? void 0 : _a.toUpperCase()) + str.slice(1) : "";
+}
+function toLowerFirst(str) {
+  var _a;
+  return str ? ((_a = str[0]) == null ? void 0 : _a.toLowerCase()) + str.slice(1) : "";
+}
+function toPascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => toUpperFirst((opts == null ? void 0 : opts.normalize) ? p.toLowerCase() : p)).join("") : "";
+}
+function toCamelCase(str, opts) {
+  return toLowerFirst(toPascalCase(str || "", opts));
+}
+function toKebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+function toSnakeCase(str) {
+  return toKebabCase(str || "", "_");
+}
+function toFlatCase(str) {
+  return toKebabCase(str || "", "");
+}
+function toTrainCase(str, opts) {
+  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => toUpperFirst((opts == null ? void 0 : opts.normalize) ? p.toLowerCase() : p)).join("-");
+}
+const titleCaseExceptions = /^(a|an|and|as|at|but|by|for|if|in|is|nor|of|on|or|the|to|with)$/i;
+function toTitleCase(str, opts) {
+  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => titleCaseExceptions.test(p) ? p.toLowerCase() : toUpperFirst((opts == null ? void 0 : opts.normalize) ? p.toLowerCase() : p)).join(" ");
+}
+
+const MAX_PRECISION = 15;
+function _withPrecision(roundingFn) {
+  return (value, precision) => {
+    if (precision === 0) {
+      return roundingFn(value);
+    }
+    if (!Number.isInteger(precision)) {
+      throw new TypeError(`precision must be an integer: ${precision}`);
+    }
+    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {
+      throw new RangeError(`precision must be between ${-MAX_PRECISION} and ${MAX_PRECISION}`);
+    }
+    if (Number.isNaN(value) || !Number.isFinite(value)) {
+      return roundingFn(value);
+    }
+    const multiplier = 10 ** precision;
+    return roundingFn(value * multiplier) / multiplier;
+  };
+}
+
+function ceil(...args) {
+  return purry(_withPrecision(Math.ceil), args);
+}
+
 function chunk(...args) {
   return purry(chunk_, args);
 }
@@ -64,86 +165,251 @@ function chunk_(array, size) {
   return ret;
 }
 
-function concat(...args) {
-  return purry(concat_, args);
+function clamp(...args) {
+  return purry(clamp_, args);
 }
-function concat_(arr1, arr2) {
-  return arr1.concat(arr2);
+function clamp_(value, { max, min }) {
+  if (min !== void 0 && value < min) {
+    return min;
+  }
+  if (max !== void 0 && value > max) {
+    return max;
+  }
+  return value;
 }
 
-function reduceLazy(array, lazy, isIndexed = false) {
-  const out = [];
-  for (let index = 0; index < array.length; index++) {
-    const item = array[index];
-    const result = isIndexed ? lazy(item, index, array) : lazy(item);
-    if (result.hasMany === true) {
-      out.push(...result.next);
-    } else if (result.hasNext) {
-      out.push(result.next);
+function cloneRegExp_(pattern) {
+  return new RegExp(
+    pattern.source,
+    (pattern.global ? "g" : "") + (pattern.ignoreCase ? "i" : "") + (pattern.multiline ? "m" : "") + (pattern.sticky ? "y" : "") + (pattern.unicode ? "u" : "")
+  );
+}
+function clone_(value, refFrom, refTo, deep) {
+  function copy(copiedValue) {
+    const len = refFrom.length;
+    let idx = 0;
+    while (idx < len) {
+      if (value === refFrom[idx]) {
+        return refTo[idx];
+      }
+      idx += 1;
     }
-    if (result.done) {
-      break;
+    refFrom[idx + 1] = value;
+    refTo[idx + 1] = copiedValue;
+    for (const key in value) {
+      copiedValue[key] = deep ? clone_(value[key], refFrom, refTo, true) : value[key];
     }
+    return copiedValue;
+  }
+  switch (type(value)) {
+    case "Object":
+      return copy({});
+    case "Array":
+      return copy([]);
+    case "Date":
+      return new Date(value.valueOf());
+    case "RegExp":
+      return cloneRegExp_(value);
+    default:
+      return value;
   }
-  return out;
-}
-
-function differenceWith(...args) {
-  return purry(differenceWith_, args, differenceWith.lazy);
 }
-function differenceWith_(array, other, isEquals) {
-  const lazy = differenceWith.lazy(other, isEquals);
-  return reduceLazy(array, lazy);
+function clone(value) {
+  return value != null && typeof value.clone === "function" ? value.clone() : clone_(value, [], [], true);
 }
-((differenceWith2) => {
-  function lazy(other, isEquals) {
-    return (value) => other.every((otherValue) => !isEquals(value, otherValue)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+function type(val) {
+  if (val === null) {
+    return "Null";
   }
-  differenceWith2.lazy = lazy;
-})(differenceWith || (differenceWith = {}));
-
-function dropLast(...args) {
-  return purry(dropLast_, args);
-}
-function dropLast_(array, n) {
-  const copy = array.slice();
-  if (n > 0) {
-    copy.splice(-n);
+  if (val === void 0) {
+    return "Undefined";
   }
-  return copy;
+  return Object.prototype.toString.call(val).slice(8, -1);
 }
 
-function drop(...args) {
-  return purry(drop_, args, drop.lazy);
+function concat(...args) {
+  return purry(concat_, args);
 }
-function drop_(array, n) {
-  return reduceLazy(array, drop.lazy(n));
+function concat_(arr1, arr2) {
+  return arr1.concat(arr2);
 }
-((drop2) => {
-  function lazy(n) {
-    let left = n;
-    return (value) => {
-      if (left > 0) {
-        left -= 1;
-        return { done: false, hasNext: false };
-      }
-      return { done: false, hasNext: true, next: value };
-    };
-  }
-  drop2.lazy = lazy;
-})(drop || (drop = {}));
 
-function hasAtLeast(...args) {
-  return purry(hasAtLeastImplementation, args);
-}
-function hasAtLeastImplementation(data, minimum) {
-  return data.length >= minimum;
+function purryOn(isArg, implementation, args) {
+  const callArgs = Array.from(args);
+  return isArg(args[0]) ? (data) => implementation(data, ...callArgs) : implementation(...callArgs);
 }
 
-function swapInPlace(data, i, j) {
-  [data[i], data[j]] = [data[j], data[i]];
+function conditional(...args) {
+  return purryOn(isCase, conditionalImplementation, args);
 }
-
+function conditionalImplementation(data, ...cases) {
+  for (const [when, then] of cases) {
+    if (when(data)) {
+      return then(data);
+    }
+  }
+  throw new Error("conditional: data failed for all cases");
+}
+function isCase(maybeCase) {
+  if (!Array.isArray(maybeCase)) {
+    return false;
+  }
+  const [when, then, ...rest] = maybeCase;
+  return typeof when === "function" && when.length <= 1 && typeof then === "function" && then.length <= 1 && rest.length === 0;
+}
+const trivialDefaultCase = () => void 0;
+((conditional2) => {
+  function defaultCase(then = trivialDefaultCase) {
+    return [() => true, then];
+  }
+  conditional2.defaultCase = defaultCase;
+})(conditional || (conditional = {}));
+
+function debounce(func, {
+  maxWaitMs,
+  timing = "trailing",
+  waitMs
+}) {
+  if (maxWaitMs !== void 0 && waitMs !== void 0 && maxWaitMs < waitMs) {
+    throw new Error(
+      `debounce: maxWaitMs (${maxWaitMs}) cannot be less than waitMs (${waitMs})`
+    );
+  }
+  let coolDownTimeoutId;
+  let maxWaitTimeoutId;
+  let latestCallArgs;
+  let result;
+  function handleDebouncedCall(args) {
+    latestCallArgs = args;
+    if (maxWaitMs !== void 0 && maxWaitTimeoutId === void 0) {
+      maxWaitTimeoutId = setTimeout(handleInvoke, maxWaitMs);
+    }
+  }
+  function handleInvoke() {
+    if (latestCallArgs === void 0) {
+      return;
+    }
+    if (maxWaitTimeoutId !== void 0) {
+      const timeoutId = maxWaitTimeoutId;
+      maxWaitTimeoutId = void 0;
+      clearTimeout(timeoutId);
+    }
+    const args = latestCallArgs;
+    latestCallArgs = void 0;
+    result = func(...args);
+  }
+  function handleCoolDownEnd() {
+    if (coolDownTimeoutId === void 0) {
+      return;
+    }
+    const timeoutId = coolDownTimeoutId;
+    coolDownTimeoutId = void 0;
+    clearTimeout(timeoutId);
+    if (latestCallArgs !== void 0) {
+      handleInvoke();
+    }
+  }
+  return {
+    get cachedValue() {
+      return result;
+    },
+    call: (...args) => {
+      if (coolDownTimeoutId === void 0) {
+        if (timing === "trailing") {
+          handleDebouncedCall(args);
+        } else {
+          result = func(...args);
+        }
+      } else {
+        if (timing !== "leading") {
+          handleDebouncedCall(args);
+        }
+        const timeoutId = coolDownTimeoutId;
+        coolDownTimeoutId = void 0;
+        clearTimeout(timeoutId);
+      }
+      coolDownTimeoutId = setTimeout(
+        handleCoolDownEnd,
+        // If waitMs is not defined but maxWaitMs *is* it means the user is only
+        // interested in the leaky-bucket nature of the debouncer which is
+        // achieved by setting waitMs === maxWaitMs. If both are not defined we
+        // default to 0 which would wait until the end of the execution frame.
+        waitMs ?? maxWaitMs ?? 0
+      );
+      return result;
+    },
+    cancel: () => {
+      if (coolDownTimeoutId !== void 0) {
+        const timeoutId = coolDownTimeoutId;
+        coolDownTimeoutId = void 0;
+        clearTimeout(timeoutId);
+      }
+      if (maxWaitTimeoutId !== void 0) {
+        const timeoutId = maxWaitTimeoutId;
+        maxWaitTimeoutId = void 0;
+        clearTimeout(timeoutId);
+      }
+      latestCallArgs = void 0;
+    },
+    flush: () => {
+      handleCoolDownEnd();
+      return result;
+    },
+    get isPending() {
+      return coolDownTimeoutId !== void 0;
+    }
+  };
+}
+
+function _reduceLazy(array, lazy, isIndexed = false) {
+  const out = [];
+  for (let index = 0; index < array.length; index++) {
+    const item = array[index];
+    const result = isIndexed ? lazy(item, index, array) : lazy(item);
+    if (result.hasMany === true) {
+      out.push(...result.next);
+    } else if (result.hasNext) {
+      out.push(result.next);
+    }
+    if (result.done) {
+      break;
+    }
+  }
+  return out;
+}
+
+function differenceWith(...args) {
+  return purry(differenceWith_, args, differenceWith.lazy);
+}
+function differenceWith_(array, other, isEquals) {
+  const lazy = differenceWith.lazy(other, isEquals);
+  return _reduceLazy(array, lazy);
+}
+((differenceWith2) => {
+  function lazy(other, isEquals) {
+    return (value) => other.every((otherValue) => !isEquals(value, otherValue)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+  }
+  differenceWith2.lazy = lazy;
+})(differenceWith || (differenceWith = {}));
+
+function divide(...args) {
+  return purry(divide_, args);
+}
+function divide_(value, divisor) {
+  return value / divisor;
+}
+
+function swapInPlace(data, i, j) {
+  [data[i], data[j]] = [data[j], data[i]];
+}
+
+function hasAtLeast(...args) {
+  return purry(hasAtLeastImplementation, args);
+}
+function hasAtLeastImplementation(data, minimum) {
+  return data.length >= minimum;
+}
+
 function heapify(heap, compareFn) {
   for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
     heapSiftDown(heap, i, compareFn);
@@ -218,7 +484,7 @@ function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
     if (comparator(projectedB, projectedA)) {
       return -1;
     }
-    return nextComparer?.(a, b) ?? 0;
+    return (nextComparer == null ? void 0 : nextComparer(a, b)) ?? 0;
   };
 }
 function isOrderRule(x) {
@@ -268,6 +534,17 @@ function dropLastWhile_(data, predicate) {
   return [];
 }
 
+function dropLast(...args) {
+  return purry(dropLast_, args);
+}
+function dropLast_(array, n) {
+  const copy = array.slice();
+  if (n > 0) {
+    copy.splice(-n);
+  }
+  return copy;
+}
+
 function dropWhile(...args) {
   return purry(dropWhile_, args);
 }
@@ -280,7 +557,34 @@ function dropWhile_(data, predicate) {
   return [];
 }
 
-function toLazyIndexed(fn) {
+function drop(...args) {
+  return purry(drop_, args, drop.lazy);
+}
+function drop_(array, n) {
+  return _reduceLazy(array, drop.lazy(n));
+}
+((drop2) => {
+  function lazy(n) {
+    let left = n;
+    return (value) => {
+      if (left > 0) {
+        left -= 1;
+        return { done: false, hasNext: false };
+      }
+      return { done: false, hasNext: true, next: value };
+    };
+  }
+  drop2.lazy = lazy;
+})(drop || (drop = {}));
+
+function entries(...args) {
+  return purry(Object.entries, args);
+}
+((entries2) => {
+  entries2.strict = entries2;
+})(entries || (entries = {}));
+
+function _toLazyIndexed(fn) {
   return Object.assign(fn, { indexed: true });
 }
 
@@ -289,14 +593,14 @@ function filter(...args) {
 }
 function filter_(indexed) {
   return (array, fn) => {
-    return reduceLazy(
+    return _reduceLazy(
       array,
       indexed ? filter.lazyIndexed(fn) : filter.lazy(fn),
       indexed
     );
   };
 }
-function lazy_$6(indexed) {
+function lazy_$5(indexed) {
   return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
 }
 ((filter2) => {
@@ -304,11 +608,11 @@ function lazy_$6(indexed) {
     return purry(filter_(true), args, filter2.lazyIndexed);
   }
   filter2.indexed = indexed;
-  filter2.lazy = lazy_$6(false);
-  filter2.lazyIndexed = toLazyIndexed(lazy_$6(true));
+  filter2.lazy = lazy_$5(false);
+  filter2.lazyIndexed = _toLazyIndexed(lazy_$5(true));
 })(filter || (filter = {}));
 
-function toSingle(fn) {
+function _toSingle(fn) {
   return Object.assign(fn, { single: true });
 }
 
@@ -318,7 +622,7 @@ function findIndex(...args) {
 function findIndex_(indexed) {
   return (array, fn) => array.findIndex((item, index, input) => indexed ? fn(item, index, input) : fn(item));
 }
-function lazy_$5(indexed) {
+function lazy_$4(indexed) {
   return (fn) => {
     let actualIndex = 0;
     return (value, index, array) => {
@@ -335,8 +639,8 @@ function lazy_$5(indexed) {
     return purry(findIndex_(true), args, findIndex2.lazyIndexed);
   }
   findIndex2.indexed = indexed;
-  findIndex2.lazy = toSingle(lazy_$5(false));
-  findIndex2.lazyIndexed = toSingle(toLazyIndexed(lazy_$5(true)));
+  findIndex2.lazy = _toSingle(lazy_$4(false));
+  findIndex2.lazyIndexed = _toSingle(_toLazyIndexed(lazy_$4(true)));
 })(findIndex || (findIndex = {}));
 
 function findLastIndex(...args) {
@@ -385,7 +689,7 @@ function find(...args) {
 function find_(indexed) {
   return (array, fn) => array.find((item, index, input) => indexed ? fn(item, index, input) : fn(item));
 }
-function lazy_$4(indexed) {
+function lazy_$3(indexed) {
   return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value)) ? { done: true, hasNext: true, next: value } : { done: false, hasNext: false };
 }
 ((find2) => {
@@ -393,26 +697,10 @@ function lazy_$4(indexed) {
     return purry(find_(true), args, find2.lazyIndexed);
   }
   find2.indexed = indexed;
-  find2.lazy = toSingle(lazy_$4(false));
-  find2.lazyIndexed = toSingle(toLazyIndexed(lazy_$4(true)));
+  find2.lazy = _toSingle(lazy_$3(false));
+  find2.lazyIndexed = _toSingle(_toLazyIndexed(lazy_$3(true)));
 })(find || (find = {}));
 
-function first(...args) {
-  return purry(first_, args, first.lazy);
-}
-function first_([item]) {
-  return item;
-}
-((first2) => {
-  function lazy() {
-    return (value) => ({ done: true, hasNext: true, next: value });
-  }
-  first2.lazy = lazy;
-  ((lazy2) => {
-    lazy2.single = true;
-  })(lazy = first2.lazy || (first2.lazy = {}));
-})(first || (first = {}));
-
 function firstBy(...args) {
   return purryOrderRules(firstByImplementation, args);
 }
@@ -430,33 +718,27 @@ function firstByImplementation(data, compareFn) {
   return currentFirst;
 }
 
-function flatMapToObj(...args) {
-  return purry(flatMapToObj_(false), args);
+function first(...args) {
+  return purry(first_, args, first.lazy);
 }
-function flatMapToObj_(indexed) {
-  return (array, fn) => {
-    const out = {};
-    for (const [index, element] of array.entries()) {
-      const items = indexed ? fn(element, index, array) : fn(element);
-      for (const [key, value] of items) {
-        out[key] = value;
-      }
-    }
-    return out;
-  };
+function first_([item]) {
+  return item;
 }
-((flatMapToObj2) => {
-  function indexed(...args) {
-    return purry(flatMapToObj_(true), args);
+((first2) => {
+  function lazy() {
+    return (value) => ({ done: true, hasNext: true, next: value });
   }
-  flatMapToObj2.indexed = indexed;
-})(flatMapToObj || (flatMapToObj = {}));
+  first2.lazy = lazy;
+  ((lazy2) => {
+    lazy2.single = true;
+  })(lazy = first2.lazy || (first2.lazy = {}));
+})(first || (first = {}));
 
 function flatten(...args) {
   return purry(flatten_, args, flatten.lazy);
 }
 function flatten_(items) {
-  return reduceLazy(items, flatten.lazy());
+  return _reduceLazy(items, flatten.lazy());
 }
 ((flatten2) => {
   function lazy() {
@@ -488,7 +770,7 @@ function flattenDeep(...args) {
   return purry(flattenDeep_, args, flattenDeep.lazy);
 }
 function flattenDeep_(items) {
-  return reduceLazy(items, flattenDeep.lazy());
+  return _reduceLazy(items, flattenDeep.lazy());
 }
 function flattenDeepValue_(value) {
   if (!Array.isArray(value)) {
@@ -514,21 +796,50 @@ function flattenDeepValue_(value) {
   flattenDeep2.lazy = lazy;
 })(flattenDeep || (flattenDeep = {}));
 
-function forEach(...args) {
-  return purry(forEach_(false), args, forEach.lazy);
+function floor(...args) {
+  return purry(_withPrecision(Math.floor), args);
 }
-function forEach_(indexed) {
-  return (array, fn) => reduceLazy(
-    array,
-    indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
-    indexed
-  );
+
+function forEachObj(...args) {
+  return purry(forEachObj_(false), args);
 }
-function lazy_$3(indexed) {
-  return (fn) => (value, index, array) => {
-    if (indexed) {
-      fn(value, index, array);
-    } else {
+function forEachObj_(indexed) {
+  return (data, fn) => {
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        const { [key]: val } = data;
+        if (indexed) {
+          fn(val, key, data);
+        } else {
+          fn(val);
+        }
+      }
+    }
+    return data;
+  };
+}
+((forEachObj2) => {
+  function indexed(...args) {
+    return purry(forEachObj_(true), args);
+  }
+  forEachObj2.indexed = indexed;
+})(forEachObj || (forEachObj = {}));
+
+function forEach(...args) {
+  return purry(forEach_(false), args, forEach.lazy);
+}
+function forEach_(indexed) {
+  return (array, fn) => _reduceLazy(
+    array,
+    indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
+    indexed
+  );
+}
+function lazy_$2(indexed) {
+  return (fn) => (value, index, array) => {
+    if (indexed) {
+      fn(value, index, array);
+    } else {
       fn(value);
     }
     return {
@@ -543,10 +854,35 @@ function lazy_$3(indexed) {
     return purry(forEach_(true), args, forEach2.lazyIndexed);
   }
   forEach2.indexed = indexed;
-  forEach2.lazy = lazy_$3(false);
-  forEach2.lazyIndexed = toLazyIndexed(lazy_$3(true));
+  forEach2.lazy = lazy_$2(false);
+  forEach2.lazyIndexed = _toLazyIndexed(lazy_$2(true));
 })(forEach || (forEach = {}));
 
+function fromEntries(...args) {
+  return purry(fromEntriesImplementation, args);
+}
+function fromEntriesImplementation(entries) {
+  const out = {};
+  for (const [key, value] of entries) {
+    out[key] = value;
+  }
+  return out;
+}
+((fromEntries2) => {
+  fromEntries2.strict = fromEntries2;
+})(fromEntries || (fromEntries = {}));
+
+function fromKeys(...args) {
+  return purry(fromKeysImplementation, args);
+}
+function fromKeysImplementation(data, mapper) {
+  const result = {};
+  for (const key of data) {
+    result[key] = mapper(key);
+  }
+  return result;
+}
+
 function groupBy(...args) {
   return purry(groupBy_(false), args);
 }
@@ -576,6 +912,92 @@ function groupBy_(indexed) {
   groupBy2.strict = groupBy2;
 })(groupBy || (groupBy = {}));
 
+function isDeepEqual(...args) {
+  return purry(isDeepEqualImplementation, args);
+}
+function isDeepEqualImplementation(data, other) {
+  if (data === other) {
+    return true;
+  }
+  if (typeof data === "number" && typeof other === "number") {
+    return data !== data && other !== other;
+  }
+  if (typeof data !== "object" || typeof other !== "object") {
+    return false;
+  }
+  if (data === null || other === null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(data) !== Object.getPrototypeOf(other)) {
+    return false;
+  }
+  if (Array.isArray(data)) {
+    if (data.length !== other.length) {
+      return false;
+    }
+    for (let i = 0; i < data.length; i++) {
+      if (!isDeepEqualImplementation(
+        data[i],
+        other[i]
+      )) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (data instanceof Date) {
+    return data.getTime() === other.getTime();
+  }
+  if (data instanceof RegExp) {
+    return data.toString() === other.toString();
+  }
+  const keys = Object.keys(data);
+  if (keys.length !== Object.keys(other).length) {
+    return false;
+  }
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(other, key)) {
+      return false;
+    }
+    if (!isDeepEqualImplementation(data[key], other[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function hasSubObject(...args) {
+  return purry(_hasSubObject, args);
+}
+function _hasSubObject(data, subObject) {
+  for (const key of Object.keys(subObject)) {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      return false;
+    }
+    if (!isDeepEqual(subObject[key], data[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function humanReadableFileSize(bytes, base = 1e3) {
+  if (bytes < base) {
+    return `${bytes} B`;
+  }
+  const prefix = base === 1024 ? ["Ki", "Mi", "Gi"] : ["k", "M", "G"];
+  let unit = -1;
+  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {
+    bytes /= base;
+    ++unit;
+  }
+  return `${bytes.toFixed(1)} ${prefix[unit]}B`;
+}
+
+function identity(value) {
+  return value;
+}
+
 function indexBy(...args) {
   return purry(indexBy_(false), args);
 }
@@ -614,7 +1036,7 @@ function intersectionWith(...args) {
 }
 function intersectionWith_(array, other, comparator) {
   const lazy = intersectionWith.lazy(other, comparator);
-  return reduceLazy(array, lazy);
+  return _reduceLazy(array, lazy);
 }
 ((intersectionWith2) => {
   function lazy(other, comparator) {
@@ -623,101 +1045,229 @@ function intersectionWith_(array, other, comparator) {
   intersectionWith2.lazy = lazy;
 })(intersectionWith || (intersectionWith = {}));
 
-function join(...args) {
-  return purry(joinImplementation, args);
+function invert(...args) {
+  return purry(invert_, args);
 }
-function joinImplementation(data, glue) {
-  return data.join(glue);
+function invert_(object) {
+  const result = {};
+  for (const key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+      result[object[key]] = key;
+    }
+  }
+  return result;
 }
 
-function last(...args) {
-  return purry(last_, args);
-}
-function last_(array) {
-  return array[array.length - 1];
+function isArray(data) {
+  return Array.isArray(data);
 }
 
-function length(...args) {
-  return purry(length_, args);
-}
-function length_(items) {
-  return "length" in items ? items.length : Array.from(items).length;
+function isBoolean(data) {
+  return typeof data === "boolean";
 }
 
-function map(...args) {
-  return purry(map_(false), args, map.lazy);
-}
-function map_(indexed) {
-  return (array, fn) => {
-    return reduceLazy(
-      array,
-      indexed ? map.lazyIndexed(fn) : map.lazy(fn),
-      indexed
-    );
-  };
+function isDate(data) {
+  return data instanceof Date;
 }
-function lazy_$2(indexed) {
-  return (fn) => (value, index, array) => ({
-    done: false,
-    hasNext: true,
-    next: indexed ? fn(value, index, array) : fn(value)
-  });
+
+function isDefined(data) {
+  return data !== void 0 && data !== null;
 }
-((map2) => {
-  function indexed(...args) {
-    return purry(map_(true), args, map2.lazyIndexed);
+((isDefined2) => {
+  function strict(data) {
+    return data !== void 0;
   }
-  map2.indexed = indexed;
-  map2.lazy = lazy_$2(false);
-  map2.lazyIndexed = toLazyIndexed(lazy_$2(true));
-  map2.strict = map2;
-})(map || (map = {}));
+  isDefined2.strict = strict;
+})(isDefined || (isDefined = {}));
 
-function mapToObj(...args) {
-  return purry(mapToObj_(false), args);
-}
-function mapToObj_(indexed) {
-  return (array, fn) => {
-    const out = {};
-    for (const [index, element] of array.entries()) {
-      const [key, value] = indexed ? fn(element, index, array) : fn(element);
-      out[key] = value;
-    }
-    return out;
-  };
+function isObject(data) {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(data);
+  return proto === null || proto === Object.prototype;
 }
-((mapToObj2) => {
-  function indexed(...args) {
-    return purry(mapToObj_(true), args);
+
+function isEmpty(data) {
+  if (data === void 0) {
+    return true;
   }
-  mapToObj2.indexed = indexed;
-})(mapToObj || (mapToObj = {}));
+  if (isArray(data) || isString(data)) {
+    return data.length === 0;
+  }
+  if (isObject(data)) {
+    return Object.keys(data).length === 0;
+  }
+  return false;
+}
 
-function maxBy_(indexed) {
-  return (array, fn) => {
-    let ret;
-    let retMax;
-    for (const [index, item] of array.entries()) {
-      const max = indexed ? fn(item, index, array) : fn(item);
-      if (retMax === void 0 || max > retMax) {
-        ret = item;
-        retMax = max;
-      }
-    }
-    return ret;
-  };
+function isError(data) {
+  return data instanceof Error;
 }
-function maxBy(...args) {
-  return purry(maxBy_(false), args);
+
+function isFunction(data) {
+  return typeof data === "function";
 }
-((maxBy2) => {
-  function indexed(...args) {
-    return purry(maxBy_(true), args);
+
+function isIncludedIn(dataOrContainer, container) {
+  if (container === void 0) {
+    const asSet = new Set(dataOrContainer);
+    return (data) => asSet.has(data);
   }
-  maxBy2.indexed = indexed;
-})(maxBy || (maxBy = {}));
+  return container.includes(dataOrContainer);
+}
 
-function meanBy_(indexed) {
+function isNonNull(data) {
+  return data !== null;
+}
+
+function isNot(predicate) {
+  return (data) => !predicate(data);
+}
+
+function isNullish(data) {
+  return data === null || data === void 0;
+}
+
+function isNumber(data) {
+  return typeof data === "number" && !Number.isNaN(data);
+}
+
+function isPromise(data) {
+  return data instanceof Promise;
+}
+
+function isSymbol(data) {
+  return typeof data === "symbol";
+}
+
+function isTruthy(data) {
+  return !!data;
+}
+
+function join(...args) {
+  return purry(joinImplementation, args);
+}
+function joinImplementation(data, glue) {
+  return data.join(glue);
+}
+
+const KEY_CODES = {
+  ALT: "Alt",
+  ARROW_DOWN: "ArrowDown",
+  ARROW_LEFT: "ArrowLeft",
+  ARROW_RIGHT: "ArrowRight",
+  ARROW_UP: "ArrowUp",
+  AT: "@",
+  BACKSPACE: "Backspace",
+  CTRL: "Control",
+  DELETE: "Delete",
+  END: "End",
+  ENTER: "Enter",
+  ESC: "Escape",
+  HOME: "Home",
+  KEY_F: "KEY_F",
+  META: "Meta",
+  PAGE_DOWN: "PageDown",
+  PAGE_UP: "PageUp",
+  SHIFT: "Shift",
+  SPACE: "Space",
+  TAB: "Tab"
+};
+
+function keys(...args) {
+  return purry(Object.keys, args);
+}
+((keys2) => {
+  keys2.strict = keys2;
+})(keys || (keys = {}));
+
+function last(...args) {
+  return purry(last_, args);
+}
+function last_(array) {
+  return array[array.length - 1];
+}
+
+function length(...args) {
+  return purry(length_, args);
+}
+function length_(items) {
+  return "length" in items ? items.length : Array.from(items).length;
+}
+
+function mapKeys(...args) {
+  return purry(mapKeys_, args);
+}
+function mapKeys_(data, fn) {
+  const out = {};
+  for (const [key, value] of entries.strict(data)) {
+    out[fn(key, value)] = value;
+  }
+  return out;
+}
+
+function mapToObj(...args) {
+  return purry(mapToObj_(false), args);
+}
+function mapToObj_(indexed) {
+  return (array, fn) => {
+    const out = {};
+    for (const [index, element] of array.entries()) {
+      const [key, value] = indexed ? fn(element, index, array) : fn(element);
+      out[key] = value;
+    }
+    return out;
+  };
+}
+((mapToObj2) => {
+  function indexed(...args) {
+    return purry(mapToObj_(true), args);
+  }
+  mapToObj2.indexed = indexed;
+})(mapToObj || (mapToObj = {}));
+
+function mapValues(...args) {
+  return purry(mapValues_, args);
+}
+function mapValues_(data, fn) {
+  const out = {};
+  for (const [key, value] of entries.strict(data)) {
+    out[key] = fn(value, key);
+  }
+  return out;
+}
+
+function map(...args) {
+  return purry(map_(false), args, map.lazy);
+}
+function map_(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? map.lazyIndexed(fn) : map.lazy(fn),
+      indexed
+    );
+  };
+}
+function lazy_$1(indexed) {
+  return (fn) => (value, index, array) => ({
+    done: false,
+    hasNext: true,
+    next: indexed ? fn(value, index, array) : fn(value)
+  });
+}
+((map2) => {
+  function indexed(...args) {
+    return purry(map_(true), args, map2.lazyIndexed);
+  }
+  map2.indexed = indexed;
+  map2.lazy = lazy_$1(false);
+  map2.lazyIndexed = _toLazyIndexed(lazy_$1(true));
+  map2.strict = map2;
+})(map || (map = {}));
+
+function meanBy_(indexed) {
   return (array, fn) => {
     if (array.length === 0) {
       return Number.NaN;
@@ -747,29 +1297,48 @@ function mergeAll(items) {
   return out;
 }
 
-function minBy_(indexed) {
-  return (array, fn) => {
-    let ret;
-    let retMin;
-    for (const [index, item] of array.entries()) {
-      const min = indexed ? fn(item, index, array) : fn(item);
-      if (retMin === void 0 || min < retMin) {
-        ret = item;
-        retMin = min;
-      }
+function mergeDeep(...args) {
+  return purry(mergeDeepImplementation, args);
+}
+function mergeDeepImplementation(destination, source) {
+  const output = { ...destination, ...source };
+  for (const key in source) {
+    if (!(key in destination)) {
+      continue;
     }
-    return ret;
-  };
+    const { [key]: destinationValue } = destination;
+    if (!isRecord(destinationValue)) {
+      continue;
+    }
+    const { [key]: sourceValue } = source;
+    if (!isRecord(sourceValue)) {
+      continue;
+    }
+    output[key] = mergeDeepImplementation(destinationValue, sourceValue);
+  }
+  return output;
 }
-function minBy(...args) {
-  return purry(minBy_(false), args);
+function isRecord(object) {
+  return typeof object === "object" && object !== null && Object.getPrototypeOf(object) === Object.prototype;
+}
+
+function merge(...args) {
+  return purry(merge_, args);
+}
+function merge_(data, source) {
+  return { ...data, ...source };
+}
+
+function multiply(...args) {
+  return purry(multiply_, args);
+}
+function multiply_(value, multiplicand) {
+  return value * multiplicand;
+}
+
+function noop() {
+  return void 0;
 }
-((minBy2) => {
-  function indexed(...args) {
-    return purry(minBy_(true), args);
-  }
-  minBy2.indexed = indexed;
-})(minBy || (minBy = {}));
 
 function quickSelect(data, index, compareFn) {
   return index < 0 || index >= data.length ? void 0 : quickSelectImplementation(
@@ -820,6 +1389,56 @@ function nthByImplementation(data, compareFn, index) {
   );
 }
 
+function omitBy(...args) {
+  return purry(omitBy_, args);
+}
+function omitBy_(object, fn) {
+  if (object === void 0 || object === null) {
+    return object;
+  }
+  const out = {};
+  for (const key of keys.strict(object)) {
+    const k = key;
+    if (!fn(object[k], k)) {
+      out[k] = object[k];
+    }
+  }
+  return out;
+}
+
+function omit(...args) {
+  return purry(omit_, args);
+}
+function omit_(data, propNames) {
+  if (!hasAtLeast(propNames, 1)) {
+    return { ...data };
+  }
+  if (!hasAtLeast(propNames, 2)) {
+    const [propName] = propNames;
+    const { [propName]: omitted, ...remaining } = data;
+    return remaining;
+  }
+  if (!propNames.some((propName) => propName in data)) {
+    return { ...data };
+  }
+  const asSet = new Set(propNames);
+  return fromEntries(
+    Object.entries(data).filter(([key]) => !asSet.has(key))
+  );
+}
+
+function once(fn) {
+  let called = false;
+  let ret;
+  return () => {
+    if (!called) {
+      ret = fn();
+      called = true;
+    }
+    return ret;
+  };
+}
+
 function only(...args) {
   return purry(only_, args);
 }
@@ -847,15 +1466,195 @@ function partition_(indexed) {
   partition2.indexed = indexed;
 })(partition || (partition = {}));
 
-function range(...args) {
-  return purry(range_, args);
+function pathOr(...args) {
+  return purry(pathOr_, args);
 }
-function range_(start, end) {
-  const ret = [];
-  for (let i = start; i < end; i++) {
-    ret.push(i);
+function pathOr_(data, path, defaultValue) {
+  let current = data;
+  for (const prop of path) {
+    if (current === null || current === void 0) {
+      break;
+    }
+    current = current[prop];
   }
-  return ret;
+  return current ?? defaultValue;
+}
+
+function pickBy(...args) {
+  return purry(pickBy_, args);
+}
+function pickBy_(data, fn) {
+  if (data === null || data === void 0) {
+    return {};
+  }
+  const out = {};
+  for (const key of keys.strict(data)) {
+    const k = key;
+    if (fn(data[k], k)) {
+      out[k] = data[k];
+    }
+  }
+  return out;
+}
+
+function pick(...args) {
+  return purry(pick_, args);
+}
+function pick_(object, names) {
+  const out = {};
+  for (const name of names) {
+    if (name in object) {
+      out[name] = object[name];
+    }
+  }
+  return out;
+}
+
+function pipe(input, ...operations) {
+  let output = input;
+  const lazyOperations = operations.map((op) => "lazy" in op ? prepareLazyOperation(op) : void 0);
+  let operationIndex = 0;
+  while (operationIndex < operations.length) {
+    const lazyOperation = lazyOperations[operationIndex];
+    if (lazyOperation === void 0 || !isIterable(output)) {
+      const operation = operations[operationIndex];
+      output = operation(output);
+      operationIndex += 1;
+      continue;
+    }
+    const lazySequence = [];
+    for (let index = operationIndex; index < operations.length; index++) {
+      const lazyOp = lazyOperations[index];
+      if (lazyOp === void 0) {
+        break;
+      }
+      lazySequence.push(lazyOp);
+      if (lazyOp.isSingle) {
+        break;
+      }
+    }
+    const accumulator = [];
+    const iterator = output[Symbol.iterator]();
+    while (true) {
+      const result = iterator.next();
+      if (result.done ?? false) {
+        break;
+      }
+      const shouldExitEarly = processItem_(
+        result.value,
+        accumulator,
+        lazySequence
+      );
+      if (shouldExitEarly) {
+        break;
+      }
+    }
+    const { isSingle } = lazySequence[lazySequence.length - 1];
+    output = isSingle ? accumulator[0] : accumulator;
+    operationIndex += lazySequence.length;
+  }
+  return output;
+}
+function processItem_(item, accumulator, lazySequence) {
+  if (lazySequence.length === 0) {
+    accumulator.push(item);
+    return false;
+  }
+  let currentItem = item;
+  let lazyResult = { done: false, hasNext: false };
+  let isDone = false;
+  for (const [operationsIndex, lazyFn] of lazySequence.entries()) {
+    const { index, isIndexed, items } = lazyFn;
+    items.push(currentItem);
+    lazyResult = isIndexed ? lazyFn(currentItem, index, items) : lazyFn(currentItem);
+    lazyFn.index += 1;
+    if (lazyResult.hasNext) {
+      if (lazyResult.hasMany ?? false) {
+        for (const subItem of lazyResult.next) {
+          const subResult = processItem_(
+            subItem,
+            accumulator,
+            lazySequence.slice(operationsIndex + 1)
+          );
+          if (subResult) {
+            return true;
+          }
+        }
+        return false;
+      }
+      currentItem = lazyResult.next;
+    }
+    if (!lazyResult.hasNext) {
+      break;
+    }
+    if (lazyResult.done) {
+      isDone = true;
+    }
+  }
+  if (lazyResult.hasNext) {
+    accumulator.push(currentItem);
+  }
+  return isDone;
+}
+function prepareLazyOperation(op) {
+  const { lazy, lazyArgs } = op;
+  const fn = lazy(...lazyArgs ?? []);
+  return Object.assign(fn, {
+    index: 0,
+    isIndexed: lazy.indexed,
+    isSingle: lazy.single,
+    items: []
+  });
+}
+function isIterable(something) {
+  return typeof something === "string" || typeof something === "object" && something !== null && Symbol.iterator in something;
+}
+
+function piped(...operations) {
+  return (value) => pipe(
+    value,
+    ...operations
+  );
+}
+
+function prop(propName) {
+  return ({ [propName]: value }) => value;
+}
+
+function times(...args) {
+  return purry(times_, args);
+}
+function times_(count, fn) {
+  if (count < 0) {
+    throw new RangeError("n must be a non-negative number");
+  }
+  const res = [];
+  for (let i = 0; i < count; i++) {
+    res.push(fn(i));
+  }
+  return res;
+}
+
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function randomString(...args) {
+  return purry(randomStringImplementation, args);
+}
+function randomStringImplementation(length) {
+  return times(length, randomChar).join("");
+}
+function randomChar() {
+  return ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
+}
+
+function range(...args) {
+  return purry(range_, args);
+}
+function range_(start, end) {
+  const ret = [];
+  for (let i = start; i < end; i++) {
+    ret.push(i);
+  }
+  return ret;
 }
 
 function rankBy(...args) {
@@ -889,30 +1688,6 @@ function reduce_(indexed) {
   reduce2.indexed = indexed;
 })(reduce || (reduce = {}));
 
-function reject(...args) {
-  return purry(reject_(false), args, reject.lazy);
-}
-function reject_(indexed) {
-  return (array, fn) => {
-    return reduceLazy(
-      array,
-      indexed ? reject.lazyIndexed(fn) : reject.lazy(fn),
-      indexed
-    );
-  };
-}
-function lazy_$1(indexed) {
-  return (fn) => (item, index, data) => (indexed ? fn(item, index, data) : fn(item)) ? { done: false, hasNext: false } : { done: false, hasNext: true, next: item };
-}
-((reject2) => {
-  function indexed(...args) {
-    return purry(reject_(true), args, reject2.lazyIndexed);
-  }
-  reject2.indexed = indexed;
-  reject2.lazy = lazy_$1(false);
-  reject2.lazyIndexed = toLazyIndexed(lazy_$1(true));
-})(reject || (reject = {}));
-
 function reverse(...args) {
   return purry(reverse_, args);
 }
@@ -920,6 +1695,10 @@ function reverse_(array) {
   return array.slice().reverse();
 }
 
+function round(...args) {
+  return purry(_withPrecision(Math.round), args);
+}
+
 function sample(...args) {
   return purry(sampleImplementation, args);
 }
@@ -948,6 +1727,40 @@ function sampleImplementation(data, sampleSize) {
   return data.filter((_, index) => !sampleIndices.has(index));
 }
 
+function setPath(...args) {
+  return purry(setPath_, args);
+}
+function setPath_(data, path, value) {
+  const [current, ...rest] = path;
+  if (current === void 0) {
+    return value;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item, index) => index === current ? setPath_(item, rest, value) : item);
+  }
+  if (data === null || data === void 0) {
+    throw new Error("Path doesn't exist in object!");
+  }
+  return {
+    ...data,
+    [current]: setPath_(
+      data[current],
+      rest,
+      value
+    )
+  };
+}
+
+function set(...args) {
+  return purry(set_, args);
+}
+function set_(obj, prop, value) {
+  return {
+    ...obj,
+    [prop]: value
+  };
+}
+
 function shuffle(...args) {
   return purry(shuffle_, args);
 }
@@ -962,17 +1775,15 @@ function shuffle_(items) {
   return result;
 }
 
-function sort(...args) {
-  return purry(sort_, args);
+function sleep(timeout) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+  });
 }
-function sort_(items, cmp) {
-  const ret = items.slice();
-  ret.sort(cmp);
-  return ret;
+
+function slugify(str) {
+  return str.normalize("NFD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z0-9]/g, " ").trim().replace(/\s+/g, "-");
 }
-((sort2) => {
-  sort2.strict = sort2;
-})(sort || (sort = {}));
 
 function sortBy(...args) {
   return purryOrderRules(_sortBy, args);
@@ -984,7 +1795,19 @@ function _sortBy(data, compareFn) {
   sortBy2.strict = sortBy2;
 })(sortBy || (sortBy = {}));
 
-function binarySearchCutoffIndex(array, predicate) {
+function sort(...args) {
+  return purry(sort_, args);
+}
+function sort_(items, cmp) {
+  const ret = items.slice();
+  ret.sort(cmp);
+  return ret;
+}
+((sort2) => {
+  sort2.strict = sort2;
+})(sort || (sort = {}));
+
+function _binarySearchCutoffIndex(array, predicate) {
   let lowIndex = 0;
   let highIndex = array.length;
   while (lowIndex < highIndex) {
@@ -999,37 +1822,57 @@ function binarySearchCutoffIndex(array, predicate) {
   return highIndex;
 }
 
-function sortedIndex(...args) {
-  return purry(sortedIndexImplementation, args);
+function sortedIndexBy(...args) {
+  return purry(sortedIndexByImplementation, args);
 }
-function sortedIndexImplementation(array, item) {
-  return binarySearchCutoffIndex(array, (pivot) => pivot < item);
+((sortedIndexBy2) => {
+  function indexed(...args) {
+    return purry(sortedIndexByImplementation, args);
+  }
+  sortedIndexBy2.indexed = indexed;
+})(sortedIndexBy || (sortedIndexBy = {}));
+function sortedIndexByImplementation(array, item, valueFunction) {
+  const value = valueFunction(item);
+  return _binarySearchCutoffIndex(
+    array,
+    (pivot, index) => valueFunction(pivot, index) < value
+  );
 }
 
 function sortedIndexWith(...args) {
-  return purry(binarySearchCutoffIndex, args);
+  return purry(_binarySearchCutoffIndex, args);
 }
 ((sortedIndexWith2) => {
   function indexed(...args) {
-    return purry(binarySearchCutoffIndex, args);
+    return purry(_binarySearchCutoffIndex, args);
   }
   sortedIndexWith2.indexed = indexed;
 })(sortedIndexWith || (sortedIndexWith = {}));
 
-function sortedIndexBy(...args) {
-  return purry(sortedIndexByImplementation, args);
+function sortedIndex(...args) {
+  return purry(sortedIndexImplementation, args);
 }
-((sortedIndexBy2) => {
+function sortedIndexImplementation(array, item) {
+  return _binarySearchCutoffIndex(array, (pivot) => pivot < item);
+}
+
+function sortedLastIndexBy(...args) {
+  return purry(sortedLastIndexByImplementation, args);
+}
+((sortedLastIndexBy2) => {
   function indexed(...args) {
-    return purry(sortedIndexByImplementation, args);
+    return purry(sortedLastIndexByImplementation, args);
   }
-  sortedIndexBy2.indexed = indexed;
-})(sortedIndexBy || (sortedIndexBy = {}));
-function sortedIndexByImplementation(array, item, valueFunction) {
+  sortedLastIndexBy2.indexed = indexed;
+})(sortedLastIndexBy || (sortedLastIndexBy = {}));
+function sortedLastIndexByImplementation(array, item, valueFunction) {
   const value = valueFunction(item);
-  return binarySearchCutoffIndex(
+  return _binarySearchCutoffIndex(
     array,
-    (pivot, index) => valueFunction(pivot, index) < value
+    // The only difference between the regular implementation and the "last"
+    // variation is that we consider the pivot with equality too, so that we
+    // skip all equal values in addition to the lower ones.
+    (pivot, index) => valueFunction(pivot, index) <= value
   );
 }
 
@@ -1037,7 +1880,7 @@ function sortedLastIndex(...args) {
   return purry(sortedLastIndexImplementation, args);
 }
 function sortedLastIndexImplementation(array, item) {
-  return binarySearchCutoffIndex(
+  return _binarySearchCutoffIndex(
     array,
     // The only difference between the regular implementation and the "last"
     // variation is that we consider the pivot with equality too, so that we
@@ -1076,6 +1919,28 @@ function splitWhen_(array, fn) {
   return [array.slice(), []];
 }
 
+function stringToPath(path) {
+  return stringToPath_(path);
+}
+function stringToPath_(path) {
+  if (path.length === 0) {
+    return [];
+  }
+  const match = /^\[(.+?)\](.*)$/u.exec(path) ?? /^\.?([^.[\]]+)(.*)$/u.exec(path);
+  if (match !== null) {
+    const [, key, rest] = match;
+    return [key, ...stringToPath_(rest)];
+  }
+  return [path];
+}
+
+function subtract(...args) {
+  return purry(subtract_, args);
+}
+function subtract_(value, subtrahend) {
+  return value - subtrahend;
+}
+
 function sumBy_(indexed) {
   return (array, fn) => {
     let sum = 0;
@@ -1124,25 +1989,17 @@ function swapString_(item, index1, index2) {
   return result.join("");
 }
 
-function take(...args) {
-  return purry(take_, args, take.lazy);
+function swapProps(...args) {
+  return purry(swapProps_, args);
 }
-function take_(array, n) {
-  return reduceLazy(array, take.lazy(n));
+function swapProps_(obj, key1, key2) {
+  const { [key1]: value1, [key2]: value2 } = obj;
+  return {
+    ...obj,
+    [key1]: value2,
+    [key2]: value1
+  };
 }
-((take2) => {
-  function lazy(n) {
-    if (n <= 0) {
-      return () => ({ done: true, hasNext: false });
-    }
-    let remaining = n;
-    return (value) => {
-      remaining -= 1;
-      return { done: remaining <= 0, hasNext: true, next: value };
-    };
-  }
-  take2.lazy = lazy;
-})(take || (take = {}));
 
 function takeFirstBy(...args) {
   return purryOrderRulesWithArgument(takeFirstByImplementation, args);
@@ -1177,83 +2034,80 @@ function takeWhile_(array, fn) {
   return ret;
 }
 
-function uniq(...args) {
-  return purry(uniq_, args, uniq.lazy);
+function take(...args) {
+  return purry(take_, args, take.lazy);
 }
-function uniq_(array) {
-  return reduceLazy(array, uniq.lazy());
+function take_(array, n) {
+  return _reduceLazy(array, take.lazy(n));
 }
-((uniq2) => {
-  function lazy() {
-    const set = /* @__PURE__ */ new Set();
+((take2) => {
+  function lazy(n) {
+    if (n <= 0) {
+      return () => ({ done: true, hasNext: false });
+    }
+    let remaining = n;
     return (value) => {
-      if (set.has(value)) {
-        return { done: false, hasNext: false };
-      }
-      set.add(value);
-      return { done: false, hasNext: true, next: value };
+      remaining -= 1;
+      return { done: remaining <= 0, hasNext: true, next: value };
     };
   }
-  uniq2.lazy = lazy;
-})(uniq || (uniq = {}));
+  take2.lazy = lazy;
+})(take || (take = {}));
 
-function uniqBy(...args) {
-  return purry(uniqBy_, args, lazyUniqBy);
+function uniqueBy(...args) {
+  return purry(uniqueByImplementation, args, lazyUniqueBy);
 }
-function uniqBy_(array, transformer) {
-  return reduceLazy(array, lazyUniqBy(transformer));
+function uniqueByImplementation(data, keyFunction) {
+  return _reduceLazy(data, lazyUniqueBy(keyFunction));
 }
-function lazyUniqBy(transformer) {
+function lazyUniqueBy(keyFunction) {
   const set = /* @__PURE__ */ new Set();
   return (value) => {
-    const appliedItem = transformer(value);
-    if (set.has(appliedItem)) {
+    const key = keyFunction(value);
+    if (set.has(key)) {
       return { done: false, hasNext: false };
     }
-    set.add(appliedItem);
+    set.add(key);
     return { done: false, hasNext: true, next: value };
   };
 }
 
-function uniqWith(...args) {
-  return purry(uniqWith_, args, uniqWith.lazy);
+function uniqueWith(...args) {
+  return purry(uniqueWithImplementation, args, uniqueWith.lazy);
 }
-function uniqWith_(array, isEquals) {
-  const lazy = uniqWith.lazy(isEquals);
-  return reduceLazy(array, lazy, true);
+function uniqueWithImplementation(array, isEquals) {
+  const lazy = uniqueWith.lazy(isEquals);
+  return _reduceLazy(array, lazy, true);
 }
 function lazy_(isEquals) {
   return (value, index, array) => array !== void 0 && array.findIndex((otherValue) => isEquals(value, otherValue)) === index ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
 }
-((uniqWith2) => {
-  uniqWith2.lazy = toLazyIndexed(lazy_);
-})(uniqWith || (uniqWith = {}));
+((uniqueWith2) => {
+  uniqueWith2.lazy = _toLazyIndexed(lazy_);
+})(uniqueWith || (uniqueWith = {}));
 
-function zip(...args) {
-  return purry(zip_, args);
-}
-function zip_(first, second) {
-  const resultLength = first.length > second.length ? second.length : first.length;
-  const result = [];
-  for (let i = 0; i < resultLength; i++) {
-    result.push([first[i], second[i]]);
-  }
-  return result;
+function unique(...args) {
+  return purry(uniqueImplementation, args, unique.lazy);
 }
-((zip2) => {
-  zip2.strict = zip2;
-})(zip || (zip = {}));
-
-function zipObj(...args) {
-  return purry(zipObj_, args);
+function uniqueImplementation(array) {
+  return _reduceLazy(array, unique.lazy());
 }
-function zipObj_(first, second) {
-  const resultLength = first.length > second.length ? second.length : first.length;
-  const result = {};
-  for (let i = 0; i < resultLength; i++) {
-    result[first[i]] = second[i];
+((unique2) => {
+  function lazy() {
+    const set = /* @__PURE__ */ new Set();
+    return (value) => {
+      if (set.has(value)) {
+        return { done: false, hasNext: false };
+      }
+      set.add(value);
+      return { done: false, hasNext: true, next: value };
+    };
   }
-  return result;
+  unique2.lazy = lazy;
+})(unique || (unique = {}));
+
+function values(source) {
+  return Object.values(source);
 }
 
 function zipWith(arg0, arg1, arg2) {
@@ -1274,959 +2128,20 @@ function zipWith_(first, second, fn) {
   return result;
 }
 
-function purryOn(isArg, implementation, args) {
-  const callArgs = Array.from(args);
-  return isArg(args[0]) ? (data) => implementation(data, ...callArgs) : implementation(...callArgs);
-}
-
-function conditional(...args) {
-  return purryOn(isCase, conditionalImplementation, args);
-}
-function conditionalImplementation(data, ...cases) {
-  for (const [when, then] of cases) {
-    if (when(data)) {
-      return then(data);
-    }
-  }
-  throw new Error("conditional: data failed for all cases");
-}
-function isCase(maybeCase) {
-  if (!Array.isArray(maybeCase)) {
-    return false;
-  }
-  const [when, then, ...rest] = maybeCase;
-  return typeof when === "function" && when.length <= 1 && typeof then === "function" && then.length <= 1 && rest.length === 0;
-}
-const trivialDefaultCase = () => void 0;
-((conditional2) => {
-  function defaultCase(then = trivialDefaultCase) {
-    return [() => true, then];
-  }
-  conditional2.defaultCase = defaultCase;
-})(conditional || (conditional = {}));
-
-function pipe(input, ...operations) {
-  let output = input;
-  const lazyOperations = operations.map((op) => "lazy" in op ? prepareLazyOperation(op) : void 0);
-  let operationIndex = 0;
-  while (operationIndex < operations.length) {
-    const lazyOperation = lazyOperations[operationIndex];
-    if (lazyOperation === void 0 || !isIterable(output)) {
-      const operation = operations[operationIndex];
-      output = operation(output);
-      operationIndex += 1;
-      continue;
-    }
-    const lazySequence = [];
-    for (let index = operationIndex; index < operations.length; index++) {
-      const lazyOp = lazyOperations[index];
-      if (lazyOp === void 0) {
-        break;
-      }
-      lazySequence.push(lazyOp);
-      if (lazyOp.isSingle) {
-        break;
-      }
-    }
-    const accumulator = [];
-    const iterator = output[Symbol.iterator]();
-    while (true) {
-      const result = iterator.next();
-      if (result.done ?? false) {
-        break;
-      }
-      const shouldExitEarly = processItem_(
-        result.value,
-        accumulator,
-        lazySequence
-      );
-      if (shouldExitEarly) {
-        break;
-      }
-    }
-    const { isSingle } = lazySequence[lazySequence.length - 1];
-    output = isSingle ? accumulator[0] : accumulator;
-    operationIndex += lazySequence.length;
-  }
-  return output;
+function zip(...args) {
+  return purry(zip_, args);
 }
-function processItem_(item, accumulator, lazySequence) {
-  if (lazySequence.length === 0) {
-    accumulator.push(item);
-    return false;
-  }
-  let currentItem = item;
-  let lazyResult = { done: false, hasNext: false };
-  let isDone = false;
-  for (const [operationsIndex, lazyFn] of lazySequence.entries()) {
-    const { index, isIndexed, items } = lazyFn;
-    items.push(currentItem);
-    lazyResult = isIndexed ? lazyFn(currentItem, index, items) : lazyFn(currentItem);
-    lazyFn.index += 1;
-    if (lazyResult.hasNext) {
-      if (lazyResult.hasMany ?? false) {
-        for (const subItem of lazyResult.next) {
-          const subResult = processItem_(
-            subItem,
-            accumulator,
-            lazySequence.slice(operationsIndex + 1)
-          );
-          if (subResult) {
-            return true;
-          }
-        }
-        return false;
-      }
-      currentItem = lazyResult.next;
-    }
-    if (!lazyResult.hasNext) {
-      break;
-    }
-    if (lazyResult.done) {
-      isDone = true;
-    }
-  }
-  if (lazyResult.hasNext) {
-    accumulator.push(currentItem);
+function zip_(first, second) {
+  const resultLength = first.length > second.length ? second.length : first.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push([first[i], second[i]]);
   }
-  return isDone;
-}
-function prepareLazyOperation(op) {
-  const { lazy, lazyArgs } = op;
-  const fn = lazy(...lazyArgs ?? []);
-  return Object.assign(fn, {
-    index: 0,
-    isIndexed: lazy.indexed,
-    isSingle: lazy.single,
-    items: []
-  });
-}
-function isIterable(something) {
-  return typeof something === "string" || typeof something === "object" && something !== null && Symbol.iterator in something;
-}
-
-function createPipe(...operations) {
-  return (value) => pipe(
-    value,
-    ...operations
-  );
-}
-
-function identity(value) {
-  return value;
-}
-
-function noop() {
-  return void 0;
-}
-
-function once(fn) {
-  let called = false;
-  let ret;
-  return () => {
-    if (!called) {
-      ret = fn();
-      called = true;
-    }
-    return ret;
-  };
-}
-
-function debounce(func, {
-  maxWaitMs,
-  timing = "trailing",
-  waitMs
-}) {
-  if (maxWaitMs !== void 0 && waitMs !== void 0 && maxWaitMs < waitMs) {
-    throw new Error(
-      `debounce: maxWaitMs (${maxWaitMs}) cannot be less than waitMs (${waitMs})`
-    );
-  }
-  let coolDownTimeoutId;
-  let maxWaitTimeoutId;
-  let latestCallArgs;
-  let result;
-  function handleDebouncedCall(args) {
-    latestCallArgs = args;
-    if (maxWaitMs !== void 0 && maxWaitTimeoutId === void 0) {
-      maxWaitTimeoutId = setTimeout(handleInvoke, maxWaitMs);
-    }
-  }
-  function handleInvoke() {
-    if (latestCallArgs === void 0) {
-      return;
-    }
-    if (maxWaitTimeoutId !== void 0) {
-      const timeoutId = maxWaitTimeoutId;
-      maxWaitTimeoutId = void 0;
-      clearTimeout(timeoutId);
-    }
-    const args = latestCallArgs;
-    latestCallArgs = void 0;
-    result = func(...args);
-  }
-  function handleCoolDownEnd() {
-    if (coolDownTimeoutId === void 0) {
-      return;
-    }
-    const timeoutId = coolDownTimeoutId;
-    coolDownTimeoutId = void 0;
-    clearTimeout(timeoutId);
-    if (latestCallArgs !== void 0) {
-      handleInvoke();
-    }
-  }
-  return {
-    get cachedValue() {
-      return result;
-    },
-    call: (...args) => {
-      if (coolDownTimeoutId === void 0) {
-        if (timing === "trailing") {
-          handleDebouncedCall(args);
-        } else {
-          result = func(...args);
-        }
-      } else {
-        if (timing !== "leading") {
-          handleDebouncedCall(args);
-        }
-        const timeoutId = coolDownTimeoutId;
-        coolDownTimeoutId = void 0;
-        clearTimeout(timeoutId);
-      }
-      coolDownTimeoutId = setTimeout(
-        handleCoolDownEnd,
-        // If waitMs is not defined but maxWaitMs *is* it means the user is only
-        // interested in the leaky-bucket nature of the debouncer which is
-        // achieved by setting waitMs === maxWaitMs. If both are not defined we
-        // default to 0 which would wait until the end of the execution frame.
-        waitMs ?? maxWaitMs ?? 0
-      );
-      return result;
-    },
-    cancel: () => {
-      if (coolDownTimeoutId !== void 0) {
-        const timeoutId = coolDownTimeoutId;
-        coolDownTimeoutId = void 0;
-        clearTimeout(timeoutId);
-      }
-      if (maxWaitTimeoutId !== void 0) {
-        const timeoutId = maxWaitTimeoutId;
-        maxWaitTimeoutId = void 0;
-        clearTimeout(timeoutId);
-      }
-      latestCallArgs = void 0;
-    },
-    flush: () => {
-      handleCoolDownEnd();
-      return result;
-    },
-    get isPending() {
-      return coolDownTimeoutId !== void 0;
-    }
-  };
-}
-
-function sleep(timeout) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeout);
-  });
-}
-
-function times(...args) {
-  return purry(times_, args);
-}
-function times_(count, fn) {
-  if (count < 0) {
-    throw new RangeError("n must be a non-negative number");
-  }
-  const res = [];
-  for (let i = 0; i < count; i++) {
-    res.push(fn(i));
-  }
-  return res;
-}
-
-function isDeepEqual(...args) {
-  return purry(isDeepEqualImplementation, args);
-}
-function isDeepEqualImplementation(data, other) {
-  if (data === other) {
-    return true;
-  }
-  if (typeof data === "number" && typeof other === "number") {
-    return data !== data && other !== other;
-  }
-  if (typeof data !== "object" || typeof other !== "object") {
-    return false;
-  }
-  if (data === null || other === null) {
-    return false;
-  }
-  if (Object.getPrototypeOf(data) !== Object.getPrototypeOf(other)) {
-    return false;
-  }
-  if (Array.isArray(data)) {
-    if (data.length !== other.length) {
-      return false;
-    }
-    for (let i = 0; i < data.length; i++) {
-      if (!isDeepEqualImplementation(
-        data[i],
-        other[i]
-      )) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (data instanceof Date) {
-    return data.getTime() === other.getTime();
-  }
-  if (data instanceof RegExp) {
-    return data.toString() === other.toString();
-  }
-  const keys = Object.keys(data);
-  if (keys.length !== Object.keys(other).length) {
-    return false;
-  }
-  for (const key of keys) {
-    if (!Object.prototype.hasOwnProperty.call(other, key)) {
-      return false;
-    }
-    if (!isDeepEqualImplementation(data[key], other[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function hasSubObject(...args) {
-  return purry(_hasSubObject, args);
-}
-function _hasSubObject(data, subObject) {
-  for (const key of Object.keys(subObject)) {
-    if (!Object.prototype.hasOwnProperty.call(data, key)) {
-      return false;
-    }
-    if (!isDeepEqual(subObject[key], data[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function isArray(data) {
-  return Array.isArray(data);
-}
-
-function isBoolean(data) {
-  return typeof data === "boolean";
-}
-
-function isDate(data) {
-  return data instanceof Date;
-}
-
-function isDefined(data) {
-  return data !== void 0 && data !== null;
-}
-((isDefined2) => {
-  function strict(data) {
-    return data !== void 0;
-  }
-  isDefined2.strict = strict;
-})(isDefined || (isDefined = {}));
-
-function isObject(data) {
-  if (typeof data !== "object" || data === null) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(data);
-  return proto === null || proto === Object.prototype;
-}
-
-function isString(data) {
-  return typeof data === "string";
-}
-
-function isEmpty(data) {
-  if (data === void 0) {
-    return true;
-  }
-  if (isArray(data) || isString(data)) {
-    return data.length === 0;
-  }
-  if (isObject(data)) {
-    return Object.keys(data).length === 0;
-  }
-  return false;
-}
-
-function isError(data) {
-  return data instanceof Error;
-}
-
-function isFunction(data) {
-  return typeof data === "function";
-}
-
-function isIncludedIn(dataOrContainer, container) {
-  if (container === void 0) {
-    const asSet = new Set(dataOrContainer);
-    return (data) => asSet.has(data);
-  }
-  return container.includes(dataOrContainer);
-}
-
-function isNil(data) {
-  return data === null || data === void 0;
-}
-
-function isNonNull(data) {
-  return data !== null;
-}
-
-function isNot(predicate) {
-  return (data) => !predicate(data);
-}
-
-function isNumber(data) {
-  return typeof data === "number" && !Number.isNaN(data);
-}
-
-function isPromise(data) {
-  return data instanceof Promise;
-}
-
-function isSymbol(data) {
-  return typeof data === "symbol";
-}
-
-function isTruthy(data) {
-  return !!data;
-}
-
-function add(...args) {
-  return purry(add_, args);
-}
-function add_(value, addend) {
-  return value + addend;
-}
-
-const MAX_PRECISION = 15;
-function withPrecision(roundingFn) {
-  return (value, precision) => {
-    if (precision === 0) {
-      return roundingFn(value);
-    }
-    if (!Number.isInteger(precision)) {
-      throw new TypeError(`precision must be an integer: ${precision}`);
-    }
-    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {
-      throw new RangeError(`precision must be between ${-MAX_PRECISION} and ${MAX_PRECISION}`);
-    }
-    if (Number.isNaN(value) || !Number.isFinite(value)) {
-      return roundingFn(value);
-    }
-    const multiplier = 10 ** precision;
-    return roundingFn(value * multiplier) / multiplier;
-  };
-}
-
-function ceil(...args) {
-  return purry(withPrecision(Math.ceil), args);
-}
-
-function clamp(...args) {
-  return purry(clamp_, args);
-}
-function clamp_(value, { max, min }) {
-  if (min !== void 0 && value < min) {
-    return min;
-  }
-  if (max !== void 0 && value > max) {
-    return max;
-  }
-  return value;
-}
-
-function divide(...args) {
-  return purry(divide_, args);
-}
-function divide_(value, divisor) {
-  return value / divisor;
-}
-
-function floor(...args) {
-  return purry(withPrecision(Math.floor), args);
-}
-
-function multiply(...args) {
-  return purry(multiply_, args);
-}
-function multiply_(value, multiplicand) {
-  return value * multiplicand;
-}
-
-function round(...args) {
-  return purry(withPrecision(Math.round), args);
-}
-
-function subtract(...args) {
-  return purry(subtract_, args);
-}
-function subtract_(value, subtrahend) {
-  return value - subtrahend;
-}
-
-function addProp(...args) {
-  return purry(addProp_, args);
-}
-function addProp_(obj, prop, value) {
-  return {
-    ...obj,
-    [prop]: value
-  };
-}
-
-function type(val) {
-  if (val === null) {
-    return "Null";
-  }
-  if (val === void 0) {
-    return "Undefined";
-  }
-  return Object.prototype.toString.call(val).slice(8, -1);
-}
-
-function cloneRegExp_(pattern) {
-  return new RegExp(
-    pattern.source,
-    (pattern.global ? "g" : "") + (pattern.ignoreCase ? "i" : "") + (pattern.multiline ? "m" : "") + (pattern.sticky ? "y" : "") + (pattern.unicode ? "u" : "")
-  );
-}
-function clone_(value, refFrom, refTo, deep) {
-  function copy(copiedValue) {
-    const len = refFrom.length;
-    let idx = 0;
-    while (idx < len) {
-      if (value === refFrom[idx]) {
-        return refTo[idx];
-      }
-      idx += 1;
-    }
-    refFrom[idx + 1] = value;
-    refTo[idx + 1] = copiedValue;
-    for (const key in value) {
-      copiedValue[key] = deep ? clone_(value[key], refFrom, refTo, true) : value[key];
-    }
-    return copiedValue;
-  }
-  switch (type(value)) {
-    case "Object":
-      return copy({});
-    case "Array":
-      return copy([]);
-    case "Date":
-      return new Date(value.valueOf());
-    case "RegExp":
-      return cloneRegExp_(value);
-    default:
-      return value;
-  }
-}
-function clone(value) {
-  return value != null && typeof value.clone === "function" ? value.clone() : clone_(value, [], [], true);
-}
-
-function forEachObj(...args) {
-  return purry(forEachObj_(false), args);
-}
-function forEachObj_(indexed) {
-  return (data, fn) => {
-    for (const key in data) {
-      if (Object.prototype.hasOwnProperty.call(data, key)) {
-        const { [key]: val } = data;
-        if (indexed) {
-          fn(val, key, data);
-        } else {
-          fn(val);
-        }
-      }
-    }
-    return data;
-  };
-}
-((forEachObj2) => {
-  function indexed(...args) {
-    return purry(forEachObj_(true), args);
-  }
-  forEachObj2.indexed = indexed;
-})(forEachObj || (forEachObj = {}));
-
-function fromKeys(...args) {
-  return purry(fromKeysImplementation, args);
-}
-function fromKeysImplementation(data, mapper) {
-  const result = {};
-  for (const key of data) {
-    result[key] = mapper(key);
-  }
-  return result;
-}
-
-function fromPairs(...args) {
-  return purry(fromPairsImplementation, args);
-}
-function fromPairsImplementation(entries) {
-  const out = {};
-  for (const [key, value] of entries) {
-    out[key] = value;
-  }
-  return out;
-}
-((fromPairs2) => {
-  fromPairs2.strict = fromPairs2;
-})(fromPairs || (fromPairs = {}));
-
-function invert(...args) {
-  return purry(invert_, args);
-}
-function invert_(object) {
-  const result = {};
-  for (const key in object) {
-    if (Object.prototype.hasOwnProperty.call(object, key)) {
-      result[object[key]] = key;
-    }
-  }
-  return result;
-}
-
-function keys(...args) {
-  return purry(Object.keys, args);
-}
-((keys2) => {
-  keys2.strict = keys2;
-})(keys || (keys = {}));
-
-function toPairs(...args) {
-  return purry(Object.entries, args);
-}
-((toPairs2) => {
-  toPairs2.strict = toPairs2;
-})(toPairs || (toPairs = {}));
-
-function mapKeys(...args) {
-  return purry(mapKeys_, args);
-}
-function mapKeys_(data, fn) {
-  const out = {};
-  for (const [key, value] of toPairs.strict(data)) {
-    out[fn(key, value)] = value;
-  }
-  return out;
-}
-
-function mapValues(...args) {
-  return purry(mapValues_, args);
-}
-function mapValues_(data, fn) {
-  const out = {};
-  for (const [key, value] of toPairs.strict(data)) {
-    out[key] = fn(value, key);
-  }
-  return out;
-}
-
-function merge(...args) {
-  return purry(merge_, args);
-}
-function merge_(data, source) {
-  return { ...data, ...source };
-}
-
-function mergeDeep(...args) {
-  return purry(mergeDeepImplementation, args);
-}
-function mergeDeepImplementation(destination, source) {
-  const output = { ...destination, ...source };
-  for (const key in source) {
-    if (!(key in destination)) {
-      continue;
-    }
-    const { [key]: destinationValue } = destination;
-    if (!isRecord(destinationValue)) {
-      continue;
-    }
-    const { [key]: sourceValue } = source;
-    if (!isRecord(sourceValue)) {
-      continue;
-    }
-    output[key] = mergeDeepImplementation(destinationValue, sourceValue);
-  }
-  return output;
-}
-function isRecord(object) {
-  return typeof object === "object" && object !== null && Object.getPrototypeOf(object) === Object.prototype;
-}
-
-function omit(...args) {
-  return purry(omit_, args);
-}
-function omit_(data, propNames) {
-  if (!hasAtLeast(propNames, 1)) {
-    return { ...data };
-  }
-  if (!hasAtLeast(propNames, 2)) {
-    const [propName] = propNames;
-    const { [propName]: omitted, ...remaining } = data;
-    return remaining;
-  }
-  if (!propNames.some((propName) => propName in data)) {
-    return { ...data };
-  }
-  const asSet = new Set(propNames);
-  return fromPairs(
-    Object.entries(data).filter(([key]) => !asSet.has(key))
-  );
-}
-
-function omitBy(...args) {
-  return purry(omitBy_, args);
-}
-function omitBy_(object, fn) {
-  if (object === void 0 || object === null) {
-    return object;
-  }
-  const out = {};
-  for (const key of keys.strict(object)) {
-    const k = key;
-    if (!fn(object[k], k)) {
-      out[k] = object[k];
-    }
-  }
-  return out;
-}
-
-function pathOr(...args) {
-  return purry(pathOr_, args);
-}
-function pathOr_(data, path, defaultValue) {
-  let current = data;
-  for (const prop of path) {
-    if (current === null || current === void 0) {
-      break;
-    }
-    current = current[prop];
-  }
-  return current ?? defaultValue;
-}
-
-function pick(...args) {
-  return purry(pick_, args);
-}
-function pick_(object, names) {
-  const out = {};
-  for (const name of names) {
-    if (name in object) {
-      out[name] = object[name];
-    }
-  }
-  return out;
-}
-
-function pickBy(...args) {
-  return purry(pickBy_, args);
-}
-function pickBy_(data, fn) {
-  if (data === null || data === void 0) {
-    return {};
-  }
-  const out = {};
-  for (const key of keys.strict(data)) {
-    const k = key;
-    if (fn(data[k], k)) {
-      out[k] = data[k];
-    }
-  }
-  return out;
-}
-
-function prop(propName) {
-  return ({ [propName]: value }) => value;
-}
-
-function set(...args) {
-  return purry(set_, args);
-}
-function set_(obj, prop, value) {
-  return {
-    ...obj,
-    [prop]: value
-  };
-}
-
-function setPath(...args) {
-  return purry(setPath_, args);
-}
-function setPath_(data, path, value) {
-  const [current, ...rest] = path;
-  if (current === void 0) {
-    return value;
-  }
-  if (Array.isArray(data)) {
-    return data.map((item, index) => index === current ? setPath_(item, rest, value) : item);
-  }
-  if (data === null || data === void 0) {
-    throw new Error("Path doesn't exist in object!");
-  }
-  return {
-    ...data,
-    [current]: setPath_(
-      data[current],
-      rest,
-      value
-    )
-  };
-}
-
-function swapProps(...args) {
-  return purry(swapProps_, args);
-}
-function swapProps_(obj, key1, key2) {
-  const { [key1]: value1, [key2]: value2 } = obj;
-  return {
-    ...obj,
-    [key1]: value2,
-    [key2]: value1
-  };
-}
-
-function values(source) {
-  return Object.values(source);
-}
-
-const RE_NUMBER_CHAR = /\d/;
-const STR_SPLITTERS = ["-", "_", "/", "."];
-function isUppercase(char = "") {
-  if (RE_NUMBER_CHAR.test(char)) {
-    return void 0;
-  }
-  return char !== char.toLowerCase();
-}
-function splitByCase(str, separators) {
-  const splitters = separators ?? STR_SPLITTERS;
-  const parts = [];
-  if (!str || !isString(str)) {
-    return parts;
-  }
-  let buff = "";
-  let previousUpper;
-  let previousSplitter;
-  for (const char of str) {
-    const isSplitter = splitters.includes(char);
-    if (isSplitter === true) {
-      parts.push(buff);
-      buff = "";
-      previousUpper = void 0;
-      continue;
-    }
-    const isUpper = isUppercase(char);
-    if (previousSplitter === false) {
-      if (previousUpper === false && isUpper === true) {
-        parts.push(buff);
-        buff = char;
-        previousUpper = isUpper;
-        continue;
-      }
-      if (previousUpper === true && isUpper === false && buff.length > 1) {
-        const lastChar = buff.at(-1);
-        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
-        buff = lastChar + char;
-        previousUpper = isUpper;
-        continue;
-      }
-    }
-    buff += char;
-    previousUpper = isUpper;
-    previousSplitter = isSplitter;
-  }
-  parts.push(buff);
-  return parts;
-}
-function toUpperFirst(str) {
-  return str ? str[0]?.toUpperCase() + str.slice(1) : "";
-}
-function toLowerFirst(str) {
-  return str ? str[0]?.toLowerCase() + str.slice(1) : "";
-}
-function toPascalCase(str, opts) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => toUpperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
-}
-function toCamelCase(str, opts) {
-  return toLowerFirst(toPascalCase(str || "", opts));
-}
-function toKebabCase(str, joiner) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
-}
-function toSnakeCase(str) {
-  return toKebabCase(str || "", "_");
-}
-function toFlatCase(str) {
-  return toKebabCase(str || "", "");
-}
-function toTrainCase(str, opts) {
-  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => toUpperFirst(opts?.normalize ? p.toLowerCase() : p)).join("-");
-}
-const titleCaseExceptions = /^(a|an|and|as|at|but|by|for|if|in|is|nor|of|on|or|the|to|with)$/i;
-function toTitleCase(str, opts) {
-  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => titleCaseExceptions.test(p) ? p.toLowerCase() : toUpperFirst(opts?.normalize ? p.toLowerCase() : p)).join(" ");
-}
-
-function humanReadableFileSize(bytes, base = 1e3) {
-  if (bytes < base) {
-    return `${bytes} B`;
-  }
-  const prefix = base === 1024 ? ["Ki", "Mi", "Gi"] : ["k", "M", "G"];
-  let unit = -1;
-  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {
-    bytes /= base;
-    ++unit;
-  }
-  return `${bytes.toFixed(1)} ${prefix[unit]}B`;
-}
-
-const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-function randomString(...args) {
-  return purry(randomStringImplementation, args);
-}
-function randomStringImplementation(length) {
-  return times(length, randomChar).join("");
-}
-function randomChar() {
-  return ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
-}
-
-function slugify(str) {
-  return str.normalize("NFD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z0-9]/g, " ").trim().replace(/\s+/g, "-");
-}
-
-function stringToPath(path) {
-  return stringToPath_(path);
-}
-function stringToPath_(path) {
-  if (path.length === 0) {
-    return [];
-  }
-  const match = /^\[(.+?)\](.*)$/u.exec(path) ?? /^\.?([^.[\]]+)(.*)$/u.exec(path);
-  if (match !== null) {
-    const [, key, rest] = match;
-    return [key, ...stringToPath_(rest)];
-  }
-  return [path];
+  return result;
 }
+((zip2) => {
+  zip2.strict = zip2;
+})(zip || (zip = {}));
 
 const isBrowser = typeof window !== "undefined";
 
@@ -2241,7 +2156,6 @@ exports.clamp = clamp;
 exports.clone = clone;
 exports.concat = concat;
 exports.conditional = conditional;
-exports.createPipe = createPipe;
 exports.debounce = debounce;
 exports.differenceWith = differenceWith;
 exports.divide = divide;
@@ -2250,6 +2164,7 @@ exports.dropFirstBy = dropFirstBy;
 exports.dropLast = dropLast;
 exports.dropLastWhile = dropLastWhile;
 exports.dropWhile = dropWhile;
+exports.entries = entries;
 exports.filter = filter;
 exports.find = find;
 exports.findIndex = findIndex;
@@ -2258,14 +2173,13 @@ exports.findLastIndex = findLastIndex;
 exports.first = first;
 exports.firstBy = firstBy;
 exports.flatMap = flatMap;
-exports.flatMapToObj = flatMapToObj;
 exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
 exports.floor = floor;
 exports.forEach = forEach;
 exports.forEachObj = forEachObj;
+exports.fromEntries = fromEntries;
 exports.fromKeys = fromKeys;
-exports.fromPairs = fromPairs;
 exports.groupBy = groupBy;
 exports.hasAtLeast = hasAtLeast;
 exports.hasSubObject = hasSubObject;
@@ -2284,9 +2198,9 @@ exports.isEmpty = isEmpty;
 exports.isError = isError;
 exports.isFunction = isFunction;
 exports.isIncludedIn = isIncludedIn;
-exports.isNil = isNil;
 exports.isNonNull = isNonNull;
 exports.isNot = isNot;
+exports.isNullish = isNullish;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
 exports.isPromise = isPromise;
@@ -2302,12 +2216,10 @@ exports.map = map;
 exports.mapKeys = mapKeys;
 exports.mapToObj = mapToObj;
 exports.mapValues = mapValues;
-exports.maxBy = maxBy;
 exports.meanBy = meanBy;
 exports.merge = merge;
 exports.mergeAll = mergeAll;
 exports.mergeDeep = mergeDeep;
-exports.minBy = minBy;
 exports.multiply = multiply;
 exports.noop = noop;
 exports.nthBy = nthBy;
@@ -2320,13 +2232,13 @@ exports.pathOr = pathOr;
 exports.pick = pick;
 exports.pickBy = pickBy;
 exports.pipe = pipe;
+exports.piped = piped;
 exports.prop = prop;
 exports.purry = purry;
 exports.randomString = randomString;
 exports.range = range;
 exports.rankBy = rankBy;
 exports.reduce = reduce;
-exports.reject = reject;
 exports.reverse = reverse;
 exports.round = round;
 exports.sample = sample;
@@ -2342,6 +2254,7 @@ exports.sortedIndex = sortedIndex;
 exports.sortedIndexBy = sortedIndexBy;
 exports.sortedIndexWith = sortedIndexWith;
 exports.sortedLastIndex = sortedLastIndex;
+exports.sortedLastIndexBy = sortedLastIndexBy;
 exports.splice = splice;
 exports.splitAt = splitAt;
 exports.splitByCase = splitByCase;
@@ -2359,17 +2272,14 @@ exports.toCamelCase = toCamelCase;
 exports.toFlatCase = toFlatCase;
 exports.toKebabCase = toKebabCase;
 exports.toLowerFirst = toLowerFirst;
-exports.toPairs = toPairs;
 exports.toPascalCase = toPascalCase;
 exports.toSnakeCase = toSnakeCase;
 exports.toTitleCase = toTitleCase;
 exports.toTrainCase = toTrainCase;
 exports.toUpperFirst = toUpperFirst;
-exports.type = type;
-exports.uniq = uniq;
-exports.uniqBy = uniqBy;
-exports.uniqWith = uniqWith;
+exports.unique = unique;
+exports.uniqueBy = uniqueBy;
+exports.uniqueWith = uniqueWith;
 exports.values = values;
 exports.zip = zip;
-exports.zipObj = zipObj;
 exports.zipWith = zipWith;