@vinicunca/perkakas 0.0.11 → 0.2.1

package/dist/index.d.cts

@@ -1,27 +1,29 @@
+import { IsAny, ReadonlyTuple, MergeDeep } from 'type-fest';
+
 /**
  * Using event.code is not predictable since each machine may have different output
  */
 declare const KEY_CODES: {
-    readonly TAB: "Tab";
+    readonly ALT: "Alt";
     readonly ARROW_DOWN: "ArrowDown";
-    readonly ARROW_UP: "ArrowUp";
     readonly ARROW_LEFT: "ArrowLeft";
     readonly ARROW_RIGHT: "ArrowRight";
+    readonly ARROW_UP: "ArrowUp";
+    readonly AT: "@";
+    readonly BACKSPACE: "Backspace";
+    readonly CTRL: "Control";
+    readonly DELETE: "Delete";
+    readonly END: "End";
     readonly ENTER: "Enter";
     readonly ESC: "Escape";
-    readonly SPACE: "Space";
-    readonly SHIFT: "Shift";
+    readonly HOME: "Home";
     readonly KEY_F: "KEY_F";
-    readonly CTRL: "Control";
-    readonly ALT: "Alt";
     readonly META: "Meta";
-    readonly AT: "@";
-    readonly DELETE: "Delete";
-    readonly BACKSPACE: "Backspace";
-    readonly HOME: "Home";
-    readonly END: "End";
-    readonly PAGE_UP: "PageUp";
     readonly PAGE_DOWN: "PageDown";
+    readonly PAGE_UP: "PageUp";
+    readonly SHIFT: "Shift";
+    readonly SPACE: "Space";
+    readonly TAB: "Tab";
 };
 
 /**
@@ -90,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
@@ -104,9 +106,17 @@ 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 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 [unknown, ...Array<unknown>] | readonly [...Array<unknown>, unknown] ? NonEmptyArray<NonEmptyArray<T[number]>> : Array<NonEmptyArray<T[number]>>;
+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]>>;
 /**
  * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
  * @param array the array
@@ -143,7 +153,7 @@ declare function chunk<T extends IterableContainer>(size: number): (array: T) =>
  * @category Array
  * @pipeable
  */
-declare function compact<T>(items: ReadonlyArray<T | null | undefined | false | '' | 0>): Array<T>;
+declare function compact<T>(items: ReadonlyArray<'' | 0 | T | false | null | undefined>): Array<T>;
 
 /**
  * Combines two arrays.
@@ -156,7 +166,7 @@ declare function compact<T>(items: ReadonlyArray<T | null | undefined | false |
  * @dataFirst
  * @category Array
  */
-declare function concat<T, K>(arr1: ReadonlyArray<T>, arr2: ReadonlyArray<K>): Array<T | K>;
+declare function concat<T, K>(arr1: ReadonlyArray<T>, arr2: ReadonlyArray<K>): Array<K | T>;
 /**
  * Combines two arrays.
  * @param arr2 the second array
@@ -167,7 +177,7 @@ declare function concat<T, K>(arr1: ReadonlyArray<T>, arr2: ReadonlyArray<K>): A
  * @dataLast
  * @category Array
  */
-declare function concat<T, K>(arr2: ReadonlyArray<K>): (arr1: ReadonlyArray<T>) => Array<T | K>;
+declare function concat<T, K>(arr2: ReadonlyArray<K>): (arr1: ReadonlyArray<T>) => Array<K | T>;
 
 /**
  * Counts how many values of the collection pass the specified predicate.
@@ -188,23 +198,23 @@ declare namespace countBy {
     function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => number;
 }
 
-type LazyResult<T> = LazyEmpty | LazyNext<T> | LazyMany<T>;
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
 interface LazyEmpty {
     done: boolean;
-    hasNext: false;
     hasMany?: false | undefined;
+    hasNext: false;
     next?: undefined;
 }
 interface LazyNext<T> {
     done: boolean;
-    hasNext: true;
     hasMany?: false | undefined;
+    hasNext: true;
     next: T;
 }
 interface LazyMany<T> {
     done: boolean;
-    hasNext: true;
     hasMany: true;
+    hasNext: true;
     next: Array<T>;
 }
 
@@ -302,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)
@@ -327,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)
@@ -341,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.
@@ -382,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;
     };
 }
 
@@ -435,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;
     };
@@ -587,18 +735,18 @@ 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;
     };
 }
 
-type FirstOut<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Pre[0] | Last : T[0] | undefined;
+type FirstOut<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Last | Pre[0] : T[0] | undefined;
 /**
  * Gets the first element of `array`.
  * Note: In `pipe`, use `first()` form instead of `first`. Otherwise, the inferred type is lost.
@@ -631,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.
@@ -693,7 +895,7 @@ declare namespace flatMapToObj {
  * @pipeable
  * @category Array
  */
