@vinicunca/perkakas 0.1.0 → 0.2.1

package/dist/index.js

@@ -22,232 +22,6 @@ var KEY_CODES = {
   TAB: "Tab"
 };
 
-// src/function/pipe.ts
-function pipe(value, ...operations) {
-  let ret = value;
-  const lazyOps = operations.map((op) => {
-    const { lazy, lazyArgs } = op;
-    if (lazy) {
-      const fn = lazy(...lazyArgs || []);
-      fn.indexed = lazy.indexed;
-      fn.single = lazy.single;
-      fn.index = 0;
-      fn.items = [];
-      return fn;
-    }
-    return null;
-  });
-  let opIdx = 0;
-  while (opIdx < operations.length) {
-    const op = operations[opIdx];
-    const lazyOp = lazyOps[opIdx];
-    if (!lazyOp) {
-      ret = op(ret);
-      opIdx++;
-      continue;
-    }
-    const lazySeq = [];
-    for (let j = opIdx; j < operations.length; j++) {
-      if (lazyOps[j]) {
-        lazySeq.push(lazyOps[j]);
-        if (lazyOps[j].single) {
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    const acc = [];
-    for (const item of ret) {
-      if (_processItem({ acc, item, lazySeq })) {
-        break;
-      }
-    }
-    const lastLazySeq = lazySeq[lazySeq.length - 1];
-    if (lastLazySeq.single) {
-      ret = acc[0];
-    } else {
-      ret = acc;
-    }
-    opIdx += lazySeq.length;
-  }
-  return ret;
-}
-function _processItem({
-  acc,
-  item,
-  lazySeq
-}) {
-  if (lazySeq.length === 0) {
-    acc.push(item);
-    return false;
-  }
-  let lazyResult = { done: false, hasNext: false };
-  let isDone = false;
-  for (let i = 0; i < lazySeq.length; i++) {
-    const lazyFn = lazySeq[i];
-    const indexed = lazyFn.indexed;
-    const index = lazyFn.index;
-    const items = lazyFn.items;
-    items.push(item);
-    lazyResult = indexed ? lazyFn(item, index, items) : lazyFn(item);
-    lazyFn.index++;
-    if (lazyResult.hasNext) {
-      if (lazyResult.hasMany) {
-        const nextValues = lazyResult.next;
-        for (const subItem of nextValues) {
-          const subResult = _processItem({
-            acc,
-            item: subItem,
-            lazySeq: lazySeq.slice(i + 1)
-          });
-          if (subResult) {
-            return true;
-          }
-        }
-        return false;
-      } else {
-        item = lazyResult.next;
-      }
-    }
-    if (!lazyResult.hasNext) {
-      break;
-    }
-    if (lazyResult.done) {
-      isDone = true;
-    }
-  }
-  if (lazyResult.hasNext) {
-    acc.push(item);
-  }
-  return !!isDone;
-}
-
-// src/function/create-pipe.ts
-function createPipe(...operations) {
-  return (value) => pipe(value, ...operations);
-}
-
-// src/function/identity.ts
-function identity(value) {
-  return value;
-}
-
-// src/function/noop.ts
-function noop() {
-  return void 0;
-}
-
-// src/function/once.ts
-function once(fn) {
-  let called = false;
-  let ret;
-  return () => {
-    if (!called) {
-      ret = fn();
-      called = true;
-    }
-    return ret;
-  };
-}
-
-// src/function/debounce.ts
-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;
-    }
-  };
-}
-
 // src/function/purry.ts
 function purry(fn, args, lazy) {
   const diff = fn.length - args.length;
@@ -266,13 +40,6 @@ function purry(fn, args, lazy) {
   throw new Error("Wrong number of arguments");
 }
 
-// src/function/sleep.ts
-function sleep(timeout) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeout);
-  });
-}
-
 // src/array/all-pass.ts
 function allPass(...args) {
   return purry(_allPass, args);
@@ -303,148 +70,56 @@ function _chunk(array, size) {
   return ret;
 }
 
-// src/guard/is-array.ts
-function isArray(data) {
-  return Array.isArray(data);
-}
-
-// src/guard/is-boolean.ts
-function isBoolean(data) {
-  return typeof data === "boolean";
+// src/guard/is-truthy.ts
+function isTruthy(data) {
+  return !!data;
 }
 
-// src/guard/is-date.ts
-function isDate(data) {
-  return data instanceof Date;
+// src/array/compact.ts
+function compact(items) {
+  return items.filter(isTruthy);
 }
 
-// src/guard/is-defined.ts
-function isDefined(data) {
-  return typeof data !== "undefined" && data !== null;
+// src/array/concat.ts
+function concat(...args) {
+  return purry(_concat, args);
 }
-((isDefined2) => {
-  function strict(data) {
-    return data !== void 0;
-  }
-  isDefined2.strict = strict;
-})(isDefined || (isDefined = {}));
-
-// src/base.ts
-function toString(value) {
-  return Object.prototype.toString.call(value);
+function _concat(arr1, arr2) {
+  return arr1.concat(arr2);
 }
 
-// src/guard/is-object.ts
-function isObject(data) {
-  return toString(data) === "[object Object]";
+// src/array/count-by.ts
+function _countBy(indexed) {
+  return (array, fn) => {
+    return array.reduce((ret, item, index) => {
+      const value = indexed ? fn(item, index, array) : fn(item);
+      return ret + (value ? 1 : 0);
+    }, 0);
+  };
 }
-
-// src/guard/is-string.ts
-function isString(data) {
-  return typeof data === "string";
+function countBy(...args) {
+  return purry(_countBy(false), args);
 }
-
-// src/guard/is-empty.ts
-function isEmpty(data) {
-  if (isArray(data) || isString(data)) {
-    return data.length === 0;
+((countBy2) => {
+  function indexed(...args) {
+    return purry(_countBy(true), args);
   }
-  if (isObject(data)) {
-    for (const _ in data) {
-      return false;
+  countBy2.indexed = indexed;
+})(countBy || (countBy = {}));
+
+// src/utils/reduce-lazy.ts
+function reduceLazy(array, lazy, indexed) {
+  const newArray = [];
+  for (let index = 0; index < array.length; index++) {
+    const item = array[index];
+    const result = indexed ? lazy(item, index, array) : lazy(item);
+    if (result.hasMany === true) {
+      newArray.push(...result.next);
+    } else if (result.hasNext) {
+      newArray.push(result.next);
     }
-    return !(data instanceof RegExp);
   }
-  return false;
-}
-
-// src/guard/is-error.ts
-function isError(data) {
-  return data instanceof Error;
-}
-
-// src/guard/is-function.ts
-function isFunction(data) {
-  return typeof data === "function";
-}
-
-// src/guard/is-nil.ts
-function isNil(data) {
-  return data == null;
-}
-
-// src/guard/is-non-null.ts
-function isNonNull(data) {
-  return data !== null;
-}
-
-// src/guard/is-not.ts
-function isNot(predicate) {
-  return (data) => {
-    return !predicate(data);
-  };
-}
-
-// src/guard/is-number.ts
-function isNumber(data) {
-  return typeof data === "number" && !Number.isNaN(data);
-}
-
-// src/guard/is-promise.ts
-function isPromise(data) {
-  return data instanceof Promise;
-}
-
-// src/guard/is-truthy.ts
-function isTruthy(data) {
-  return !!data;
-}
-
-// src/array/compact.ts
-function compact(items) {
-  return items.filter(isTruthy);
-}
-
-// src/array/concat.ts
-function concat(...args) {
-  return purry(_concat, args);
-}
-function _concat(arr1, arr2) {
-  return arr1.concat(arr2);
-}
-
-// src/array/count-by.ts
-function _countBy(indexed) {
-  return (array, fn) => {
-    return array.reduce((ret, item, index) => {
-      const value = indexed ? fn(item, index, array) : fn(item);
-      return ret + (value ? 1 : 0);
-    }, 0);
-  };
-}
-function countBy(...args) {
-  return purry(_countBy(false), args);
-}
-((countBy2) => {
-  function indexed(...args) {
-    return purry(_countBy(true), args);
-  }
-  countBy2.indexed = indexed;
-})(countBy || (countBy = {}));
-
-// src/utils/reduce-lazy.ts
-function _reduceLazy(array, lazy, indexed) {
-  const newArray = [];
-  for (let index = 0; index < array.length; index++) {
-    const item = array[index];
-    const result = indexed ? lazy(item, index, array) : lazy(item);
-    if (result.hasMany === true) {
-      newArray.push(...result.next);
-    } else if (result.hasNext) {
-      newArray.push(result.next);
-    }
-  }
-  return newArray;
+  return newArray;
 }
 
 // src/array/difference-with.ts
@@ -453,7 +128,7 @@ function differenceWith(...args) {
 }
 function _differenceWith(array, other, isEquals) {
   const lazy = differenceWith.lazy(other, isEquals);
-  return _reduceLazy(array, lazy);
+  return reduceLazy(array, lazy);
 }
 ((differenceWith2) => {
   function lazy(other, isEquals) {
@@ -480,7 +155,7 @@ function difference(...args) {
 }
 function _difference(array, other) {
   const lazy = difference.lazy(other);
-  return _reduceLazy(array, lazy);
+  return reduceLazy(array, lazy);
 }
 ((difference2) => {
   function lazy(other) {
@@ -519,7 +194,7 @@ function drop(...args) {
   return purry(_drop, args, drop.lazy);
 }
 function _drop(array, n) {
-  return _reduceLazy(array, drop.lazy(n));
+  return reduceLazy(array, drop.lazy(n));
 }
 ((drop2) => {
   function lazy(n) {
@@ -542,26 +217,179 @@ function _drop(array, n) {
   drop2.lazy = lazy;
 })(drop || (drop = {}));
 
+// src/array/has-at-least.ts
+function hasAtLeast(...args) {
+  return purry(hasAtLeastImplementation, args);
+}
+function hasAtLeastImplementation(data, minimum) {
+  return data.length >= minimum;
+}
+
+// src/utils/swap-in-place.ts
+function swapInPlace(data, i, j) {
+  [data[i], data[j]] = [data[j], data[i]];
+}
+
+// src/utils/heap.ts
+function heapify(heap, compareFn) {
+  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
+    heapSiftDown(heap, i, compareFn);
+  }
+}
+function heapMaybeInsert(heap, compareFn, item) {
+  if (!hasAtLeast(heap, 1)) {
+    return;
+  }
+  const head = heap[0];
+  if (compareFn(item, head) >= 0) {
+    return;
+  }
+  heap[0] = item;
+  heapSiftDown(heap, 0, compareFn);
+  return head;
+}
+function heapSiftDown(heap, index, compareFn) {
+  let currentIndex = index;
+  while (currentIndex * 2 + 1 < heap.length) {
+    const firstChildIndex = currentIndex * 2 + 1;
+    let swapIndex = compareFn(heap[currentIndex], heap[firstChildIndex]) < 0 ? firstChildIndex : currentIndex;
+    const secondChildIndex = firstChildIndex + 1;
+    if (secondChildIndex < heap.length && compareFn(heap[swapIndex], heap[secondChildIndex]) < 0) {
+      swapIndex = secondChildIndex;
+    }
+    if (swapIndex === currentIndex) {
+      return;
+    }
+    swapInPlace(heap, currentIndex, swapIndex);
+    currentIndex = swapIndex;
+  }
+}
+
+// src/utils/purry-order-rules.ts
+var COMPARATORS = {
+  asc: (x, y) => x > y,
+  desc: (x, y) => x < y
+};
+function purryOrderRules(func, inputArgs) {
+  const [dataOrRule, ...rules] = Array.isArray(inputArgs) ? inputArgs : Array.from(inputArgs);
+  if (!isOrderRule(dataOrRule)) {
+    const compareFn2 = orderRuleComparer(...rules);
+    return func(dataOrRule, compareFn2);
+  }
+  const compareFn = orderRuleComparer(dataOrRule, ...rules);
+  return (data) => func(data, compareFn);
+}
+function purryOrderRulesWithArgument(func, inputArgs) {
+  const [first2, second, ...rest] = Array.from(inputArgs);
+  let arg;
+  let argRemoved;
+  if (isOrderRule(second)) {
+    arg = first2;
+    argRemoved = [second, ...rest];
+  } else {
+    arg = second;
+    argRemoved = [first2, ...rest];
+  }
+  return purryOrderRules((...args) => func(...args, arg), argRemoved);
+}
+function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
+  const projector = typeof primaryRule === "function" ? primaryRule : primaryRule[0];
+  const direction = typeof primaryRule === "function" ? "asc" : primaryRule[1];
+  const comparator = COMPARATORS[direction];
+  const nextComparer = secondaryRule === void 0 ? void 0 : orderRuleComparer(secondaryRule, ...otherRules);
+  return (a, b) => {
+    const projectedA = projector(a);
+    const projectedB = projector(b);
+    if (comparator(projectedA, projectedB)) {
+      return 1;
+    }
+    if (comparator(projectedB, projectedA)) {
+      return -1;
+    }
+    return nextComparer?.(a, b) ?? 0;
+  };
+}
+function isOrderRule(x) {
+  if (isProjection(x)) {
+    return true;
+  }
+  if (typeof x !== "object" || !Array.isArray(x)) {
+    return false;
+  }
+  const [maybeProjection, maybeDirection, ...rest] = x;
+  return isProjection(maybeProjection) && maybeDirection in COMPARATORS && rest.length === 0;
+}
+function isProjection(x) {
+  return typeof x === "function" && x.length === 1;
+}
+
+// src/array/drop-first-by.ts
+function dropFirstBy(...args) {
+  return purryOrderRulesWithArgument(dropFirstByImplementation, args);
+}
+function dropFirstByImplementation(data, compareFn, n) {
+  if (n >= data.length) {
+    return [];
+  }
+  if (n <= 0) {
+    return [...data];
+  }
+  const heap = data.slice(0, n);
+  heapify(heap, compareFn);
+  const out = [];
+  const rest = data.slice(n);
+  for (const item of rest) {
+    const previousHead = heapMaybeInsert(heap, compareFn, item);
+    out.push(previousHead ?? item);
+  }
+  return out;
+}
+
+// src/array/drop-last-while.ts
+function dropLastWhile(...args) {
+  return purry(_dropLastWhile, args);
+}
+function _dropLastWhile(data, predicate) {
+  for (let i = data.length - 1; i >= 0; i--) {
+    if (!predicate(data[i])) {
+      return data.slice(0, i + 1);
+    }
+  }
+  return [];
+}
+
+// src/array/drop-while.ts
+function dropWhile(...args) {
+  return purry(_dropWhile, args);
+}
+function _dropWhile(data, predicate) {
+  for (let i = 0; i < data.length; i++) {
+    if (!predicate(data[i])) {
+      return data.slice(i);
+    }
+  }
+  return [];
+}
+
 // src/utils/to-lazy-indexed.ts
 function toLazyIndexed(fn) {
-  fn.indexed = true;
-  return fn;
+  return Object.assign(fn, { indexed: true });
 }
 
 // src/array/filter.ts
 function filter(...args) {
-  return purry(_filter(false), args, filter.lazy);
+  return purry(filter_(false), args, filter.lazy);
 }
-function _filter(indexed) {
+function filter_(indexed) {
   return (array, fn) => {
-    return _reduceLazy(
+    return reduceLazy(
       array,
       indexed ? filter.lazyIndexed(fn) : filter.lazy(fn),
       indexed
     );
   };
 }
-function _lazy(indexed) {
+function lazy_(indexed) {
   return (fn) => {
     return (value, index, array) => {
       const valid = indexed ? fn(value, index, array) : fn(value);
@@ -581,11 +409,11 @@ function _lazy(indexed) {
 }
 ((filter2) => {
   function indexed(...args) {
-    return purry(_filter(true), args, filter2.lazyIndexed);
+    return purry(filter_(true), args, filter2.lazyIndexed);
   }
   filter2.indexed = indexed;
-  filter2.lazy = _lazy(false);
-  filter2.lazyIndexed = toLazyIndexed(_lazy(true));
+  filter2.lazy = lazy_(false);
+  filter2.lazyIndexed = toLazyIndexed(lazy_(true));
 })(filter || (filter = {}));
 
 // src/utils/to-single.ts
@@ -606,7 +434,7 @@ function _findIndex(indexed) {
     return array.findIndex((x) => fn(x));
   };
 }
-function _lazy2(indexed) {
+function _lazy(indexed) {
   return (fn) => {
     let i = 0;
     return (value, index, array) => {
@@ -631,8 +459,8 @@ function _lazy2(indexed) {
     return purry(_findIndex(true), args, findIndex2.lazyIndexed);
   }
   findIndex2.indexed = indexed;
-  findIndex2.lazy = toSingle(_lazy2(false));
-  findIndex2.lazyIndexed = toSingle(toLazyIndexed(_lazy2(true)));
+  findIndex2.lazy = toSingle(_lazy(false));
+  findIndex2.lazyIndexed = toSingle(toLazyIndexed(_lazy(true)));
 })(findIndex || (findIndex = {}));
 
 // src/array/find-last-index.ts
@@ -667,6 +495,7 @@ function _findLast(indexed) {
         return array[i];
       }
     }
+    return void 0;
   };
 }
 ((findLast2) => {
@@ -688,7 +517,7 @@ function _find(indexed) {
     return array.find((x) => fn(x));
   };
 }
-function _lazy3(indexed) {
+function _lazy2(indexed) {
   return (fn) => {
     return (value, index, array) => {
       const valid = indexed ? fn(value, index, array) : fn(value);
@@ -705,8 +534,8 @@ function _lazy3(indexed) {
     return purry(_find(true), args, find2.lazyIndexed);
   }
   find2.indexed = indexed;
-  find2.lazy = toSingle(_lazy3(false));
-  find2.lazyIndexed = toSingle(toLazyIndexed(_lazy3(true)));
+  find2.lazy = toSingle(_lazy2(false));
+  find2.lazyIndexed = toSingle(toLazyIndexed(_lazy2(true)));
 })(find || (find = {}));
 
 // src/array/first.ts
@@ -732,6 +561,24 @@ function _first([first2]) {
   })(lazy = first2.lazy || (first2.lazy = {}));
 })(first || (first = {}));
 
+// src/array/first-by.ts
+function firstBy(...args) {
+  return purryOrderRules(firstByImplementation, args);
+}
+function firstByImplementation(data, compareFn) {
+  if (!hasAtLeast(data, 2)) {
+    return data[0];
+  }
+  let [currentFirst] = data;
+  const [, ...rest] = data;
+  for (const item of rest) {
+    if (compareFn(item, currentFirst) < 0) {
+      currentFirst = item;
+    }
+  }
+  return currentFirst;
+}
+
 // src/array/flat-map-to-obj.ts
 function flatMapToObj(...args) {
   return purry(_flatMapToObj(false), args);
@@ -759,7 +606,7 @@ 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() {
@@ -816,7 +663,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)) {
@@ -860,14 +707,14 @@ function forEach(...args) {
 }
 function _forEach(indexed) {
   return (array, fn) => {
-    return _reduceLazy(
+    return reduceLazy(
       array,
       indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
       indexed
     );
   };
 }
-function _lazy4(indexed) {
+function _lazy3(indexed) {
   return (fn) => {
     return (value, index, array) => {
       if (indexed) {
@@ -888,8 +735,8 @@ function _lazy4(indexed) {
     return purry(_forEach(true), args, forEach2.lazyIndexed);
   }
   forEach2.indexed = indexed;
-  forEach2.lazy = _lazy4(false);
-  forEach2.lazyIndexed = toLazyIndexed(_lazy4(true));
+  forEach2.lazy = _lazy3(false);
+  forEach2.lazyIndexed = toLazyIndexed(_lazy3(true));
 })(forEach || (forEach = {}));
 
 // src/array/group-by.ts
@@ -903,10 +750,12 @@ function _groupBy(indexed) {
       const key = indexed ? fn(item, index, array) : fn(item);
       if (key !== void 0) {
         const actualKey = String(key);
-        if (!ret[actualKey]) {
-          ret[actualKey] = [];
+        let items = ret[actualKey];
+        if (items === void 0) {
+          items = [];
+          ret[actualKey] = items;
         }
-        ret[actualKey].push(item);
+        items.push(item);
       }
     });
     return ret;
@@ -947,7 +796,7 @@ function intersection(...args) {
 }
 function _intersection(array, other) {
   const lazy = intersection.lazy(other);
-  return _reduceLazy(array, lazy);
+  return reduceLazy(array, lazy);
 }
 ((intersection2) => {
   function lazy(other) {
@@ -975,7 +824,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) {
@@ -1026,14 +875,14 @@ function map(...args) {
 }
 function _map(indexed) {
   return (array, fn) => {
-    return _reduceLazy(
+    return reduceLazy(
       array,
       indexed ? map.lazyIndexed(fn) : map.lazy(fn),
       indexed
     );
   };
 }
-function _lazy5(indexed) {
+function _lazy4(indexed) {
   return (fn) => {
     return (value, index, array) => {
       return {
@@ -1049,8 +898,8 @@ function _lazy5(indexed) {
     return purry(_map(true), args, map2.lazyIndexed);
   }
   map2.indexed = indexed;
-  map2.lazy = _lazy5(false);
-  map2.lazyIndexed = toLazyIndexed(_lazy5(true));
+  map2.lazy = _lazy4(false);
+  map2.lazyIndexed = toLazyIndexed(_lazy4(true));
   map2.strict = map2;
 })(map || (map = {}));
 
@@ -1060,11 +909,14 @@ function mapToObj(...args) {
 }
 function _mapToObj(indexed) {
   return (array, fn) => {
-    return array.reduce((result, element, index) => {
-      const [key, value] = indexed ? fn(element, index, array) : fn(element);
-      result[key] = value;
-      return result;
-    }, {});
+    return array.reduce(
+      (result, element, index) => {
+        const [key, value] = indexed ? fn(element, index, array) : fn(element);
+        result[key] = value;
+        return result;
+      },
+      {}
+    );
   };
 }
 ((mapToObj2) => {
@@ -1152,8 +1004,70 @@ function minBy(...args) {
   minBy2.indexed = indexed;
 })(minBy || (minBy = {}));
 
+// src/utils/quick-select.ts
+function quickSelect(data, index, compareFn) {
+  return index < 0 || index >= data.length ? void 0 : quickSelectImplementation(
+    // We need to clone the array because quickSelect mutates it in-place.
+    [...data],
+    0,
+    data.length - 1,
+    index,
+    compareFn
+  );
+}
+function quickSelectImplementation(data, left, right, index, compareFn) {
+  if (left === right) {
+    return data[left];
+  }
+  const pivotIndex = partition(data, left, right, compareFn);
+  return index === pivotIndex ? data[index] : quickSelectImplementation(
+    data,
+    // We continue by recursing into the partition where index would be
+    index < pivotIndex ? left : pivotIndex + 1,
+    index < pivotIndex ? pivotIndex - 1 : right,
+    index,
+    compareFn
+  );
+}
+function partition(data, left, right, compareFn) {
+  const pivot = data[right];
+  let i = left;
+  for (let j = left; j < right; j++) {
+    if (compareFn(data[j], pivot) < 0) {
+      swapInPlace(data, i, j);
+      i++;
+    }
+  }
+  swapInPlace(data, i, right);
+  return i;
+}
+
+// src/array/nth-by.ts
+function nthBy(...args) {
+  return purryOrderRulesWithArgument(nthByImplementation, args);
+}
+function nthByImplementation(data, compareFn, index) {
+  return quickSelect(
+    data,
+    // Allow negative indices gracefully
+    index >= 0 ? index : data.length + index,
+    compareFn
+  );
+}
+
+// src/array/only.ts
+function only(...args) {
+  return purry(_only, args);
+}
+function _only(array) {
+  if (array.length === 1) {
+    return array[0];
+  }
+  return void 0;
+}
+
 // src/array/partition.ts
-function partition(...args) {
+function partition2(...args) {
   return purry(_partition(false), args);
 }
 function _partition(indexed) {
@@ -1166,12 +1080,12 @@ function _partition(indexed) {
     return ret;
   };
 }
-((partition2) => {
+((partition3) => {
   function indexed(...args) {
     return purry(_partition(true), args);
   }
-  partition2.indexed = indexed;
-})(partition || (partition = {}));
+  partition3.indexed = indexed;
+})(partition2 || (partition2 = {}));
 
 // src/array/range.ts
 function range(...args) {
@@ -1185,6 +1099,20 @@ function _range(start, end) {
   return ret;
 }
 
+// src/array/rank-by.ts
+function rankBy(...args) {
+  return purryOrderRulesWithArgument(rankByImplementation, args);
+}
+function rankByImplementation(data, compareFn, targetItem) {
+  let rank = 0;
+  for (const item of data) {
+    if (compareFn(targetItem, item) > 0) {
+      rank++;
+    }
+  }
+  return rank;
+}
+
 // src/array/reduce.ts
 function reduce(...args) {
   return purry(_reduce(false), args);
@@ -1210,14 +1138,14 @@ function reject(...args) {
 }
 function _reject(indexed) {
   return (array, fn) => {
-    return _reduceLazy(
+    return reduceLazy(
       array,
       indexed ? reject.lazyIndexed(fn) : reject.lazy(fn),
       indexed
     );
   };
 }
-function _lazy6(indexed) {
+function _lazy5(indexed) {
   return (fn) => {
     return (value, index, array) => {
       const valid = indexed ? fn(value, index, array) : fn(value);
@@ -1240,8 +1168,8 @@ function _lazy6(indexed) {
     return purry(_reject(true), args, reject2.lazyIndexed);
   }
   reject2.indexed = indexed;
-  reject2.lazy = _lazy6(false);
-  reject2.lazyIndexed = toLazyIndexed(_lazy6(true));
+  reject2.lazy = _lazy5(false);
+  reject2.lazyIndexed = toLazyIndexed(_lazy5(true));
 })(reject || (reject = {}));
 
 // src/array/reverse.ts
@@ -1353,6 +1281,16 @@ function comparer(primaryRule, secondaryRule, ...otherRules) {
   sortBy2.strict = sortBy2;
 })(sortBy || (sortBy = {}));
 
+// src/array/splice.ts
+function splice(...args) {
+  return purry(_splice, args);
+}
+function _splice(items, start, deleteCount, replacement) {
+  const result = [...items];
+  result.splice(start, deleteCount, ...replacement);
+  return result;
+}
+
 // src/array/split-at.ts
 function splitAt(...args) {
   return purry(_splitAt, args);
@@ -1421,193 +1359,611 @@ function _swapArray(item, index1, index2) {
   result[positiveIndexB] = item[positiveIndexA];
   return result;
 }
-function _swapString(item, index1, index2) {
-  const result = _swapArray(item.split(""), index1, index2);
-  return result.join("");
+function _swapString(item, index1, index2) {
+  const result = _swapArray(item.split(""), index1, index2);
+  return result.join("");
+}
+
+// src/array/take.ts
+function take(...args) {
+  return purry(_take, args, take.lazy);
+}
+function _take(array, n) {
+  return reduceLazy(array, take.lazy(n));
+}
+((take2) => {
+  function lazy(n) {
+    return (value) => {
+      if (n === 0) {
+        return {
+          done: true,
+          hasNext: false
+        };
+      }
+      n--;
+      if (n === 0) {
+        return {
+          done: true,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  take2.lazy = lazy;
+})(take || (take = {}));
+
+// src/array/take-first-by.ts
+function takeFirstBy(...args) {
+  return purryOrderRulesWithArgument(takeFirstByImplementation, args);
+}
+function takeFirstByImplementation(data, compareFn, n) {
+  if (n <= 0) {
+    return [];
+  }
+  if (n >= data.length) {
+    return [...data];
+  }
+  const heap = data.slice(0, n);
+  heapify(heap, compareFn);
+  const rest = data.slice(n);
+  for (const item of rest) {
+    heapMaybeInsert(heap, compareFn, item);
+  }
+  return heap;
+}
+
+// src/array/take-while.ts
+function takeWhile(...args) {
+  return purry(_takeWhile, args);
+}
+function _takeWhile(array, fn) {
+  const ret = [];
+  for (const item of array) {
+    if (!fn(item)) {
+      break;
+    }
+    ret.push(item);
+  }
+  return ret;
+}
+
+// src/array/uniq.ts
+function uniq(...args) {
+  return purry(_uniq, args, uniq.lazy);
+}
+function _uniq(array) {
+  return reduceLazy(array, uniq.lazy());
+}
+((uniq2) => {
+  function lazy() {
+    const set2 = /* @__PURE__ */ new Set();
+    return (value) => {
+      if (set2.has(value)) {
+        return {
+          done: false,
+          hasNext: false
+        };
+      }
+      set2.add(value);
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  uniq2.lazy = lazy;
+})(uniq || (uniq = {}));
+
+// src/array/uniq-by.ts
+function uniqBy(...args) {
+  return purry(_uniqBy, args, lazyUniqBy);
+}
+function _uniqBy(array, transformer) {
+  return reduceLazy(array, lazyUniqBy(transformer));
+}
+function lazyUniqBy(transformer) {
+  const set2 = /* @__PURE__ */ new Set();
+  return (value) => {
+    const appliedItem = transformer(value);
+    if (set2.has(appliedItem)) {
+      return {
+        done: false,
+        hasNext: false
+      };
+    }
+    set2.add(appliedItem);
+    return {
+      done: false,
+      hasNext: true,
+      next: value
+    };
+  };
+}
+
+// src/array/uniq-with.ts
+function uniqWith(...args) {
+  return purry(_uniqWith, args, uniqWith.lazy);
+}
+function _uniqWith(array, isEquals) {
+  const lazy = uniqWith.lazy(isEquals);
+  return reduceLazy(array, lazy, true);
+}
+function _lazy6(isEquals) {
+  return (value, index, array) => {
+    if (array && array.findIndex((otherValue) => isEquals(value, otherValue)) === index) {
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    }
+    return {
+      done: false,
+      hasNext: false
+    };
+  };
+}
+((uniqWith2) => {
+  uniqWith2.lazy = toLazyIndexed(_lazy6);
+})(uniqWith || (uniqWith = {}));
+
+// src/array/zip.ts
+function zip(...args) {
+  return purry(_zip, args);
+}
+function _zip(first2, second) {
+  const resultLength = first2.length > second.length ? second.length : first2.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push([first2[i], second[i]]);
+  }
+  return result;
+}
+((zip2) => {
+  zip2.strict = zip2;
+})(zip || (zip = {}));
+
+// src/array/zip-obj.ts
+function zipObj(...args) {
+  return purry(_zipObj, args);
+}
+function _zipObj(first2, second) {
+  const resultLength = first2.length > second.length ? second.length : first2.length;
+  const result = {};
+  for (let i = 0; i < resultLength; i++) {
+    result[first2[i]] = second[i];
+  }
+  return result;
+}
+
+// src/array/zip-with.ts
+function zipWith(arg0, arg1, arg2) {
+  if (typeof arg0 === "function") {
+    return arg1 === void 0 ? (f, s) => _zipWith(f, s, arg0) : (f) => _zipWith(f, arg1, arg0);
+  }
+  if (arg1 === void 0 || arg2 === void 0) {
+    throw new Error("zipWith: Missing arguments in dataFirst function call");
+  }
+  return _zipWith(arg0, arg1, arg2);
+}
+function _zipWith(first2, second, fn) {
+  const resultLength = first2.length > second.length ? second.length : first2.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push(fn(first2[i], second[i]));
+  }
+  return result;
+}
+
+// src/utils/purry-on.ts
+function purryOn(isArg, implementation, args) {
+  const callArgs = Array.from(args);
+  return isArg(args[0]) ? (data) => implementation(data, ...callArgs) : implementation(...callArgs);
+}
+
+// src/function/conditional.ts
+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;
+}
+var trivialDefaultCase = () => void 0;
+((conditional2) => {
+  function defaultCase(then = trivialDefaultCase) {
+    return [() => true, then];
+  }
+  conditional2.defaultCase = defaultCase;
+})(conditional || (conditional = {}));
+
+// src/function/pipe.ts
+function pipe(input, ...operations) {
+  let output = input;
+  const lazyOperations = operations.map(
+    (op) => "lazy" in op ? toPipedLazy(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++;
+      continue;
+    }
+    const lazySequence = [];
+    for (let j = operationIndex; j < operations.length; j++) {
+      const lazyOp = lazyOperations[j];
+      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];
+    if (isSingle) {
+      output = accumulator[0];
+    } else {
+      output = accumulator;
+    }
+    operationIndex += lazySequence.length;
+  }
+  return output;
+}
+function processItem_(item, accumulator, lazySequence) {
+  if (lazySequence.length === 0) {
+    accumulator.push(item);
+    return false;
+  }
+  let lazyResult = { done: false, hasNext: false };
+  let isDone = false;
+  for (let i = 0; i < lazySequence.length; i++) {
+    const lazyFn = lazySequence[i];
+    const { index, isIndexed, items } = lazyFn;
+    items.push(item);
+    lazyResult = isIndexed ? lazyFn(item, index, items) : lazyFn(item);
+    lazyFn.index++;
+    if (lazyResult.hasNext) {
+      if (lazyResult.hasMany) {
+        const nextValues = lazyResult.next;
+        for (const subItem of nextValues) {
+          const subResult = processItem_(
+            subItem,
+            accumulator,
+            lazySequence.slice(i + 1)
+          );
+          if (subResult) {
+            return true;
+          }
+        }
+        return false;
+      } else {
+        item = lazyResult.next;
+      }
+    }
+    if (!lazyResult.hasNext) {
+      break;
+    }
+    if (lazyResult.done) {
+      isDone = true;
+    }
+  }
+  if (lazyResult.hasNext) {
+    accumulator.push(item);
+  }
+  return isDone;
+}
+function toPipedLazy(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;
+}
+
+// src/function/create-pipe.ts
+function createPipe(...operations) {
+  return (value) => pipe(value, ...operations);
+}
+
+// src/function/identity.ts
+function identity(value) {
+  return value;
+}
+
+// src/function/noop.ts
+function noop() {
+  return void 0;
+}
+
+// src/function/once.ts
+function once(fn) {
+  let called = false;
+  let ret;
+  return () => {
+    if (!called) {
+      ret = fn();
+      called = true;
+    }
+    return ret;
+  };
+}
+
+// src/function/debounce.ts
+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;
+    }
+  };
+}
+
+// src/function/sleep.ts
+function sleep(timeout) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+  });
+}
+
+// src/guard/is-array.ts
+function isArray(data) {
+  return Array.isArray(data);
+}
+
+// src/guard/is-boolean.ts
+function isBoolean(data) {
+  return typeof data === "boolean";
 }
 
-// src/array/take.ts
-function take(...args) {
-  return purry(_take, args, take.lazy);
+// src/guard/is-date.ts
+function isDate(data) {
+  return data instanceof Date;
 }
-function _take(array, n) {
-  return _reduceLazy(array, take.lazy(n));
+
+// src/guard/is-defined.ts
+function isDefined(data) {
+  return typeof data !== "undefined" && data !== null;
 }
-((take2) => {
-  function lazy(n) {
-    return (value) => {
-      if (n === 0) {
-        return {
-          done: true,
-          hasNext: false
-        };
-      }
-      n--;
-      if (n === 0) {
-        return {
-          done: true,
-          hasNext: true,
-          next: value
-        };
-      }
-      return {
-        done: false,
-        hasNext: true,
-        next: value
-      };
-    };
+((isDefined2) => {
+  function strict(data) {
+    return data !== void 0;
   }
-  take2.lazy = lazy;
-})(take || (take = {}));
+  isDefined2.strict = strict;
+})(isDefined || (isDefined = {}));
 
-// src/array/take-while.ts
-function takeWhile(...args) {
-  return purry(_takeWhile, args);
+// src/guard/is-object.ts
+function isObject(data) {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(data);
+  return proto === null || proto === Object.prototype;
 }
-function _takeWhile(array, fn) {
-  const ret = [];
-  for (const item of array) {
-    if (!fn(item)) {
-      break;
+
+// src/guard/is-string.ts
+function isString(data) {
+  return typeof data === "string";
+}
+
+// src/guard/is-empty.ts
+function isEmpty(data) {
+  if (isArray(data) || isString(data)) {
+    return data.length === 0;
+  }
+  if (isObject(data)) {
+    for (const _ in data) {
+      return false;
     }
-    ret.push(item);
+    return !(data instanceof RegExp);
   }
-  return ret;
+  return false;
 }
 
-// src/array/uniq.ts
-function uniq(...args) {
-  return purry(_uniq, args, uniq.lazy);
+// src/guard/is-error.ts
+function isError(data) {
+  return data instanceof Error;
 }
-function _uniq(array) {
-  return _reduceLazy(array, uniq.lazy());
+
+// src/guard/is-function.ts
+function isFunction(data) {
+  return typeof data === "function";
 }
-((uniq2) => {
-  function lazy() {
-    const set2 = /* @__PURE__ */ new Set();
-    return (value) => {
-      if (set2.has(value)) {
-        return {
-          done: false,
-          hasNext: false
-        };
-      }
-      set2.add(value);
-      return {
-        done: false,
-        hasNext: true,
-        next: value
-      };
-    };
-  }
-  uniq2.lazy = lazy;
-})(uniq || (uniq = {}));
 
-// src/array/uniq-by.ts
-function uniqBy(...args) {
-  return purry(_uniqBy, args, lazyUniqBy);
+// src/guard/is-nil.ts
+function isNil(data) {
+  return data == null;
 }
-function _uniqBy(array, transformer) {
-  return _reduceLazy(array, lazyUniqBy(transformer));
+
+// src/guard/is-non-null.ts
+function isNonNull(data) {
+  return data !== null;
 }
-function lazyUniqBy(transformer) {
-  const set2 = /* @__PURE__ */ new Set();
-  return (value) => {
-    const appliedItem = transformer(value);
-    if (set2.has(appliedItem)) {
-      return {
-        done: false,
-        hasNext: false
-      };
-    }
-    set2.add(appliedItem);
-    return {
-      done: false,
-      hasNext: true,
-      next: value
-    };
+
+// src/guard/is-not.ts
+function isNot(predicate) {
+  return (data) => {
+    return !predicate(data);
   };
 }
 
-// src/array/uniq-with.ts
-function uniqWith(...args) {
-  return purry(_uniqWith, args, uniqWith.lazy);
-}
-function _uniqWith(array, isEquals) {
-  const lazy = uniqWith.lazy(isEquals);
-  return _reduceLazy(array, lazy, true);
-}
-function _lazy7(isEquals) {
-  return (value, index, array) => {
-    if (array && array.findIndex((otherValue) => isEquals(value, otherValue)) === index) {
-      return {
-        done: false,
-        hasNext: true,
-        next: value
-      };
-    }
-    return {
-      done: false,
-      hasNext: false
-    };
-  };
+// src/guard/is-number.ts
+function isNumber(data) {
+  return typeof data === "number" && !Number.isNaN(data);
 }
-((uniqWith2) => {
-  uniqWith2.lazy = toLazyIndexed(_lazy7);
-})(uniqWith || (uniqWith = {}));
 
-// src/array/zip.ts
-function zip(...args) {
-  return purry(_zip, args);
+// src/guard/is-promise.ts
+function isPromise(data) {
+  return data instanceof Promise;
 }
-function _zip(first2, second) {
-  const resultLength = first2.length > second.length ? second.length : first2.length;
-  const result = [];
-  for (let i = 0; i < resultLength; i++) {
-    result.push([first2[i], second[i]]);
-  }
-  return result;
+
+// src/guard/is-symbol.ts
+function isSymbol(data) {
+  return typeof data === "symbol";
 }
-((zip2) => {
-  zip2.strict = zip2;
-})(zip || (zip = {}));
 
-// src/array/zip-obj.ts
-function zipObj(...args) {
-  return purry(_zipObj, args);
+// src/number/add.ts
+function add(...args) {
+  return purry(_add, args);
 }
-function _zipObj(first2, second) {
-  const resultLength = first2.length > second.length ? second.length : first2.length;
-  const result = {};
-  for (let i = 0; i < resultLength; i++) {
-    result[first2[i]] = second[i];
-  }
-  return result;
+function _add(value, addend) {
+  return value + addend;
 }
 
-// src/array/zip-with.ts
-function zipWith(...args) {
-  if (typeof args[0] === "function" && args.length === 1) {
-    return function(f, s) {
-      return _zipWith(f, s, args[0]);
-    };
-  }
-  if (typeof args[0] === "function" && args.length === 2) {
-    return function(f) {
-      return _zipWith(f, args[1], args[0]);
-    };
-  }
-  if (args.length === 3) {
-    return _zipWith(args[0], args[1], args[2]);
-  }
+// src/utils/with-precision.ts
+var 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 _zipWith(first2, second, fn) {
-  const resultLength = first2.length > second.length ? second.length : first2.length;
-  const result = [];
-  for (let i = 0; i < resultLength; i++) {
-    result.push(fn(first2[i], second[i]));
-  }
-  return result;
+
+// src/number/ceil.ts
+function ceil(...args) {
+  return purry(withPrecision(Math.ceil), args);
 }
 
 // src/number/clamp.ts
@@ -1624,6 +1980,40 @@ function _clamp(value, limits) {
   return value;
 }
 
+// src/number/divide.ts
+function divide(...args) {
+  return purry(_divide, args);
+}
+function _divide(value, divisor) {
+  return value / divisor;
+}
+
+// src/number/floor.ts
+function floor(...args) {
+  return purry(withPrecision(Math.floor), args);
+}
+
+// src/number/multiply.ts
+function multiply(...args) {
+  return purry(_multiply, args);
+}
+function _multiply(value, multiplicand) {
+  return value * multiplicand;
+}
+
+// src/number/round.ts
+function round(...args) {
+  return purry(withPrecision(Math.round), args);
+}
+
+// src/number/subtract.ts
+function subtract(...args) {
+  return purry(_subtract, args);
+}
+function _subtract(value, subtrahend) {
+  return value - subtrahend;
+}
+
 // src/object/add-prop.ts
 function addProp(...args) {
   return purry(_addProp, args);
@@ -1813,32 +2203,36 @@ function keys(source) {
   keys2.strict = keys2;
 })(keys || (keys = {}));
 
+// src/object/to-pairs.ts
+function toPairs(...args) {
+  return purry(Object.entries, args);
+}
+((toPairs2) => {
+  toPairs2.strict = toPairs2;
+})(toPairs || (toPairs = {}));
+
 // src/object/map-keys.ts
-function mapKeys(arg1, arg2) {
-  if (arguments.length === 1) {
-    return (data) => _mapKeys(data, arg1);
-  }
-  return _mapKeys(arg1, arg2);
+function mapKeys(...args) {
+  return purry(_mapKeys, args);
 }
-function _mapKeys(obj, fn) {
-  return Object.keys(obj).reduce((acc, key) => {
-    acc[fn(key, obj[key])] = obj[key];
-    return acc;
-  }, {});
+function _mapKeys(data, fn) {
+  const out = {};
+  for (const [key, value] of toPairs.strict(data)) {
+    out[fn(key, value)] = value;
+  }
+  return out;
 }
 
 // src/object/map-values.ts
-function mapValues(arg1, arg2) {
-  if (arguments.length === 1) {
-    return (data) => _mapValues(data, arg1);
-  }
-  return _mapValues(arg1, arg2);
+function mapValues(...args) {
+  return purry(_mapValues, args);
 }
-function _mapValues(obj, fn) {
-  return Object.keys(obj).reduce((acc, key) => {
-    acc[key] = fn(obj[key], key);
-    return acc;
-  }, {});
+function _mapValues(data, fn) {
+  const out = {};
+  for (const [key, value] of toPairs.strict(data)) {
+    out[key] = fn(value, key);
+  }
+  return out;
 }
 
 // src/object/merge.ts
@@ -1880,10 +2274,10 @@ function omit(...args) {
   return purry(_omit, args);
 }
 function _omit(data, propNames) {
-  if (propNames.length === 0) {
+  if (!hasAtLeast(propNames, 1)) {
     return { ...data };
   }
-  if (propNames.length === 1) {
+  if (!hasAtLeast(propNames, 2)) {
     const [propName] = propNames;
     const {
       [propName]: omitted,
@@ -1905,7 +2299,10 @@ function omitBy(...args) {
   return purry(_omitBy, args);
 }
 function _omitBy(object, fn) {
-  return Object.keys(object).reduce((acc, key) => {
+  if (object === void 0 || object === null) {
+    return object;
+  }
+  return keys.strict(object).reduce((acc, key) => {
     if (!fn(object[key], key)) {
       acc[key] = object[key];
     }
@@ -1952,7 +2349,7 @@ function _pickBy(object, fn) {
   if (object == null) {
     return {};
   }
-  return Object.keys(object).reduce((acc, key) => {
+  return keys.strict(object).reduce((acc, key) => {
     if (fn(object[key], key)) {
       acc[key] = object[key];
     }
@@ -2011,17 +2408,6 @@ function _swapProps(obj, key1, key2) {
   };
 }
 
-// src/object/to-pairs.ts
-function toPairs(object) {
-  return Object.entries(object);
-}
-((toPairs2) => {
-  function strict(object) {
-    return Object.entries(object);
-  }
-  toPairs2.strict = strict;
-})(toPairs || (toPairs = {}));
-
 // src/object/values.ts
 function values(source) {
   return Object.values(source);
@@ -2034,18 +2420,18 @@ function isUppercase(char = "") {
   if (RE_NUMBER_CHAR.test(char)) {
     return void 0;
   }
-  return char.toUpperCase() === char;
+  return char !== char.toLowerCase();
 }
-function splitByCase(string_, separators) {
+function splitByCase(str, separators) {
   const splitters = separators ?? STR_SPLITTERS;
   const parts = [];
-  if (!string_ || !isString(string_)) {
+  if (!str || !isString(str)) {
     return parts;
   }
   let buff = "";
   let previousUpper;
   let previousSplitter;
-  for (const char of string_) {
+  for (const char of str) {
     const isSplitter = splitters.includes(char);
     if (isSplitter === true) {
       parts.push(buff);
@@ -2062,7 +2448,7 @@ function splitByCase(string_, separators) {
         continue;
       }
       if (previousUpper === true && isUpper === false && buff.length > 1) {
-        const lastChar = buff[buff.length - 1];
+        const lastChar = buff.at(-1);
         parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
         buff = lastChar + char;
         previousUpper = isUpper;
@@ -2076,23 +2462,33 @@ function splitByCase(string_, separators) {
   parts.push(buff);
   return parts;
 }
-function toUpperFirst(string_) {
-  return !string_ ? "" : string_[0].toUpperCase() + string_.slice(1);
+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 toLowerFirst(string_) {
-  return !string_ ? "" : string_[0].toLowerCase() + string_.slice(1);
+function toKebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
-function toPascalCase(string_) {
-  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => toUpperFirst(p)).join("");
+function toSnakeCase(str) {
+  return toKebabCase(str || "", "_");
 }
-function toCamelCase(string_) {
-  return toLowerFirst(toPascalCase(string_ || ""));
+function toFlatCase(str) {
+  return toKebabCase(str || "", "");
 }
-function toKebabCase(string_, joiner) {
-  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => p.toLowerCase()).join(joiner ?? "-");
+function toTrainCase(str, opts) {
+  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => toUpperFirst(opts?.normalize ? p.toLowerCase() : p)).join("-");
 }
-function toSnakeCase(string_) {
-  return toKebabCase(string_ || "", "_");
+var titleCaseExceptions = /^(a|an|and|as|at|but|by|for|if|in|is|nor|of|on|or|the|to|with)$/i;
+function titleCase(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(" ");
 }
 
 // src/string/human-readable-file-size.ts
@@ -2142,21 +2538,28 @@ var isBrowser = typeof window !== "undefined";
 export {
   KEY_CODES,
   _setPath,
+  add,
   addProp,
   allPass,
   anyPass,
+  ceil,
   chunk,
   clamp,
   clone,
   compact,
   concat,
+  conditional,
   countBy,
   createPipe,
   debounce,
   difference,
   differenceWith,
+  divide,
   drop,
+  dropFirstBy,
   dropLast,
+  dropLastWhile,
+  dropWhile,
   equals,
   filter,
   find,
@@ -2164,14 +2567,17 @@ export {
   findLast,
   findLastIndex,
   first,
+  firstBy,
   flatMap,
   flatMapToObj,
   flatten,
   flattenDeep,
+  floor,
   forEach,
   forEachObj,
   fromPairs,
   groupBy,
+  hasAtLeast,
   humanReadableFileSize,
   identity,
   indexBy,
@@ -2193,6 +2599,7 @@ export {
   isObject,
   isPromise,
   isString,
+  isSymbol,
   isTruthy,
   isUppercase,
   join,
@@ -2209,11 +2616,14 @@ export {
   mergeAll,
   mergeDeep,
   minBy,
+  multiply,
   noop,
+  nthBy,
   omit,
   omitBy,
   once,
-  partition,
+  only,
+  partition2 as partition,
   pathOr,
   pick,
   pickBy,
@@ -2222,9 +2632,11 @@ export {
   purry,
   randomString,
   range,
+  rankBy,
   reduce,
   reject,
   reverse,
+  round,
   sample,
   set,
   setPath,
@@ -2233,21 +2645,27 @@ export {
   slugify,
   sort,
   sortBy,
+  splice,
   splitAt,
   splitByCase,
   splitWhen,
   stringToPath,
+  subtract,
   sumBy,
   swapIndices,
   swapProps,
   take,
+  takeFirstBy,
   takeWhile,
+  titleCase,
   toCamelCase,
+  toFlatCase,
   toKebabCase,
   toLowerFirst,
   toPairs,
   toPascalCase,
   toSnakeCase,
+  toTrainCase,
   toUpperFirst,
   type,
   uniq,