@vinicunca/perkakas 0.1.0 → 0.2.1

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { MergeDeep } from 'type-fest';
+import { IsAny, ReadonlyTuple, MergeDeep } from 'type-fest';
 
 /**
  * Using event.code is not predictable since each machine may have different output
@@ -92,7 +92,7 @@ declare function anyPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T)
 
 type Pred<T, K> = (input: T) => K;
 type PredIndexed<T, K> = (input: T, index: number, array: Array<T>) => K;
-type PredIndexedOptional<T, K> = (input: T, index?: number, array?: Array<T>) => K;
+type PredIndexedOptional<T, K> = (input: T, index?: number, array?: ReadonlyArray<T>) => K;
 type NonEmptyArray<T> = [T, ...Array<T>];
 /**
  * This should only be used for defining generics which extend any kind of JS
@@ -107,6 +107,14 @@ type NonEmptyArray<T> = [T, ...Array<T>];
  * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
  */
 type IterableContainer<T = unknown> = [] | ReadonlyArray<T>;
+type ObjectKeys$1<T extends object> = `${Exclude<keyof T, symbol>}`;
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
 
 type Chunked<T extends IterableContainer> = T[number] extends never ? [] : T extends readonly [...Array<unknown>, unknown] | readonly [unknown, ...Array<unknown>] ? NonEmptyArray<NonEmptyArray<T[number]>> : Array<NonEmptyArray<T[number]>>;
 /**
@@ -304,6 +312,7 @@ declare namespace difference {
 declare function dropLast<T>(array: ReadonlyArray<T>, n: number): Array<T>;
 /**
  * Removes last `n` elements from the `array`.
+ * @param array the target array
  * @param n the number of elements to skip
  * @signature
  *    P.dropLast(n)(array)
@@ -329,6 +338,7 @@ declare function dropLast<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
 declare function drop<T>(array: ReadonlyArray<T>, n: number): Array<T>;
 /**
  * Removes first `n` elements from the `array`.
+ * @param array the target array
  * @param n the number of elements to skip
  * @signature
  *    P.drop(n)(array)
@@ -343,6 +353,142 @@ declare namespace drop {
     function lazy<T>(n: number): (value: T) => LazyResult<T>;
 }
 
+declare const COMPARATORS: {
+    readonly asc: <T>(x: T, y: T) => boolean;
+    readonly desc: <T_1>(x: T_1, y: T_1) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable$1;
+type Comparable$1 = {
+    [Symbol.toPrimitive](hint: string): ComparablePrimitive$1;
+} | {
+    toString(): string;
+} | {
+    valueOf(): ComparablePrimitive$1;
+} | ComparablePrimitive$1;
+type ComparablePrimitive$1 = boolean | number | string;
+
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before dropping the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.dropFirstBy(data, n, ...rules);
+ * @example
+ *   P.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']
+ * @dataFirst
+ * @category Array
+ */
+declare function dropFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.dropFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']
+ * @dataLast
+ * @category Array
+ */
+declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param data the array
+ * @param predicate the predicate
+ * @signature
+ *    P.dropLastWhile(data, predicate)
+ * @example
+ *    P.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropLastWhile<T>(data: ReadonlyArray<T>, predicate: (item: T) => boolean): Array<T>;
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param predicate the predicate
+ * @signature
+ *    P.dropLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropLastWhile(x => x < 10))  // => [1, 2, 10]
+ * @dataLast
+ * @category Array
+ */
+declare function dropLastWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array,
+ * until the predicate returns false.
+ * The returned array includes the rest of the elements,
+ * starting with the element that produced false for the predicate.
+ *
+ * @param data the array
+ * @param predicate the predicate
+ * @signature
+ *    P.dropWhile(data, predicate)
+ * @example
+ *    P.dropWhile([1, 2, 10, 3, 4], x => x < 10) // => [10, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropWhile<T>(data: ReadonlyArray<T>, predicate: (item: T) => boolean): Array<T>;
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.
+ *
+ * @param predicate the predicate
+ * @signature
+ *    P.dropWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropWhile(x => x < 10))  // => [10, 3, 4]
+ * @dataLast
+ * @category Array
+ */
+declare function dropWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+
 /**
  * Filter the elements of an array that meet the condition specified in a callback function.
  * @param array The array to filter.
@@ -384,9 +530,9 @@ declare namespace filter {
      */
     function indexed<T, S extends T>(fn: (input: T, index: number, array: Array<T>) => input is S): (array: ReadonlyArray<T>) => Array<S>;
     function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => Array<T>;
-    const lazy: <T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>;
-    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>) & {
-        indexed: true;
+    const lazy: <T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>) & {
+        readonly indexed: true;
     };
 }
 
@@ -437,20 +583,20 @@ declare namespace findIndex {
     } | {
         done: boolean;
         hasNext: boolean;
-        next?: undefined;
+        next?: never;
     }) & {
         single: true;
     };
-    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+    const lazyIndexed: ((fn: PredIndexedOptional<unknown, boolean>) => (value: unknown, index?: number | undefined, array?: unknown[] | undefined) => {
         done: boolean;
         hasNext: boolean;
         next: number;
     } | {
         done: boolean;
         hasNext: boolean;
-        next?: undefined;
+        next?: never;
     }) & {
-        indexed: true;
+        readonly indexed: true;
     } & {
         single: true;
     };
@@ -589,12 +735,12 @@ declare namespace find {
     }) & {
         single: true;
     };
-    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+    const lazyIndexed: ((fn: PredIndexedOptional<unknown, boolean>) => (value: unknown, index?: number | undefined, array?: unknown[] | undefined) => {
         done: boolean;
         hasNext: boolean;
-        next: T;
+        next: unknown;
     }) & {
-        indexed: true;
+        readonly indexed: true;
     } & {
         single: true;
     };
@@ -633,6 +779,60 @@ declare namespace first {
     }
 }
 