-declare function flatMap<T, K>(array: ReadonlyArray<T>, fn: (input: T) => K | Array<K>): Array<K>;
+declare function flatMap<T, K>(array: ReadonlyArray<T>, fn: (input: T) => K | ReadonlyArray<K>): Array<K>;
 /**
  * Map each element of an array using a defined callback function and flatten the mapped result.
  * @param fn The function mapper.
@@ -705,18 +907,18 @@ declare function flatMap<T, K>(array: ReadonlyArray<T>, fn: (input: T) => K | Ar
  * @pipeable
  * @category Array
  */
-declare function flatMap<T, K>(fn: (input: T) => K | Array<K>): (array: ReadonlyArray<T>) => Array<K>;
+declare function flatMap<T, K>(fn: (input: T) => K | ReadonlyArray<K>): (array: ReadonlyArray<T>) => Array<K>;
 declare namespace flatMap {
-    function lazy<T, K>(fn: (input: T) => K | Array<K>): (value: T) => {
+    function lazy<T, K>(fn: (input: T) => K | ReadonlyArray<K>): (value: T) => {
         done: boolean;
-        hasNext: boolean;
         hasMany: boolean;
-        next: K[];
+        hasNext: boolean;
+        next: K & any[];
     } | {
         done: boolean;
         hasNext: boolean;
-        next: K;
-        hasMany?: undefined;
+        next: K | readonly K[];
+        hasMany?: never;
     };
 }
 
@@ -814,18 +1016,18 @@ 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$5 {
+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: {
-        <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: PredIndexed<Value, Key | undefined>): StrictOut$2<Value, Key>;
         <Value, Key extends PropertyKey = PropertyKey>(fn: PredIndexed<Value, Key | undefined>): (items: ReadonlyArray<Value>) => StrictOut$2<Value, Key>;
+        <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: PredIndexed<Value, Key | undefined>): StrictOut$2<Value, Key>;
     };
 }
 type StrictOut$2<Value, Key extends PropertyKey = PropertyKey> = string extends Key ? Record<Key, NonEmptyArray<Value>> : number extends Key ? Record<Key, NonEmptyArray<Value>> : symbol extends Key ? Record<Key, NonEmptyArray<Value>> : Partial<Record<Key, NonEmptyArray<Value>>>;
@@ -851,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$5;
+    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
@@ -968,9 +1215,9 @@ declare namespace intersectionWith {
     function lazy<TFirst, TSecond>(other: Array<TSecond>, comparator: Comparator<TFirst, TSecond>): (value: TFirst) => LazyResult<TFirst>;
 }
 
-type Joinable = bigint | boolean | number | string | null | undefined;
+type Joinable = bigint | boolean | null | number | string | undefined;
 type Joined<T extends IterableContainer, Glue extends string> = T[number] extends never ? '' : T extends readonly [Joinable?] ? `${NullishCoalesce<T[0], ''>}` : T extends readonly [infer First, ...infer Tail] ? `${NullishCoalesce<First, ''>}${Glue}${Joined<Tail, Glue>}` : T extends readonly [...infer Head, infer Last] ? `${Joined<Head, Glue>}${Glue}${NullishCoalesce<Last, ''>}` : string;
