@vinicunca/perkakas 0.0.10 → 0.1.0

package/dist/index.d.cts

@@ -1,27 +1,29 @@
+import { 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";
 };
 
 /**
@@ -104,9 +106,9 @@ 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 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 +145,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 +158,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 +169,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 +190,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>;
 }
 
@@ -598,7 +600,7 @@ declare namespace find {
     };
 }
 
-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.
@@ -693,7 +695,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,17 +707,17 @@ 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;
+        next: K | readonly K[];
         hasMany?: undefined;
     };
 }
@@ -820,12 +822,12 @@ declare namespace forEach {
     };
 }
 
-interface Strict$5 {
+interface Strict$6 {
     <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,7 +853,7 @@ 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$6;
 }
 
 /**
@@ -968,9 +970,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 +992,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 +1011,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 +1049,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$5 {
     <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: {
@@ -1103,7 +1105,7 @@ declare namespace map {
     const lazyIndexed: (<T, K>(fn: PredIndexedOptional<T, K>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<K>) & {
         indexed: true;
     };
-    const strict: Strict$4;
+    const strict: Strict$5;
 }
 
 /**
@@ -1532,7 +1534,7 @@ declare function shuffle<T>(items: ReadonlyArray<T>): Array<T>;
  */
 declare function shuffle<T>(): (items: ReadonlyArray<T>) => Array<T>;
 
-interface Strict$3 {
+interface Strict$4 {
     <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 +1581,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$4;
 }
 
 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$3 {
     <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,7 +1678,7 @@ 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$3;
 }
 
 /**
@@ -1972,31 +1974,55 @@ declare namespace uniqWith {
     };
 }
 
+interface Strict$2 {
+    <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$2;
+}
 
 /**
  * Creates a new object from two supplied lists by pairing up equally-positioned items.
@@ -2010,7 +2036,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,7 +2048,7 @@ 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>;
 
 /**
  * Creates a new list from two supplied lists by calling the supplied function
@@ -2116,6 +2142,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.
@@ -2205,7 +2322,7 @@ 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 DefinitelyArray<T>;
 
 type DefinitelyBoolean<T> = Extract<T, boolean> extends never ? boolean : Extract<T, boolean> extends any ? boolean : Extract<T, number>;
 /**
@@ -2273,7 +2390,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 +2405,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 +2419,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
@@ -2422,7 +2539,7 @@ 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>;
 
 /**
  * Clamp the given value within the inclusive min and max bounds.
@@ -2440,8 +2557,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,8 +2575,8 @@ declare function clamp(value: number, limits: {
  * @category Number
  */
 declare function clamp(limits: {
-    min?: number;
     max?: number;
+    min?: number;
 }): (value: number) => number;
 
 /**
@@ -2660,12 +2777,12 @@ declare function invert<T extends object>(): (object: T) => Inverted<T>;
 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;
+    -readonly [Index in keyof T]: Index extends number | string ? `${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 IsIndexAfterSpread<T extends IterableContainer, Index extends number | string> = IndicesAfterSpread<T> extends never ? false : Index extends `${IndicesAfterSpread<T>}` ? true : false;
+type IndicesAfterSpread<T extends [] | ReadonlyArray<unknown>, Iterations extends ReadonlyArray<unknown> = []> = T[number] extends never ? never : T extends readonly [unknown, ...infer Tail] ? IndicesAfterSpread<Tail, [unknown, ...Iterations]> : T extends readonly [...infer Head, unknown] ? IndicesAfterSpread<Head, [unknown, ...Iterations]> | Iterations['length'] : Iterations['length'];
 type ObjectKeys$1<T> = T extends Record<PropertyKey, never> ? [] : Array<`${Exclude<keyof T, symbol>}`>;
-declare function keys(source: Record<PropertyKey, unknown> | ArrayLike<unknown>): Array<string>;
+declare function keys(source: ArrayLike<unknown> | Record<PropertyKey, unknown>): Array<string>;
 declare namespace keys {
     const strict: Strict;
 }
@@ -2743,6 +2860,37 @@ declare function merge<A, B>(a: A, b: B): A & B;
  */
 declare function merge<A, B>(b: B): (a: A) => A & B;
 
+/**
+ * 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<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(destination: Destination, source: Source): MergeDeep<Destination, Source>;
+/**
+ * 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.mergeDeep(source)(destination)
+ * @example
+ *    P.pipe(
+ *      { foo: 'bar', x: 1 },
+ *      P.mergeDeep({ foo: 'baz', y: 2 }),
+ *    );  // => { foo: 'baz', x: 1, y: 2 }
+ * @dataLast
+ * @category Object
+ */
+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 data the object
@@ -2765,7 +2913,7 @@ 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 matching predicate.
@@ -2884,7 +3032,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.
@@ -2945,14 +3093,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
@@ -2977,13 +3117,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
@@ -3004,6 +3144,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
@@ -3114,10 +3262,10 @@ 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 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 IsUpper<S extends string> = S extends Uppercase<S> ? true : false;
@@ -3151,14 +3299,14 @@ declare function splitByCase<T extends string, Separator extends readonly string
 declare function toUpperFirst<S extends string>(string_: S): Capitalize<S>;
 declare function toLowerFirst<S extends string>(string_: 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>(string_?: T): PascalCase<T>;
 declare function toCamelCase(): '';
-declare function toCamelCase<T extends string | readonly string[]>(string_?: T): CamelCase<T>;
+declare function toCamelCase<T extends readonly string[] | string>(string_?: T): CamelCase<T>;
 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>(string_?: T): JoinByCase<T, '-'>;
+declare function toKebabCase<T extends readonly string[] | string, Joiner extends string>(string_: T, joiner: Joiner): JoinByCase<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>(string_?: T): JoinByCase<T, '_'>;
 
 /**
  * Returns human readable file size.
@@ -3227,4 +3375,4 @@ declare function type(val: any): string;
 
 declare const isBrowser: boolean;
 
-export { 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, 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, addProp, allPass, anyPass, chunk, clamp, clone, compact, concat, countBy, createPipe, debounce, difference, differenceWith, drop, dropLast, equals, filter, find, findIndex, findLast, findLastIndex, first, flatMap, flatMapToObj, flatten, flattenDeep, forEach, forEachObj, fromPairs, groupBy, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBoolean, isBrowser, isDate, isDefined, isEmpty, isError, isFunction, isNil, isNonNull, isNot, isNumber, isObject, isPromise, isString, isTruthy, isUppercase, join, keys, last, length, map, mapKeys, mapToObj, mapValues, maxBy, meanBy, merge, mergeAll, mergeDeep, minBy, noop, omit, omitBy, once, partition, pathOr, pick, pickBy, pipe, prop, purry, randomString, range, reduce, reject, reverse, sample, set, setPath, shuffle, sleep, slugify, sort, sortBy, splitAt, splitByCase, splitWhen, stringToPath, sumBy, swapIndices, swapProps, take, takeWhile, toCamelCase, toKebabCase, toLowerFirst, toPairs, toPascalCase, toSnakeCase, toUpperFirst, type, uniq, uniqBy, uniqWith, values, zip, zipObj, zipWith };