+type FirstBy<T extends IterableContainer> = (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined) | T[number];
+/**
+ * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param data an array of items
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending ordeP.
+ * @returns the first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(...rules)(data);
+ * @example
+ *   const max = P.pipe([1,2,3], P.firstBy([P.identity, "desc"])); // => 3;
+ *   const min = P.pipe([1,2,3], P.firstBy([1,2,3])); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
+ *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
+ * @dataLast
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
+/**
+ * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param data an array of items
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending ordeP.
+ * @returns the first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(data, ...rules);
+ * @example
+ *   const max = P.firstBy([1,2,3], [P.identity, "desc"]); // => 3;
+ *   const min = P.firstBy([1,2,3], P.identity); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
+ *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
+ * @dataFirst
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
+
 /**
  * Map each element of an array into an object using a defined callback function and flatten the result.
  * @param array The array to map.
@@ -718,7 +918,7 @@ declare namespace flatMap {
         done: boolean;
         hasNext: boolean;
         next: K | readonly K[];
-        hasMany?: undefined;
+        hasMany?: never;
     };
 }
 
@@ -816,13 +1016,13 @@ declare function forEach<T>(fn: Pred<T, void>): (array: ReadonlyArray<T>) => Arr
 declare namespace forEach {
     function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, void>): Array<T>;
     function indexed<T>(fn: PredIndexed<T, void>): (array: ReadonlyArray<T>) => Array<T>;
-    const lazy: <T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>;
-    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>) & {
-        indexed: true;
+    const lazy: <T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>) & {
+        readonly indexed: true;
     };
 }
 
-interface Strict$6 {
+interface Strict$7 {
     <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: (item: Value) => Key | undefined): StrictOut$2<Value, Key>;
     <Value, Key extends PropertyKey = PropertyKey>(fn: (item: Value) => Key | undefined): (items: ReadonlyArray<Value>) => StrictOut$2<Value, Key>;
     readonly indexed: {
@@ -853,9 +1053,54 @@ declare function groupBy<T>(fn: (item: T) => PropertyKey | undefined): (array: R
 declare namespace groupBy {
     function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, PropertyKey | undefined>): Record<string, NonEmptyArray<T>>;
     function indexed<T>(fn: PredIndexed<T, PropertyKey | undefined>): (array: ReadonlyArray<T>) => Record<string, NonEmptyArray<T>>;
-    const strict: Strict$6;
+    const strict: Strict$7;
 }
 
+type ArrayMinN<T, N extends number> = number extends N ? Array<T> : N extends 0 ? Array<T> : [...ReadonlyTuple<T, N>, ...Array<T>];
+/**
+ * Checks if the given array has at least the defined number of elements, and
+ * refines the output type accordingly so that those indices are defined when
+ * accessing the array even when using typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data the input array
+ * @param minimum the minimum number of elements the array must have
+ * @return true if the array's length is *at least* `minimum`.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T, N extends number>(data: ReadonlyArray<T>, minimum: N): data is ArrayMinN<T, N>;
+/**
+ * Checks if the given array has at least the defined number of elements, and
+ * refines the output type accordingly so that those indices are defined when
+ * accessing the array even when using typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data the input array
+ * @param minimum the minimum number of elements the array must have
+ * @return true if the array's length is *at least* `minimum`.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: N): <T>(data: ReadonlyArray<T>) => data is ArrayMinN<T, N>;
+
 /**
  * Converts a list of objects into an object indexing the objects by the given key.
  * @param array the array
@@ -1049,7 +1294,7 @@ type Enumerable<T> = ArrayLike<T> | Iterable<T>;
 declare function length<T>(items: Enumerable<T>): number;
 declare function length<T>(): (items: Enumerable<T>) => number;
 
-interface Strict$5 {
+interface Strict$6 {
     <T extends IterableContainer, K>(items: T, mapper: Pred<T[number], K>): StrictOut$1<T, K>;
     <T extends IterableContainer, K>(mapper: Pred<T[number], K>): (items: T) => StrictOut$1<T, K>;
     readonly indexed: {
@@ -1101,11 +1346,11 @@ declare function map<T, K>(fn: Pred<T, K>): (array: ReadonlyArray<T>) => Array<K
 declare namespace map {
     function indexed<T, K>(array: ReadonlyArray<T>, fn: PredIndexed<T, K>): Array<K>;
     function indexed<T, K>(fn: PredIndexed<T, K>): (array: ReadonlyArray<T>) => Array<K>;
-    const lazy: <T, K>(fn: PredIndexedOptional<T, K>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<K>;
-    const lazyIndexed: (<T, K>(fn: PredIndexedOptional<T, K>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<K>) & {
-        indexed: true;
+    const lazy: <T, K>(fn: PredIndexedOptional<T, K>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<K>;
+    const lazyIndexed: (<T, K>(fn: PredIndexedOptional<T, K>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<K>) & {
+        readonly indexed: true;
     };
-    const strict: Strict$5;
+    const strict: Strict$6;
 }
 
 /**
@@ -1123,7 +1368,7 @@ declare namespace map {
  * @indexed
  * @category Array
  */
-declare function mapToObj<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T) => [K, V]): Record<K, V>;
+declare function mapToObj<T, K extends PropertyKey, V>(array: ReadonlyArray<T>, fn: (element: T) => [K, V]): Record<K, V>;
 /**
  * Map each element of an array into an object using a defined callback function.
  * @param fn The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries
@@ -1144,10 +1389,10 @@ declare function mapToObj<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn
  * @indexed
  * @category Array
  */