-type NullishCoalesce<T, Fallback> = T extends Joinable ? T extends undefined | null ? NonNullable<T> | Fallback : T : never;
+type NullishCoalesce<T, Fallback> = T extends Joinable ? T extends null | undefined ? Fallback | NonNullable<T> : T : never;
 /**
  * Joins the elements of the array by: casting them to a string and
  * concatenating them one to the other, with the provided glue string in between
@@ -990,7 +1237,7 @@ type NullishCoalesce<T, Fallback> = T extends Joinable ? T extends undefined | n
  * @dataFirst
  * @category Array
  */
-declare function join<T extends ReadonlyArray<Joinable> | [], Glue extends string>(data: T, glue: Glue): Joined<T, Glue>;
+declare function join<T extends [] | ReadonlyArray<Joinable>, Glue extends string>(data: T, glue: Glue): Joined<T, Glue>;
 /**
  * Joins the elements of the array by: casting them to a string and
  * concatenating them one to the other, with the provided glue string in between
@@ -1009,7 +1256,7 @@ declare function join<T extends ReadonlyArray<Joinable> | [], Glue extends strin
  * @dataLast
  * @category Array
  */
-declare function join<T extends ReadonlyArray<Joinable> | [], Glue extends string>(glue: Glue): (data: T) => Joined<T, Glue>;
+declare function join<T extends [] | ReadonlyArray<Joinable>, Glue extends string>(glue: Glue): (data: T) => Joined<T, Glue>;
 
 /**
  * Gets the last element of `array`.
@@ -1047,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$4 {
+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: {
@@ -1099,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$4;
+    const strict: Strict$6;
 }
 
 /**
@@ -1121,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
@@ -1142,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>;
 }
 
 /**
@@ -1278,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
@@ -1359,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
@@ -1428,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;
     };
 }
 
@@ -1532,7 +1895,7 @@ declare function shuffle<T>(items: ReadonlyArray<T>): Array<T>;
  */
 declare function shuffle<T>(): (items: ReadonlyArray<T>) => Array<T>;
 
-interface Strict$3 {
+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>;
 }
@@ -1579,22 +1942,22 @@ 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$3;
+    const strict: Strict$5;
 }
 
 declare const ALL_DIRECTIONS: readonly ["asc", "desc"];
 type Direction = (typeof ALL_DIRECTIONS)[number];
-type ComparablePrimitive = number | string | boolean;
-type Comparable = ComparablePrimitive | {
+type ComparablePrimitive = boolean | number | string;
+type Comparable = {
     valueOf(): ComparablePrimitive;
-};
+} | ComparablePrimitive;
 type SortProjection<T> = (x: T) => Comparable;
 type SortPair<T> = readonly [
     projector: SortProjection<T>,
     direction: Direction
 ];
-type SortRule<T> = SortProjection<T> | SortPair<T>;
-interface Strict$2 {
+type SortRule<T> = SortPair<T> | SortProjection<T>;
+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>;
 }
@@ -1676,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$2;
+    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
@@ -1861,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
@@ -1905,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>;
@@ -1931,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.
@@ -1968,35 +2403,59 @@ 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$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>;
+}
+type Zip<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [
+    [LeftHead, RightHead],
+    ...Zip<LeftRest, RightRest>
+] : [
+    [LeftHead, Right[number]],
+    ...Zip<LeftRest, Right>
+] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zip<Left, RightRest>] : Array<[Left[number], Right[number]]>;
 /**
  * Creates a new list from two supplied lists by pairing up equally-positioned items.
  * The length of the returned list will match the shortest of the two inputs.
+ *
+ * If the input array are tuples, you can use the strict option
+ * to get another tuple instead of a generic array type.
  * @param first the first input list
  * @param second the second input list
  * @signature
  *   P.zip(first, second)
  * @example
- *   P.zip([1, 2], ['a', 'b']) // => [1, 'a'], [2, 'b']
+ *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']] (type: [number, string][])
+ *   P.zip.strict([1, 2] as const, ['a', 'b'] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
  * @dataFirst
  * @category Array
+ * @strict
  */
 declare function zip<F, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Array<[F, S]>;
 /**
  * Creates a new list from two supplied lists by pairing up equally-positioned items.
  * The length of the returned list will match the shortest of the two inputs.
+ *
+ * If the input array are tuples, you can use the strict option
+ * to get another tuple instead of a generic array type.
  * @param second the second input list
  * @signature
  *   P.zip(second)(first)
  * @example
- *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']] (type: [number, string][])
+ *   P.zip.strict(['a', 'b'] as const)([1, 2] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
  * @dataLast
  * @category Array
+ * @strict
  */
 declare function zip<S>(second: ReadonlyArray<S>): <F>(first: ReadonlyArray<F>) => Array<[F, S]>;
+declare namespace zip {
+    const strict: Strict$3;
+}
 
 /**
  * Creates a new object from two supplied lists by pairing up equally-positioned items.
@@ -2010,7 +2469,7 @@ declare function zip<S>(second: ReadonlyArray<S>): <F>(first: ReadonlyArray<F>)
  * @dataFirst
  * @category Array
  */
-declare function zipObj<F extends string | number | symbol, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Record<F, S>;
+declare function zipObj<F extends number | string | symbol, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Record<F, S>;
 /**
  * Creates a new object from two supplied lists by pairing up equally-positioned items.
  * Key/value pairing is truncated to the length of the shorter of the two lists
@@ -2022,8 +2481,9 @@ declare function zipObj<F extends string | number | symbol, S>(first: ReadonlyAr
  * @dataLast
  * @category Array
  */
-declare function zipObj<S>(second: ReadonlyArray<S>): <F extends string | number | symbol>(first: ReadonlyArray<F>) => Record<F, S>;
+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.
@@ -2037,7 +2497,7 @@ declare function zipObj<S>(second: ReadonlyArray<S>): <F extends string | number
  * @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.
@@ -2049,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.
@@ -2062,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.
@@ -2116,6 +2683,97 @@ declare function noop(): undefined;
  */
 declare function once<T>(fn: () => T): () => T;
 