-declare function mapToObj<T, K extends keyof any, V>(fn: (element: T) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
+declare function mapToObj<T, K extends PropertyKey, V>(fn: (element: T) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
 declare namespace mapToObj {
-    function indexed<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T, index: number, array: ReadonlyArray<T>) => [K, V]): Record<K, V>;
-    function indexed<T, K extends keyof any, V>(fn: (element: T, index: number, array: ReadonlyArray<T>) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
+    function indexed<T, K extends PropertyKey, V>(array: ReadonlyArray<T>, fn: (element: T, index: number, array: ReadonlyArray<T>) => [K, V]): Record<K, V>;
+    function indexed<T, K extends PropertyKey, V>(fn: (element: T, index: number, array: ReadonlyArray<T>) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
 }
 
 /**
@@ -1280,6 +1525,83 @@ declare namespace minBy {
     function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => T | undefined;
 }
 
+/**
+ * Retrieves the element that would be at the given index if the array were sorted according to specified rules.
+ * This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*.
+ * Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.
+ *
+ * See also `firstBy` which provides an even more efficient algorithm and a stricter return type,
+ * but only for `index === 0`.
+ * See `takeFirstBy` to get all the elements up to and including `index`.
+ *
+ * @param data - The input array.
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(data, index, ...rules);
+ * @example
+ *   P.nthBy([2,1,4,5,3,], 2, identity); // => 3
+ * @dataFirst
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(data: T, index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): T[number] | undefined;
+/**
+ * Retrieves the element that would be at the given index if the array were sorted according to specified rules.
+ * This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*.
+ * Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.
+ *
+ * See also `firstBy` which provides an even more efficient algorithm and a stricter return type,
+ * but only for `index === 0`.
+ * See `takeFirstBy` to get all the elements up to and including `index`.
+ *
+ * @param data - The input array.
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(index, ...rules)(data);
+ * @example
+ *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity)); // => 3
+ * @dataLast
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => T[number] | undefined;
+
+type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ * Note: In `pipe`, use `only()` form instead of `only`. Otherwise, the
+ * inferred type is lost.
+ * @param array the target array
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @pipeable
+ * @category Array
+ * @dataFirst
+ */
+declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ * Note: In `pipe`, use `only()` form instead of `only`. Otherwise, the
+ * inferred type is lost.
+ * @param array the target array
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @pipeable
+ * @category Array
+ * @dataLast
+ */
+declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
+
 /**
  * Splits a collection into two groups, the first of which contains elements the `predicate` type guard passes, and the second one containing the rest.
  * @param items the items to split
@@ -1361,6 +1683,45 @@ declare function range(start: number, end: number): Array<number>;
  */
 declare function range(end: number): (start: number) => Array<number>;
 
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param data - The input array.
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns - The rank of the item in the sorted array in the range [0..data.length]
+ * @signature
+ *   P.rankBy(data, item, ...rules)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.rankBy(DATA, 0, P.prop('a')) // => 0
+ *   P.rankBy(DATA, 1, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 2, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 3, P.prop('a')) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param data - The input array.
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns - The rank of the item in the sorted array in the range [0..data.length]
+ * @signature
+ *   P.rankBy(item, ...rules)(data)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
+ *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => number;
+
 /**
  * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
  * @param items the array to reduce
@@ -1430,9 +1791,9 @@ declare function reject<T>(fn: Pred<T, boolean>): (items: ReadonlyArray<T>) => A
 declare namespace reject {
     function indexed<T, K>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): Array<K>;
     function indexed<T, K>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => Array<K>;
-    const lazy: <T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>;
-    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>) & {
-        indexed: true;
+    const lazy: <T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>) & {
+        readonly indexed: true;
     };
 }
 
@@ -1534,7 +1895,7 @@ declare function shuffle<T>(items: ReadonlyArray<T>): Array<T>;
  */
 declare function shuffle<T>(): (items: ReadonlyArray<T>) => Array<T>;
 
-interface Strict$4 {
+interface Strict$5 {
     <T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): Sorted<T>;
     <T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => Sorted<T>;
 }
@@ -1581,7 +1942,7 @@ declare function sort<T>(items: ReadonlyArray<T>, cmp: (a: T, b: T) => number):
  */
 declare function sort<T>(cmp: (a: T, b: T) => number): (items: ReadonlyArray<T>) => Array<T>;
 declare namespace sort {
-    const strict: Strict$4;
+    const strict: Strict$5;
 }
 
 declare const ALL_DIRECTIONS: readonly ["asc", "desc"];
@@ -1596,7 +1957,7 @@ type SortPair<T> = readonly [
     direction: Direction
 ];
 type SortRule<T> = SortPair<T> | SortProjection<T>;
-interface Strict$3 {
+interface Strict$4 {
     <T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<SortRule<T[number]>>>): (array: T) => SortedBy<T>;
     <T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<SortRule<T[number]>>>): SortedBy<T>;
 }
@@ -1678,9 +2039,40 @@ declare function sortBy<T>(...sortRules: Readonly<NonEmptyArray<SortRule<T>>>):
  */
 declare function sortBy<T>(array: ReadonlyArray<T>, ...sortRules: Readonly<NonEmptyArray<SortRule<T>>>): Array<T>;
 declare namespace sortBy {
-    const strict: Strict$3;
+    const strict: Strict$4;
 }
 
+/**
+ * Removes elements from an array and, inserts new elements in their place.
+ * @param items the array to splice.
+ * @param start the index from which to start removing elements.
+ * @param deleteCount the number of elements to remove.
+ * @param replacement the elements to insert into the array in place of the deleted elements.
+ * @signature
+ *    P.splice(items, start, deleteCount, replacement)
+ * @example
+ *    P.splice([1,2,3,4,5,6,7,8], 2, 3, []); //=> [1,2,6,7,8]
+ *    P.splice([1,2,3,4,5,6,7,8], 2, 3, [9, 10]); //=> [1,2,9,10,6,7,8]
+ * @dataFirst
+ * @category Array
+ */
+declare function splice<T>(items: ReadonlyArray<T>, start: number, deleteCount: number, replacement: ReadonlyArray<T>): Array<T>;
+/**
+ * Removes elements from an array and, inserts new elements in their place.
+ * @param items the array to splice.
+ * @param start the index from which to start removing elements.
+ * @param deleteCount the number of elements to remove.
+ * @param replacement the elements to insert into the array in place of the deleted elements.
+ * @signature
+ *    P.splice(start, deleteCount, replacement)(items)
+ * @example
+ *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [])) // => [1,2,6,7,8]
+ *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [9, 10])) // => [1,2,9,10,6,7,8]
+ * @dataLast
+ * @category Array
+ */
+declare function splice<T>(start: number, deleteCount: number, replacement: ReadonlyArray<T>): (items: ReadonlyArray<T>) => Array<T>;
+
 /**
  * Splits a given array at a given index.
  * @param array the array to split
@@ -1863,6 +2255,47 @@ declare namespace take {
     function lazy<T>(n: number): (value: T) => LazyResult<T>;
 }
 
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before taking the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria.
+ * Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.takeFirstBy(data, n, ...rules);
+ * @example
+ *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
+ * @dataFirst
+ * @category Array
+ */
+declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before taking the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria.
+ * Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.takeFirstBy(n, ...rules)(data);
+ * @example
+ *   R.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
+ * @dataLast
+ * @category Array
+ */
+declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+
 /**
  * Returns elements from the array until predicate returns false.
  * @param array the array
@@ -1907,7 +2340,7 @@ declare function takeWhile<T>(fn: (item: T) => boolean): (array: ReadonlyArray<T
 declare function uniq<T>(array: ReadonlyArray<T>): Array<T>;
 declare function uniq<T>(): (array: ReadonlyArray<T>) => Array<T>;
 declare namespace uniq {
-    function lazy(): (value: any) => LazyResult<any>;
+    function lazy<T>(): (value: T) => LazyResult<T>;
 }
 
 declare function uniqBy<T, K>(array: ReadonlyArray<T>, transformer: (item: T) => K): Array<T>;
@@ -1933,7 +2366,7 @@ declare function uniqBy<T, K>(array: ReadonlyArray<T>, transformer: (item: T) =>
 declare function uniqBy<T, K>(transformer: (item: T) => K): (array: ReadonlyArray<T>) => Array<T>;
 
 type IsEquals<T> = (a: T, b: T) => boolean;
-declare function _lazy<T>(isEquals: IsEquals<T>): (value: T, index?: number, array?: Array<T>) => LazyResult<T>;
+declare function _lazy<T>(isEquals: IsEquals<T>): (value: T, index?: number, array?: ReadonlyArray<T>) => LazyResult<T>;
 /**
  * Returns a new array containing only one copy of each element in the original list.
  * Elements are compared by custom comparator isEquals.
@@ -1970,11 +2403,11 @@ declare function uniqWith<T>(array: ReadonlyArray<T>, isEquals: IsEquals<T>): Ar
 declare function uniqWith<T>(isEquals: IsEquals<T>): (array: ReadonlyArray<T>) => Array<T>;
 declare namespace uniqWith {
     const lazy: typeof _lazy & {
-        indexed: true;
+        readonly indexed: true;
     };
 }
 
-interface Strict$2 {
+interface Strict$3 {
     <F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zip<F, S>;
     <S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zip<F, S>;
 }
@@ -2021,7 +2454,7 @@ declare function zip<F, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): A
  */
 declare function zip<S>(second: ReadonlyArray<S>): <F>(first: ReadonlyArray<F>) => Array<[F, S]>;
 declare namespace zip {
-    const strict: Strict$2;
+    const strict: Strict$3;
 }
 
 /**
@@ -2050,6 +2483,7 @@ declare function zipObj<F extends number | string | symbol, S>(first: ReadonlyAr
  */
 declare function zipObj<S>(second: ReadonlyArray<S>): <F extends number | string | symbol>(first: ReadonlyArray<F>) => Record<F, S>;
 
+type ZippingFunction<F = unknown, S = unknown, R = unknown> = (f: F, s: S) => R;
 /**
  * Creates a new list from two supplied lists by calling the supplied function
  * with the same-positioned element from each list.
@@ -2063,7 +2497,7 @@ declare function zipObj<S>(second: ReadonlyArray<S>): <F extends number | string
  * @dataFirst
  * @category Array
  */
-declare function zipWith<F, S, R>(first: Array<F>, second: Array<S>, fn: (f: F, s: S) => R): Array<R>;
+declare function zipWith<F, S, R>(first: ReadonlyArray<F>, second: ReadonlyArray<S>, fn: ZippingFunction<F, S, R>): Array<R>;
 /**
  * Creates a new list from two supplied lists by calling the supplied function
  * with the same-positioned element from each list.
@@ -2075,7 +2509,7 @@ declare function zipWith<F, S, R>(first: Array<F>, second: Array<S>, fn: (f: F,
  * @dataLast
  * @category Array
  */
-declare function zipWith<F, S, R>(fn: (f: F, s: S) => R): (first: Array<F>, second: Array<S>) => Array<R>;
+declare function zipWith<F, S, R>(fn: ZippingFunction<F, S, R>): (first: ReadonlyArray<F>, second: ReadonlyArray<S>) => Array<R>;
 /**
  * Creates a new list from two supplied lists by calling the supplied function
  * with the same-positioned element from each list.
@@ -2088,7 +2522,114 @@ declare function zipWith<F, S, R>(fn: (f: F, s: S) => R): (first: Array<F>, seco
  * @dataLast
  * @category Array
  */
-declare function zipWith<F, S, R>(fn: (f: F, s: S) => R, second: Array<S>): (first: Array<F>) => Array<R>;
+declare function zipWith<F, S, R>(fn: ZippingFunction<F, S, R>, second: ReadonlyArray<S>): (first: ReadonlyArray<F>) => Array<R>;
+
+type Case<In, Out, Thru extends In = In> = readonly [
+    when: ((data: In) => boolean) | ((data: In) => data is Thru),
+    then: (data: Thru) => Out
+];
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(...cases)(data);
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.conditional.defaultCase(
+ *         (something) => `Hello something (${JSON.stringify(something)})`,
+ *       ),
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataLast
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(data, ...cases);
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.conditional.defaultCase(
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataFirst
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(data: T, case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+declare namespace conditional {
+    /**
+     * A simplified case that accepts all data. Put this as the last case to
+     * prevent an exception from being thrown when none of the previous cases
+     * match.
+     * If this is not the last case it will short-circuit anything after it.
+     * @param then - You only need to provide the transformer, the predicate is
+     * implicit. @default () => undefined, which is how Lodash and Ramda handle
+     * the final fallback case.
+     */
+    function defaultCase<In>(then?: (data: In) => unknown): readonly [() => boolean, (data: In) => unknown];
+}
 
 /**
  * Creates a data-last pipe function. First function must be always annotated. Other functions are automatically inferred.
@@ -2309,7 +2850,6 @@ declare function purry(fn: any, args: IArguments | ReadonlyArray<any>, lazy?: an
  */
 declare function sleep(timeout: number): Promise<void>;
 
-type DefinitelyArray<T> = Extract<T, Array<any> | ReadonlyArray<any>> extends never ? ReadonlyArray<unknown> : Extract<T, Array<any> | ReadonlyArray<any>>;
 /**
  * A function that checks if the passed parameter is an Array and narrows its type accordingly
  * @param data the variable to check
@@ -2322,9 +2862,8 @@ type DefinitelyArray<T> = Extract<T, Array<any> | ReadonlyArray<any>> extends ne
  *    P.isArray('somethingElse') //=> false
  * @category Guard
  */
-declare function isArray<T>(data: ReadonlyArray<unknown> | T): data is DefinitelyArray<T>;
+declare function isArray<T>(data: ReadonlyArray<unknown> | T): data is NarrowedTo<T, ReadonlyArray<unknown>>;
 
-type DefinitelyBoolean<T> = Extract<T, boolean> extends never ? boolean : Extract<T, boolean> extends any ? boolean : Extract<T, number>;
 /**
  * A function that checks if the passed parameter is a boolean and narrows its type accordingly
  * @param data the variable to check
@@ -2337,7 +2876,7 @@ type DefinitelyBoolean<T> = Extract<T, boolean> extends never ? boolean : Extrac
  *    P.isBoolean('somethingElse') //=> false
  * @category Guard
  */
-declare function isBoolean<T>(data: T | boolean): data is DefinitelyBoolean<T>;
+declare function isBoolean<T>(data: T | boolean): data is NarrowedTo<T, boolean>;
 
 /**
  * A function that checks if the passed parameter is a Date and narrows its type accordingly
@@ -2465,36 +3004,45 @@ declare function isNonNull<T>(data: T | null): data is T;
 declare function isNot<T, S extends T>(predicate: (data: T) => data is S): (data: T) => data is Exclude<T, S>;
 declare function isNot<T>(predicate: (data: T) => any): (data: T) => boolean;
 
-type DefinitelyNumber<T> = Extract<T, number> extends never ? number : Extract<T, number> extends any ? number : Extract<T, number>;
 /**
  * A function that checks if the passed parameter is a number and narrows its type accordingly
  * @param data the variable to check
  * @signature
- *    R.isNumber(data)
+ *    P.isNumber(data)
  * @returns true if the passed input is a number, false otherwise
  * @example
- *    R.isNumber(1) //=> true
- *    R.isNumber('notANumber') //=> false
+ *    P.isNumber(1) //=> true
+ *    P.isNumber('notANumber') //=> false
  * @category Guard
  */
-declare function isNumber<T>(data: T | number): data is DefinitelyNumber<T>;
+declare function isNumber<T>(data: T | number): data is NarrowedTo<T, number>;
 
-type DefinitelyObject<T> = Exclude<Extract<T, object>, Array<any> | Function | ReadonlyArray<any>> extends never ? Record<string, unknown> : Exclude<Extract<T, object>, Array<any> | Function | ReadonlyArray<any>>;
 /**
- * A function that checks if the passed parameter is of type Object and narrows its type accordingly
- * @param data the variable to check
+ * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
+ *
+ * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
+ *
+ * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
+ *
+ * @param data - The variable to check.
+ * @returns - The input type, narrowed to only plain objects.
  * @signature
  *    P.isObject(data)
- * @returns true if the passed input is an Object, Promise, Date or Error, false otherwise
  * @example
+ *    // true
  *    P.isObject({}) //=> true
- *    P.isObject(Promise.resolve("something")) //=> true
- *    P.isObject(new Date()) //=> true
- *    P.isObject(new Error("error")) //=> true
+ *    P.isObject({ a: 123 }) //=> true
+ *
+ *    // false
+ *    P.isObject([]) //=> false
+ *    P.isObject(Promise.resolve("something")) //=> false
+ *    P.isObject(new Date()) //=> false
+ *    P.isObject(new Error("error")) //=> false
  *    P.isObject('somethingElse') //=> false
+ *    P.isObject(null) //=> false
  * @category Guard
  */
-declare function isObject<T>(data: T | object): data is DefinitelyObject<T>;
+declare function isObject<T>(data: Record<PropertyKey, unknown> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
 
 /**
  * A function that checks if the passed parameter is a Promise and narrows its type accordingly
@@ -2510,7 +3058,6 @@ declare function isObject<T>(data: T | object): data is DefinitelyObject<T>;
  */
 declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
 
-type DefinitelyString<T> = Extract<T, string> extends never ? string : Extract<T, string> extends any ? string : Extract<T, string>;
 /**
  * A function that checks if the passed parameter is a string and narrows its type accordingly
  * @param data the variable to check
@@ -2522,7 +3069,20 @@ type DefinitelyString<T> = Extract<T, string> extends never ? string : Extract<T
  *    P.isString(1) //=> false
  * @category Guard
  */
-declare function isString<T>(data: T | string): data is DefinitelyString<T>;
+declare function isString<T>(data: T | string): data is NarrowedTo<T, string>;
+
+/**
+ * A function that checks if the passed parameter is a symbol and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isSymbol(data)
+ * @returns true if the passed input is a symbol, false otherwise
+ * @example
+ *    P.isSymbol(Symbol('foo')) //=> true
+ *    P.isSymbol(1) //=> false
+ * @category Guard
+ */
+declare function isSymbol<T>(data: T | symbol): data is NarrowedTo<T, symbol>;
 
 /**
  * A function that checks if the passed parameter is truthy and narrows its type accordingly
@@ -2541,6 +3101,70 @@ declare function isString<T>(data: T | string): data is DefinitelyString<T>;
  */
 declare function isTruthy<T>(data: T): data is Exclude<T, '' | 0 | false | null | undefined>;
 
+/**
+ * Adds two numbers.
+ * @param value The number.
+ * @param addend The number to add to the value.
+ * @signature
+ *    P.add(value, addend);
+ * @example
+ *    P.add(10, 5) // => 15
+ *    P.add(10, -5) // => 5
+ *    P.reduce([1, 2, 3, 4], P.add, 0) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function add(value: number, addend: number): number;
+/**
+ * Adds two numbers.
+ * @param value The number.
+ * @param addend The number to add to the value.
+ * @signature
+ *    P.add(addend)(value);
+ * @example
+ *    P.add(5)(10) // => 15
+ *    P.add(-5)(10) // => 5
+ *    P.map([1, 2, 3, 4], P.add(1)) // => [2, 3, 4, 5]
+ * @dataLast
+ * @category Number
+ */
+declare function add(addend: number): (value: number) => number;
+
+/**
+ * Rounds up a given number to a specific precision.
+ * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.ceil` instead, as it won't incur the additional library overhead.
+ * @param value The number to round up.
+ * @param precision The precision to round up to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.ceil(value, precision);
+ * @example
+ *    P.ceil(123.9876, 3) // => 123.988
+ *    P.ceil(483.22243, 1) // => 483.3
+ *    P.ceil(8541, -1) // => 8550
+ *    P.ceil(456789, -3) // => 457000
+ * @dataFirst
+ * @category Number
+ */
+declare function ceil(value: number, precision: number): number;
+/**
+ * Rounds up a given number to a specific precision.
+ * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.ceil` instead, as it won't incur the additional library overhead.
+ * @param value The number to round up.
+ * @param precision The precision to round up to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.ceil(precision)(value);
+ * @example
+ *    P.ceil(3)(123.9876) // => 123.988
+ *    P.ceil(1)(483.22243) // => 483.3
+ *    P.ceil(-1)(8541) // => 8550
+ *    P.ceil(-3)(456789) // => 457000
+ * @dataLast
+ * @category Number
+ */
+declare function ceil(precision: number): (value: number) => number;
+
 /**
  * Clamp the given value within the inclusive min and max bounds.
  * @param value the number
@@ -2579,6 +3203,159 @@ declare function clamp(limits: {
     min?: number;
 }): (value: number) => number;
 
+/**
+ * Divides two numbers.
+ * @param value The number.
+ * @param divisor The number to divide the value by.
+ * @signature
+ *    P.divide(value, divisor);
+ * @example
+ *    P.divide(12, 3) // => 4
+ *    P.reduce([1, 2, 3, 4], P.divide, 24) // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function divide(value: number, divisor: number): number;
+/**
+ * Divides two numbers.
+ * @param value The number.
+ * @param divisor The number to divide the value by.
+ * @signature
+ *    P.divide(divisor)(value);
+ * @example
+ *    P.divide(3)(12) // => 4
+ *    P.map([2, 4, 6, 8], P.divide(2)) // => [1, 2, 3, 4]
+ * @dataLast
+ * @category Number
+ */
+declare function divide(divisor: number): (value: number) => number;
+
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ * @param value The number to round down.
+ * @param precision The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(value, precision);
+ * @example
+ *    P.floor(123.9876, 3) // => 123.987
+ *    P.floor(483.22243, 1) // => 483.2
+ *    P.floor(8541, -1) // => 8540
+ *    P.floor(456789, -3) // => 456000
+ * @dataFirst
+ * @category Number
+ */
+declare function floor(value: number, precision: number): number;
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ * @param value The number to round down.
+ * @param precision The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(precision)(value);
+ * @example
+ *    P.floor(3)(123.9876) // => 123.987
+ *    P.floor(1)(483.22243) // => 483.2
+ *    P.floor(-1)(8541) // => 8540
+ *    P.floor(-3)(456789) // => 456000
+ * @dataLast
+ * @category Number
+ */
+declare function floor(precision: number): (value: number) => number;
+
+/**
+ * Multiplies two numbers.
+ * @param value The number.
+ * @param multiplicand The number to multiply the value by.
+ * @signature
+ *    P.multiply(value, multiplicand);
+ * @example
+ *    P.multiply(3, 4) // => 12
+ *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24
+ * @dataFirst
+ * @category Number
+ */
+declare function multiply(value: number, multiplicand: number): number;
+/**
+ * Multiplies two numbers.
+ * @param value The number.
+ * @param multiplicand The number to multiply the value by.
+ * @signature
+ *    P.multiply(multiplicand)(value);
+ * @example
+ *    P.multiply(4)(3) // => 12
+ *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]
+ * @dataLast
+ * @category Number
+ */
+declare function multiply(multiplicand: number): (value: number) => number;
+
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ * @param value The number to round.
+ * @param precision The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(value, precision);
+ * @example
+ *    P.round(123.9876, 3) // => 123.988
+ *    P.round(483.22243, 1) // => 483.2
+ *    P.round(8541, -1) // => 8540
+ *    P.round(456789, -3) // => 457000
+ * @dataFirst
+ * @category Number
+ */
+declare function round(value: number, precision: number): number;
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ * @param value The number to round.
+ * @param precision The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(precision)(value);
+ * @example
+ *    P.round(3)(123.9876) // => 123.988
+ *    P.round(1)(483.22243) // => 483.2
+ *    P.round(-1)(8541) // => 8540
+ *    P.round(-3)(456789) // => 457000
+ * @dataLast
+ * @category Number
+ */
+declare function round(precision: number): (value: number) => number;
+
+/**
+ * Subtracts two numbers.
+ * @param value The number.
+ * @param subtrahend The number to subtract from the value.
+ * @signature
+ *    P.subtract(value, subtrahend);
+ * @example
+ *    P.subtract(10, 5) // => 5
+ *    P.subtract(10, -5) // => 15
+ *    R.reduce([1, 2, 3, 4], P.subtract, 20) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function subtract(value: number, subtrahend: number): number;
+/**
+ * Subtracts two numbers.
+ * @param value The number.
+ * @param subtrahend The number to subtract from the value.
+ * @signature
+ *    P.subtract(subtrahend)(value);
+ * @example
+ *    P.subtract(5)(10) // => 5
+ *    P.subtract(-5)(10) // => 15
+ *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]
+ * @dataLast
+ * @category Number
+ */
+declare function subtract(subtrahend: number): (value: number) => number;
+
 /**
  * Add a new property to an object.
  * @param obj the target object
@@ -2695,7 +3472,7 @@ type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [
     key: Key,
     value: Value
 ];
-type Strict$1 = <Entries extends IterableContainer<Entry>>(entries: Entries) => StrictOut<Entries>;
+type Strict$2 = <Entries extends IterableContainer<Entry>>(entries: Entries) => StrictOut<Entries>;
 type StrictOut<Entries> = Entries extends readonly [infer First, ...infer Tail] ? FromPairsTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromPairsTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromPairsArray<Entries> : 'ERROR: Entries array-like could not be infered';
 type FromPairsTuple<E, Rest> = E extends Entry ? Record<E[0], E[1]> & StrictOut<Rest> : 'ERROR: Array-like contains a non-entry element';
 type FromPairsArray<Entries extends IterableContainer<Entry>> = string extends AllKeys$1<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys$1<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys$1<Entries> ? Record<symbol, Entries[number][1]> : FromPairsArrayWithLiteralKeys<Entries>;
@@ -2724,7 +3501,7 @@ type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey
 declare function fromPairs<V>(pairs: ReadonlyArray<Entry<number, V>>): Record<number, V>;
 declare function fromPairs<V>(pairs: ReadonlyArray<Entry<string, V>>): Record<string, V>;
 declare namespace fromPairs {
-    const strict: Strict$1;
+    const strict: Strict$2;
 }
 
 type Inverted<T extends object> = T[keyof T] extends PropertyKey ? Record<T[keyof T], keyof T> : never;
@@ -2754,6 +3531,14 @@ declare function invert<T extends object>(object: T): Inverted<T>;
  */
 declare function invert<T extends object>(): (object: T) => Inverted<T>;
 
+type Strict$1 = <T extends object>(source: T) => Keys<T>;
+type Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;
+type ArrayKeys<T extends IterableContainer> = {
+    -readonly [Index in keyof T]: Index extends number | string ? `${IsIndexAfterSpread<T, Index> extends true ? number : Index}` : never;
+};
+type IsIndexAfterSpread<T extends IterableContainer, Index extends number | string> = IndicesAfterSpread<T> extends never ? false : Index extends `${IndicesAfterSpread<T>}` ? true : false;
+type IndicesAfterSpread<T extends [] | ReadonlyArray<unknown>, Iterations extends ReadonlyArray<unknown> = []> = T[number] extends never ? never : T extends readonly [unknown, ...infer Tail] ? IndicesAfterSpread<Tail, [unknown, ...Iterations]> : T extends readonly [...infer Head, unknown] ? IndicesAfterSpread<Head, [unknown, ...Iterations]> | Iterations['length'] : Iterations['length'];
+type ObjectKeys<T> = T extends Record<PropertyKey, never> ? [] : Array<`${Exclude<keyof T, symbol>}`>;
 /**
  * Returns a new array containing the keys of the array or object.
  * @param source Either an array or an object
@@ -2773,23 +3558,14 @@ declare function invert<T extends object>(): (object: T) => Inverted<T>;
  * @strict
  * @category Object
  */
-
-type Strict = <T extends object>(source: T) => Keys<T>;
-type Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys$1<T>;
-type ArrayKeys<T extends IterableContainer> = {
-    -readonly [Index in keyof T]: Index extends number | string ? `${IsIndexAfterSpread<T, Index> extends true ? number : Index}` : never;
-};
-type IsIndexAfterSpread<T extends IterableContainer, Index extends number | string> = IndicesAfterSpread<T> extends never ? false : Index extends `${IndicesAfterSpread<T>}` ? true : false;
-type IndicesAfterSpread<T extends [] | ReadonlyArray<unknown>, Iterations extends ReadonlyArray<unknown> = []> = T[number] extends never ? never : T extends readonly [unknown, ...infer Tail] ? IndicesAfterSpread<Tail, [unknown, ...Iterations]> : T extends readonly [...infer Head, unknown] ? IndicesAfterSpread<Head, [unknown, ...Iterations]> | Iterations['length'] : Iterations['length'];
-type ObjectKeys$1<T> = T extends Record<PropertyKey, never> ? [] : Array<`${Exclude<keyof T, symbol>}`>;
 declare function keys(source: ArrayLike<unknown> | Record<PropertyKey, unknown>): Array<string>;
 declare namespace keys {
-    const strict: Strict;
+    const strict: Strict$1;
 }
 
 /**
  * Maps keys of `object` and keeps the same values.
- * @param object the object to map
+ * @param data the object to map
  * @param fn the mapping function
  * @signature
  *    P.mapKeys(object, fn)
@@ -2798,7 +3574,7 @@ declare namespace keys {
  * @dataFirst
  * @category Object
  */
-declare function mapKeys<T, S extends keyof any>(object: T, fn: (key: keyof T, value: T[keyof T]) => S): Record<S, T[keyof T]>;
+declare function mapKeys<T, S extends PropertyKey>(data: T, fn: (key: keyof T, value: Required<T>[keyof T]) => S): Record<S, T[keyof T]>;
 /**
  * Maps keys of `object` and keeps the same values.
  * @param fn the mapping function
@@ -2809,11 +3585,11 @@ declare function mapKeys<T, S extends keyof any>(object: T, fn: (key: keyof T, v
  * @dataLast
  * @category Object
  */
-declare function mapKeys<T, S extends keyof any>(fn: (key: keyof T, value: T[keyof T]) => S): (object: T) => Record<S, T[keyof T]>;
+declare function mapKeys<T, S extends PropertyKey>(fn: (key: keyof T, value: Required<T>[keyof T]) => S): (data: T) => Record<S, T[keyof T]>;
 
 /**
  * Maps values of `object` and keeps the same keys.
- * @param object the object to map
+ * @param data the object to map
  * @param fn the mapping function
  * @signature
  *    P.mapValues(object, fn)
@@ -2822,7 +3598,7 @@ declare function mapKeys<T, S extends keyof any>(fn: (key: keyof T, value: T[key
  * @dataFirst
  * @category Object
  */
-declare function mapValues<T extends Record<PropertyKey, any>, S>(object: T, fn: (value: T[keyof T], key: keyof T) => S): Record<keyof T, S>;
+declare function mapValues<T extends Record<PropertyKey, unknown>, S>(data: T, fn: (value: T[ObjectKeys$1<T>], key: ObjectKeys$1<T>) => S): Record<ObjectKeys$1<T>, S>;
 /**
  * Maps values of `object` and keeps the same keys.
  * @param fn the mapping function
@@ -2833,7 +3609,7 @@ declare function mapValues<T extends Record<PropertyKey, any>, S>(object: T, fn:
  * @dataLast
  * @category Object
  */
-declare function mapValues<T extends Record<PropertyKey, any>, S>(fn: (value: T[keyof T], key: keyof T) => S): (object: T) => Record<keyof T, S>;
+declare function mapValues<T extends Record<PropertyKey, unknown>, S>(fn: (value: T[keyof T], key: keyof T) => S): (data: T) => Record<ObjectKeys$1<T>, S>;
 
 /**
  * Merges two objects. The same as `Object.assign`.
@@ -2893,27 +3669,27 @@ declare function mergeDeep<Destination extends Record<string, unknown>, Source e
 
 /**
  * Returns a partial copy of an object omitting the keys specified.
- * @param data the object
  * @param propNames the property names
  * @signature
- *    P.omit(obj, names);
+ *    P.omit(propNames)(obj);
  * @example
- *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
- * @dataFirst
+ *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }
+ * @dataLast
  * @category Object
  */
-declare function omit<T extends object, K extends keyof T>(data: T, propNames: ReadonlyArray<K>): Omit<T, K>;
+declare function omit<T extends object, K extends keyof T>(propNames: ReadonlyArray<K>): (data: T) => Omit<T, K>;
 /**
  * Returns a partial copy of an object omitting the keys specified.
+ * @param data the object
  * @param propNames the property names
  * @signature
- *    P.omit(propNames)(obj);
+ *    P.omit(obj, names);
  * @example
- *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }
- * @dataLast
+ *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
+ * @dataFirst
  * @category Object
  */
-declare function omit<T extends object, K extends keyof T>(propNames: ReadonlyArray<K>): (data: T) => Omit<T, K>;
+declare function omit<T extends object, K extends keyof T>(data: T, propNames: ReadonlyArray<K>): Omit<T, K>;
 
 /**
  * Returns a partial copy of an object omitting the keys matching predicate.
@@ -3222,13 +3998,12 @@ declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyo
  */
 declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyof T>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;
 
-type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
-type ObjectValues<T extends Record<PropertyKey, unknown>> = Required<T>[ObjectKeys<T>];
-type ObjectEntry<T extends Record<PropertyKey, unknown>> = [
-    ObjectKeys<T>,
-    ObjectValues<T>
-];
-type ObjectEntries<T extends Record<PropertyKey, unknown>> = Array<ObjectEntry<T>>;
+type Pairs<T> = Array<{
+    [K in keyof T]-?: [key: K, value: Required<T>[K]];
+}[keyof T]>;
+interface Strict {
+    <T extends NonNullable<unknown>>(object: T): Pairs<T>;
+}
 /**
  * Returns an array of key/values of the enumerable properties of an object.
  * @param object
@@ -3238,12 +4013,21 @@ type ObjectEntries<T extends Record<PropertyKey, unknown>> = Array<ObjectEntry<T
  * @example
  *    P.toPairs({ a: 1, b: 2, c: 3 }) // => [['a', 1], ['b', 2], ['c', 3]]
  *    P.toPairs.strict({ a: 1 } as const) // => [['a', 1]] typed Array<['a', 1]>
+ *    P.pipe(
+ *      { a: 1, b: 2, c: 3 },
+ *      toPairs,
+ *    ); // => [['a', 1], ['b', 2], ['c', 3]]
+ *    P.pipe(
+ *      { a: 1 } as const,
+ *      toPairs.strict,
+ *    ); // => [['a', 1]] typed Array<['a', 1]>
  * @strict
  * @category Object
+ * @dataFirst
  */
 declare function toPairs<T>(object: Record<string, T>): Array<[string, T]>;
 declare namespace toPairs {
-    function strict<T extends Record<PropertyKey, unknown>>(object: T): ObjectEntries<T>;
+    const strict: Strict;
 }
 
 /**
@@ -3266,13 +4050,18 @@ type Values<T extends object> = T extends [] | ReadonlyArray<unknown> ? Array<T[
 declare function values<T extends object>(source: T): Values<T>;
 
 type Splitter = '.' | '/' | '_' | '-';
-type LastOfArray<T extends any[]> = T extends [...any, infer R] ? R : never;
-type RemoveLastOfArray<T extends any[]> = T extends [...infer F, any] ? F : never;
+type FirstOfString<S extends string> = S extends `${infer F}${string}` ? F : never;
+type RemoveFirstOfString<S extends string> = S extends `${string}${infer R}` ? R : never;
 type IsUpper<S extends string> = S extends Uppercase<S> ? true : false;
 type IsLower<S extends string> = S extends Lowercase<S> ? true : false;
 type SameLetterCase<X extends string, Y extends string> = IsUpper<X> extends IsUpper<Y> ? true : IsLower<X> extends IsLower<Y> ? true : false;
-type FirstOfString<S extends string> = S extends `${infer F}${string}` ? F : never;
-type RemoveFirstOfString<S extends string> = S extends `${string}${infer R}` ? R : never;
+type CapitalizedWords<T extends readonly string[], Accumulator extends string = '', Normalize extends boolean | undefined = false> = T extends readonly [infer F extends string, ...infer R extends string[]] ? CapitalizedWords<R, `${Accumulator}${Capitalize<Normalize extends true ? Lowercase<F> : F>}`, Normalize> : Accumulator;
+type JoinLowercaseWords<T extends readonly string[], Joiner extends string, Accumulator extends string = ''> = T extends readonly [infer F extends string, ...infer R extends string[]] ? Accumulator extends '' ? JoinLowercaseWords<R, Joiner, `${Accumulator}${Lowercase<F>}`> : JoinLowercaseWords<R, Joiner, `${Accumulator}${Joiner}${Lowercase<F>}`> : Accumulator;
+type LastOfArray<T extends any[]> = T extends [...any, infer R] ? R : never;
+type RemoveLastOfArray<T extends any[]> = T extends [...infer F, any] ? F : never;
+interface CaseOptions {
+    normalize?: boolean;
+}
 type SplitByCase<T, Separator extends string = Splitter, Accumulator extends unknown[] = []> = string extends Separator ? string[] : T extends `${infer F}${infer R}` ? [LastOfArray<Accumulator>] extends [never] ? SplitByCase<R, Separator, [F]> : LastOfArray<Accumulator> extends string ? R extends '' ? SplitByCase<R, Separator, [
     ...RemoveLastOfArray<Accumulator>,
     `${LastOfArray<Accumulator>}${F}`
@@ -3287,26 +4076,34 @@ type SplitByCase<T, Separator extends string = Splitter, Accumulator extends unk
     `${LastOfArray<Accumulator>}${F}`,
     FirstOfString<R>
 ]> : SplitByCase<R, Separator, [...Accumulator, F]> : never : Accumulator extends [] ? T extends '' ? [] : string[] : Accumulator;
-type CapitalizedWords<T extends readonly string[], Accumulator extends string = ''> = T extends readonly [infer F extends string, ...infer R extends string[]] ? CapitalizedWords<R, `${Accumulator}${Capitalize<F>}`> : Accumulator;
-type JoinLowercaseWords<T extends readonly string[], Joiner extends string, Accumulator extends string = ''> = T extends readonly [infer F extends string, ...infer R extends string[]] ? Accumulator extends '' ? JoinLowercaseWords<R, Joiner, `${Accumulator}${Lowercase<F>}`> : JoinLowercaseWords<R, Joiner, `${Accumulator}${Joiner}${Lowercase<F>}`> : Accumulator;
-type PascalCase<T> = string extends T ? string : string[] extends T ? string : T extends string ? SplitByCase<T> extends readonly string[] ? CapitalizedWords<SplitByCase<T>> : never : T extends readonly string[] ? CapitalizedWords<T> : never;
-type CamelCase<T> = string extends T ? string : string[] extends T ? string : Uncapitalize<PascalCase<T>>;
 type JoinByCase<T, Joiner extends string> = string extends T ? string : string[] extends T ? string : T extends string ? SplitByCase<T> extends readonly string[] ? JoinLowercaseWords<SplitByCase<T>, Joiner> : never : T extends readonly string[] ? JoinLowercaseWords<T, Joiner> : never;
+type PascalCase<T, Normalize extends boolean | undefined = false> = string extends T ? string : string[] extends T ? string : T extends string ? SplitByCase<T> extends readonly string[] ? CapitalizedWords<SplitByCase<T>, '', Normalize> : never : T extends readonly string[] ? CapitalizedWords<T, '', Normalize> : never;
+type CamelCase<T, Normalize extends boolean | undefined = false> = string extends T ? string : string[] extends T ? string : Uncapitalize<PascalCase<T, Normalize>>;
+type KebabCase<T extends readonly string[] | string, Joiner extends string = '-'> = JoinByCase<T, Joiner>;
+type SnakeCase<T extends readonly string[] | string> = JoinByCase<T, '_'>;
+type TrainCase<T, Normalize extends boolean | undefined = false, Joiner extends string = '-'> = string extends T ? string : string[] extends T ? string : T extends string ? SplitByCase<T> extends readonly string[] ? CapitalizedWords<SplitByCase<T>, Joiner> : never : T extends readonly string[] ? CapitalizedWords<T, Joiner, Normalize> : never;
+type FlatCase<T extends readonly string[] | string, Joiner extends string = ''> = JoinByCase<T, Joiner>;
 
 declare function isUppercase(char?: string): boolean | undefined;
-declare function splitByCase<T extends string>(string_: T): SplitByCase<T>;
-declare function splitByCase<T extends string, Separator extends readonly string[]>(string_: T, separators: Separator): SplitByCase<T, Separator[number]>;
-declare function toUpperFirst<S extends string>(string_: S): Capitalize<S>;
-declare function toLowerFirst<S extends string>(string_: S): Uncapitalize<S>;
+declare function splitByCase<T extends string>(str: T): SplitByCase<T>;
+declare function splitByCase<T extends string, Separator extends readonly string[]>(str: T, separators: Separator): SplitByCase<T, Separator[number]>;
+declare function toUpperFirst<S extends string>(str: S): Capitalize<S>;
+declare function toLowerFirst<S extends string>(str: S): Uncapitalize<S>;
 declare function toPascalCase(): '';
-declare function toPascalCase<T extends readonly string[] | string>(string_?: T): PascalCase<T>;
+declare function toPascalCase<T extends readonly string[] | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: CaseOptions): PascalCase<T, UserCaseOptions['normalize']>;
 declare function toCamelCase(): '';
-declare function toCamelCase<T extends readonly string[] | string>(string_?: T): CamelCase<T>;
+declare function toCamelCase<T extends readonly string[] | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: UserCaseOptions): CamelCase<T, UserCaseOptions['normalize']>;
 declare function toKebabCase(): '';
-declare function toKebabCase<T extends readonly string[] | string>(string_?: T): JoinByCase<T, '-'>;
-declare function toKebabCase<T extends readonly string[] | string, Joiner extends string>(string_: T, joiner: Joiner): JoinByCase<T, Joiner>;
+declare function toKebabCase<T extends readonly string[] | string>(str: T): KebabCase<T>;
+declare function toKebabCase<T extends readonly string[] | string, Joiner extends string>(str: T, joiner: Joiner): KebabCase<T, Joiner>;
 declare function toSnakeCase(): '';
-declare function toSnakeCase<T extends readonly string[] | string>(string_?: T): JoinByCase<T, '_'>;
+declare function toSnakeCase<T extends readonly string[] | string>(str: T): SnakeCase<T>;
+declare function toFlatCase(): '';
+declare function toFlatCase<T extends readonly string[] | string>(str: T): FlatCase<T>;
+declare function toTrainCase(): '';
+declare function toTrainCase<T extends readonly string[] | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: UserCaseOptions): TrainCase<T, UserCaseOptions['normalize']>;
+declare function titleCase(): '';
+declare function titleCase<T extends readonly string[] | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: UserCaseOptions): TrainCase<T, UserCaseOptions['normalize'], ' '>;
 
 /**
  * Returns human readable file size.
@@ -3371,8 +4168,8 @@ type StringToPath<T extends string> = T extends '' ? [] : T extends `[${infer He
  *    P.type(undefined); //=> "Undefined"
  * @category Type
  */
-declare function type(val: any): string;
+declare function type(val: unknown): string;
 
 declare const isBrowser: boolean;
 
-export { type Joined, KEY_CODES, type StringToPath, _setPath, addProp, allPass, anyPass, chunk, clamp, clone, compact, concat, countBy, createPipe, debounce, difference, differenceWith, drop, dropLast, equals, filter, find, findIndex, findLast, findLastIndex, first, flatMap, flatMapToObj, flatten, flattenDeep, forEach, forEachObj, fromPairs, groupBy, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBoolean, isBrowser, isDate, isDefined, isEmpty, isError, isFunction, isNil, isNonNull, isNot, isNumber, isObject, isPromise, isString, isTruthy, isUppercase, join, keys, last, length, map, mapKeys, mapToObj, mapValues, maxBy, meanBy, merge, mergeAll, mergeDeep, minBy, noop, omit, omitBy, once, partition, pathOr, pick, pickBy, pipe, prop, purry, randomString, range, reduce, reject, reverse, sample, set, setPath, shuffle, sleep, slugify, sort, sortBy, splitAt, splitByCase, splitWhen, stringToPath, sumBy, swapIndices, swapProps, take, takeWhile, toCamelCase, toKebabCase, toLowerFirst, toPairs, toPascalCase, toSnakeCase, toUpperFirst, type, uniq, uniqBy, uniqWith, values, zip, zipObj, zipWith };
+export { type Joined, KEY_CODES, type StringToPath, _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, findIndex, findLast, findLastIndex, first, firstBy, flatMap, flatMapToObj, flatten, flattenDeep, floor, forEach, forEachObj, fromPairs, groupBy, hasAtLeast, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBoolean, isBrowser, isDate, isDefined, isEmpty, isError, isFunction, isNil, isNonNull, isNot, isNumber, isObject, isPromise, isString, isSymbol, isTruthy, isUppercase, join, keys, last, length, map, mapKeys, mapToObj, mapValues, maxBy, meanBy, merge, mergeAll, mergeDeep, minBy, multiply, noop, nthBy, omit, omitBy, once, only, partition, pathOr, pick, pickBy, pipe, prop, purry, randomString, range, rankBy, reduce, reject, reverse, round, sample, set, setPath, shuffle, sleep, 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, uniqBy, uniqWith, values, zip, zipObj, zipWith };