+interface Debouncer<F extends (...args: any) => unknown, IsNullable extends boolean = true> {
+    /**
+     * The last computed value of the debounced function.
+     */
+    readonly cachedValue: ReturnType<F> | undefined;
+    /**
+     * Invoke the debounced function.
+     * @param args - same as the args for the debounced function.
+     * @returns - the last computed value of the debounced function with the
+     * latest args provided to it. If `timing` does not include `leading` then the
+     * the function would return `undefined` until the first cool-down period is
+     * over, otherwise the function would always return the return type of the
+     * debounced function.
+     */
+    readonly call: (...args: Parameters<F>) => ReturnType<F> | (true extends IsNullable ? undefined : never);
+    /**
+     * Cancels any debounced functions without calling them, effectively resetting
+     * the debouncer to the same state it is when initially created.
+     */
+    readonly cancel: () => void;
+    /**
+     * Similar to `cancel`, but would also trigger the `trailing` invocation if
+     * the debouncer would run one at the end of the cool-down period.
+     */
+    readonly flush: () => ReturnType<F> | undefined;
+    /**
+     * Is `true` when there is an active cool-down period currently debouncing
+     * invocations.
+     */
+    readonly isPending: boolean;
+}
+interface DebounceOptions {
+    readonly maxWaitMs?: number;
+    readonly waitMs?: number;
+}
+/**
+ * Wraps `func` with a debouncer object that "debounces" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).
+ * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).
+ * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).
+ * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.
+ * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.
+ * @param func The function to debounce, the returned `call` function will have
+ * the exact same signature.
+ * @param options An object allowing further customization of the debouncer:
+ * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.
+ *   `leading` would result in the function being invoked at the start of the
+ *   cool-down period; `trailing` would result in the function being invoked at
+ *   the end of the cool-down period (using the args from the last call to the
+ *   debouncer). When `both` is selected the `trailing` invocation would only
+ *   take place if there were more than one call to the debouncer during the
+ *   cool-down period. **DEFAULT: 'trailing'**
+ * - `waitMs?: number`. The length of the cool-down period in milliseconds. The
+ *   debouncer would wait until this amount of time has passed without **any**
+ *   additional calls to the debouncer before triggering the end-of-cool-down-
+ *   period event. When this happens, the function would be invoked (if `timing`
+ *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**
+ * - `maxWaitMs?: number`. The length of time since a debounced call (a call
+ *   that the debouncer prevented from being invoked) was made until it would be
+ *   invoked. Because the debouncer can be continually triggered and thus never
+ *   reach the end of the cool-down period, this allows the function to still
+ *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is
+ *   `'leading'`.
+ * @returns a debouncer object. The main function is `call`. In addition to it
+ * the debouncer comes with the following additional functions and properties:
+ * - `cancel` method to cancel delayed `func` invocations
+ * - `flush` method to end the cool-down period immediately.
+ * - `cachedValue` the latest return value of an invocation (if one occurred).
+ * - `isPending` flag to check if there is an inflight cool-down window.
+ * @signature
+ *   P.debounce(func, options);
+ * @example
+ *   const debouncer = debounce(identity, { timing: 'trailing', waitMs: 1000 });
+ *   const result1 = debouncer.call(1); // => undefined
+ *   const result2 = debouncer.call(2); // => undefined
+ *   // after 1 second
+ *   const result3 = debouncer.call(3); // => 2
+ *   // after 1 second
+ *   debouncer.cachedValue; // => 3
+ * @dataFirst
+ * @category Function
+ * @see https://css-tricks.com/debouncing-throttling-explained-examples/
+ */
+declare function debounce<F extends (...args: any) => any>(func: F, options: {
+    readonly timing?: 'trailing';
+} & DebounceOptions): Debouncer<F>;
+declare function debounce<F extends (...args: any) => any>(func: F, options: ({
+    readonly timing: 'both';
+} & DebounceOptions) | ({
+    readonly timing: 'leading';
+} & Omit<DebounceOptions, 'maxWaitMs'>)): Debouncer<F, false>;
+
 /**
  * Perform left-to-right function composition.
  * @param value The initial value.
@@ -2192,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
@@ -2205,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: T | ReadonlyArray<unknown>): 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
@@ -2220,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
@@ -2273,7 +2929,7 @@ declare namespace isDefined {
  * @category Function
  */
 declare function isEmpty(data: string): data is '';
-declare function isEmpty(data: ReadonlyArray<unknown> | []): data is [];
+declare function isEmpty(data: [] | ReadonlyArray<unknown>): data is [];
 declare function isEmpty<T extends Readonly<Record<PropertyKey, unknown>>>(data: T): data is Record<keyof T, never>;
 
 type DefinitelyError<T> = Extract<T, Error> extends never ? Error : Extract<T, Error>;
@@ -2288,7 +2944,7 @@ type DefinitelyError<T> = Extract<T, Error> extends never ? Error : Extract<T, E
  *    P.isError('somethingElse') //=> false
  * @category Guard
  */
-declare function isError<T>(data: T | Error): data is DefinitelyError<T>;
+declare function isError<T>(data: Error | T): data is DefinitelyError<T>;
 
 type DefinitelyFunction<T> = Extract<T, Function> extends never ? Function : Extract<T, Function>;
 /**
@@ -2302,7 +2958,7 @@ type DefinitelyFunction<T> = Extract<T, Function> extends never ? Function : Ext
  *    P.isFunction('somethingElse') //=> false
  * @category Guard
  */
-declare function isFunction<T>(data: T | Function): data is DefinitelyFunction<T>;
+declare function isFunction<T>(data: Function | T): data is DefinitelyFunction<T>;
 
 /**
  * A function that checks if the passed parameter is Nil (null or undefined) and narrows its type accordingly
@@ -2348,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
@@ -2393,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
@@ -2405,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
@@ -2422,7 +3099,71 @@ declare function isString<T>(data: T | string): data is DefinitelyString<T>;
  *    P.isTruthy('') //=> false
  * @category Guard
  */
-declare function isTruthy<T>(data: T): data is Exclude<T, null | undefined | false | '' | 0>;
+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.
@@ -2440,8 +3181,8 @@ declare function isTruthy<T>(data: T): data is Exclude<T, null | undefined | fal
  * @category Number
  */
 declare function clamp(value: number, limits: {
-    min?: number;
     max?: number;
+    min?: number;
 }): number;
 /**
  * Clamp the given value within the inclusive min and max bounds.
@@ -2458,10 +3199,163 @@ declare function clamp(value: number, limits: {
  * @category Number
  */
 declare function clamp(limits: {
-    min?: number;
     max?: number;
+    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
@@ -2578,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>;
@@ -2607,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;
@@ -2637,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
@@ -2656,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 string | number ? `${IsIndexAfterSpread<T, Index> extends true ? number : Index}` : never;
-};
-type IsIndexAfterSpread<T extends IterableContainer, Index extends string | number> = 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: Record<PropertyKey, unknown> | ArrayLike<unknown>): Array<string>;
+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)
@@ -2681,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
@@ -2692,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)
@@ -2705,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
@@ -2716,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`.
@@ -2743,30 +3636,37 @@ declare function merge<A, B>(a: A, b: B): A & B;
  */
 declare function merge<A, B>(b: B): (a: A) => A & B;
 
-type DeepPartial<T> = {
-    [P in keyof T]?: DeepPartial<T[P]>;
-};
 /**
- * Deep merge two objects
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param destination - The object to merge into. In general, this object would have it's values overridden.
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns - The merged object.
+ * @signature
+ *    P.mergeDeep(destination, source)
+ * @example
+ *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }
+ * @dataFirst
+ * @category Object
  */
-declare function mergeDeep<T>({ mergeArray, original, patch, }: {
-    mergeArray?: boolean;
-    original: T;
-    patch: DeepPartial<T>;
-}): T;
-
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(destination: Destination, source: Source): MergeDeep<Destination, Source>;
 /**
- * Returns a partial copy of an object omitting the keys specified.
- * @param data the object
- * @param propNames the property names
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns - The merged object.
  * @signature
- *    P.omit(obj, names);
+ *    P.mergeDeep(source)(destination)
  * @example
- *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
- * @dataFirst
+ *    P.pipe(
+ *      { foo: 'bar', x: 1 },
+ *      P.mergeDeep({ foo: 'baz', y: 2 }),
+ *    );  // => { foo: 'baz', x: 1, y: 2 }
+ * @dataLast
  * @category Object
  */
-declare function omit<T extends object, K extends keyof T>(data: T, propNames: ReadonlyArray<K>): Omit<T, K>;
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(source: Source): (target: Destination) => MergeDeep<Destination, Source>;
+
 /**
  * Returns a partial copy of an object omitting the keys specified.
  * @param propNames the property names
@@ -2777,7 +3677,19 @@ declare function omit<T extends object, K extends keyof T>(data: T, propNames: R
  * @dataLast
  * @category Object
  */
-declare function omit<K extends PropertyKey>(propNames: ReadonlyArray<K>): <T extends object>(data: T) => 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(obj, names);
+ * @example
+ *    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>(data: T, propNames: ReadonlyArray<K>): Omit<T, K>;
 
 /**
  * Returns a partial copy of an object omitting the keys matching predicate.
@@ -2896,7 +3808,7 @@ declare function pick<T extends object, K extends keyof T>(object: T, names: Rea
  * @dataLast
  * @category Object
  */
-declare function pick<K extends PropertyKey>(names: ReadonlyArray<K>): <T extends Record<PropertyKey, any>>(object: T) => Pick<T, K>;
+declare function pick<T extends object, K extends keyof T>(names: ReadonlyArray<K>): (object: T) => Pick<T, K>;
 
 /**
  * Creates an object composed of the picked `object` properties.
@@ -2957,14 +3869,6 @@ declare function set<T, K extends keyof T>(obj: T, prop: K, value: T[K]): T;
  */
 declare function set<T, K extends keyof T>(prop: K, value: T[K]): (obj: T) => T;
 
-type Path<Obj, Prefix extends Array<PropertyKey> = []> = Obj extends Primitive ? Prefix : Obj extends Array<infer Item> ? Prefix | Path<Item, [...Prefix, number]> : Prefix | PathsOfObject<Obj, Prefix>;
-type PathsOfObject<Obj, Prefix extends Array<PropertyKey>> = {
-    [K in keyof Obj]: Path<Obj[K], [...Prefix, K]>;
-}[keyof Obj];
-type ValueAtPath<Obj, ObjPath extends Array<PropertyKey> = []> = ObjPath extends [] ? Obj : ObjPath extends [infer Head, ...infer Tail] ? Tail extends Array<PropertyKey> ? Head extends keyof Obj ? ValueAtPath<Obj[Head], Tail> : never : never : never;
-type SupportsValueAtPath<Obj, Path extends Array<PropertyKey>, Value> = Value extends ValueAtPath<Obj, Path> ? Obj : never;
-type Primitive = string | number | boolean | null | undefined | symbol;
-
 /**
  * Copied from ts-toolbelt
  * https://github.com/millsp/ts-toolbelt/blob/master/sources/Function/Narrow.ts
@@ -2989,13 +3893,13 @@ type Try<A1, A2, Catch = never> = A1 extends A2 ? A1 : Catch;
 /**
  * Describes types that can be narrowed
  */
-type Narrowable = string | number | bigint | boolean;
+type Narrowable = bigint | boolean | number | string;
 /**
  * @hidden
  */
-type NarrowRaw<A> = (A extends [] ? [] : never) | (A extends Narrowable ? A : never) | {
+type NarrowRaw<A> = {
     [K in keyof A]: A[K] extends (...args: Array<any>) => any ? A[K] : NarrowRaw<A[K]>;
-};
+} | (A extends [] ? [] : never) | (A extends Narrowable ? A : never);
 /**
  * Prevent type widening on generic function parameters
  * @param A to narrow
@@ -3016,6 +3920,14 @@ type NarrowRaw<A> = (A extends [] ? [] : never) | (A extends Narrowable ? A : ne
  */
 type Narrow<A> = Try<A, [], NarrowRaw<A>>;
 
+type Path<Obj, Prefix extends Array<PropertyKey> = []> = Obj extends Primitive ? Prefix : Obj extends Array<infer Item> ? Path<Item, [...Prefix, number]> | Prefix : PathsOfObject<Obj, Prefix> | Prefix;
+type PathsOfObject<Obj, Prefix extends Array<PropertyKey>> = {
+    [K in keyof Obj]: Path<Obj[K], [...Prefix, K]>;
+}[keyof Obj];
+type ValueAtPath<Obj, ObjPath extends Array<PropertyKey> = []> = ObjPath extends [] ? Obj : ObjPath extends [infer Head, ...infer Tail] ? Tail extends Array<PropertyKey> ? Head extends keyof Obj ? ValueAtPath<Obj[Head], Tail> : never : never : never;
+type SupportsValueAtPath<Obj, Path extends Array<PropertyKey>, Value> = Value extends ValueAtPath<Obj, Path> ? Obj : never;
+type Primitive = boolean | null | number | string | symbol | undefined;
+
 /**
  * Sets the value at `path` of `object`. `path` can be an array or a path string.
  * @param object the target method
@@ -3086,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
@@ -3102,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;
 }
 
 /**
@@ -3126,17 +4046,22 @@ declare namespace toPairs {
  * @pipeable
  * @category Object
  */
-type Values<T extends object> = T extends ReadonlyArray<unknown> | [] ? Array<T[number]> : Array<T[keyof T]>;
+type Values<T extends object> = T extends [] | ReadonlyArray<unknown> ? Array<T[number]> : Array<T[keyof 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 Splitter = '.' | '/' | '_' | '-';
+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}`
@@ -3151,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 string | readonly 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 string | readonly 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 string | readonly string[]>(string_?: T): JoinByCase<T, '-'>;
-declare function toKebabCase<T extends string | readonly 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 string | readonly 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.
@@ -3235,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 { DeepPartial, Joined, KEY_CODES, StringToPath, _setPath, addProp, allPass, anyPass, chunk, clamp, clone, compact, concat, countBy, createPipe, 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 };