@vinicunca/perkakas 0.2.1 → 0.3.1

package/dist/types/aria/index.d.ts

@@ -0,0 +1,2 @@
+export * from './key-codes';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/aria/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/aria/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/types/aria/key-codes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Using event.code is not predictable since each machine may have different output
+ */
+export declare const KEY_CODES: {
+    readonly ALT: "Alt";
+    readonly ARROW_DOWN: "ArrowDown";
+    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 HOME: "Home";
+    readonly KEY_F: "KEY_F";
+    readonly META: "Meta";
+    readonly PAGE_DOWN: "PageDown";
+    readonly PAGE_UP: "PageUp";
+    readonly SHIFT: "Shift";
+    readonly SPACE: "Space";
+    readonly TAB: "Tab";
+};
+//# sourceMappingURL=key-codes.d.ts.map

package/dist/types/aria/key-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-codes.d.ts","sourceRoot":"","sources":["../../../src/aria/key-codes.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;CAqBZ,CAAC"}

package/dist/types/array/all-pass.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Determines whether all predicates returns true for the input data.
+ * @param data The input data for predicates.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.allPass(data, fns)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.allPass(12, fns) // => true
+ *    P.allPass(8, fns) // => false
+ * @dataFirst
+ * @category Array
+ */
+export declare function allPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
+/**
+ * Determines whether all predicates returns true for the input data.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.allPass(fns)(data)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.allPass(fns)(12) // => true
+ *    P.allPass(fns)(8) // => false
+ * @dataLast
+ * @category Array
+ */
+export declare function allPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
+//# sourceMappingURL=all-pass.d.ts.map

package/dist/types/array/all-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all-pass.d.ts","sourceRoot":"","sources":["../../../src/array/all-pass.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,EACP,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,OAAO,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC"}

package/dist/types/array/any-pass.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Determines whether any predicate returns true for the input data.
+ * @param data The input data for predicates.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.anyPass(data, fns)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.anyPass(8, fns) // => true
+ *    P.anyPass(11, fns) // => false
+ * @dataFirst
+ * @category Array
+ */
+export declare function anyPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
+/**
+ * Determines whether any predicate returns true for the input data.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.anyPass(fns)(data)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.anyPass(fns)(8) // => true
+ *    P.anyPass(fns)(11) // => false
+ * @dataLast
+ * @category Array
+ */
+export declare function anyPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
+//# sourceMappingURL=any-pass.d.ts.map

package/dist/types/array/any-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"any-pass.d.ts","sourceRoot":"","sources":["../../../src/array/any-pass.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,EACP,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,OAAO,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC"}

package/dist/types/array/chunk.d.ts

@@ -0,0 +1,29 @@
+import type { IterableContainer, NonEmptyArray } from '../utils/types';
+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
+ * @param size the length of the chunk
+ * @signature
+ *    P.chunk(array, size)
+ * @example
+ *    P.chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]
+ *    P.chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]
+ * @dataFirst
+ * @category Array
+ */
+export declare function chunk<T extends IterableContainer>(array: T, size: number): Chunked<T>;
+/**
+ * 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 size the length of the chunk
+ * @signature
+ *    P.chunk(size)(array)
+ * @example
+ *    P.chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]
+ *    P.chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]
+ * @dataLast
+ * @category Array
+ */
+export declare function chunk<T extends IterableContainer>(size: number): (array: T) => Chunked<T>;
+export {};
+//# sourceMappingURL=chunk.d.ts.map

package/dist/types/array/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../src/array/chunk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIvE,KAAK,OAAO,CAAC,CAAC,SAAS,iBAAiB,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,KAAK,GAC/D,EAAE,GACF,CAAC,SACD,SAAS,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GACrC,SAAS,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,GACnC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACvC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAAC;AAEd;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,IAAI,EAAE,MAAM,GACX,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/compact.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Filter out all falsey values. The values `false`, `null`, `0`, `""`, `undefined`, and `NaN` are falsey.
+ * @param items the array to compact
+ * @signature
+ *    P.compact(array)
+ * @example
+ *    P.compact([0, 1, false, 2, '', 3]) // => [1, 2, 3]
+ * @category Array
+ * @pipeable
+ */
+export declare function compact<T>(items: ReadonlyArray<'' | 0 | T | false | null | undefined>): Array<T>;
+//# sourceMappingURL=compact.d.ts.map

package/dist/types/array/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../src/array/compact.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC,GAC1D,KAAK,CAAC,CAAC,CAAC,CAGV"}

package/dist/types/array/concat.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Combines two arrays.
+ * @param arr1 the first array
+ * @param arr2 the second array
+ * @signature
+ *    P.concat(arr1, arr2);
+ * @example
+ *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
+ * @dataFirst
+ * @category Array
+ */
+export declare function concat<T, K>(arr1: ReadonlyArray<T>, arr2: ReadonlyArray<K>): Array<K | T>;
+/**
+ * Combines two arrays.
+ * @param arr2 the second array
+ * @signature
+ *    P.concat(arr2)(arr1);
+ * @example
+ *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
+ * @dataLast
+ * @category Array
+ */
+export declare function concat<T, K>(arr2: ReadonlyArray<K>): (arr1: ReadonlyArray<T>) => Array<K | T>;
+//# sourceMappingURL=concat.d.ts.map

package/dist/types/array/concat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../src/array/concat.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GACrB,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEhB;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GACrB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC"}

package/dist/types/array/count-by.d.ts

@@ -0,0 +1,20 @@
+import type { Pred, PredIndexed } from '../utils/types';
+/**
+ * Counts how many values of the collection pass the specified predicate.
+ * @param items The input data.
+ * @param fn The predicate.
+ * @signature
+ *    P.countBy(array, fn)
+ * @example
+ *    P.countBy([1, 2, 3, 4, 5], x => x % 2 === 0) // => 2
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function countBy<T>(items: ReadonlyArray<T>, fn: Pred<T, boolean>): number;
+export declare function countBy<T>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => number;
+export declare namespace countBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): number;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => number;
+}
+//# sourceMappingURL=count-by.d.ts.map

package/dist/types/array/count-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by.d.ts","sourceRoot":"","sources":["../../../src/array/count-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAa7E;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,MAAM,CAAC;AAEV,wBAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAiBvC,yBAAiB,OAAO,CAAC;IACvB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,MAAM,CAAC;IACV,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAIxC"}

package/dist/types/array/difference-with.d.ts

@@ -0,0 +1,48 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+type IsEquals<TFirst, TSecond> = (a: TFirst, b: TSecond) => boolean;
+/**
+ * Excludes the values from `other` array.
+ * Elements are compared by custom comparator isEquals.
+ * @param array the source array
+ * @param other the values to exclude
+ * @param isEquals the comparator
+ * @signature
+ *    P.differenceWith(array, other, isEquals)
+ * @example
+ *    P.differenceWith(
+ *      [{a: 1}, {a: 2}, {a: 3}, {a: 4}],
+ *      [{a: 2}, {a: 5}, {a: 3}],
+ *      P.equals,
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+export declare function differenceWith<TFirst, TSecond>(array: ReadonlyArray<TFirst>, other: ReadonlyArray<TSecond>, isEquals: IsEquals<TFirst, TSecond>): Array<TFirst>;
+/**
+ * Excludes the values from `other` array.
+ * Elements are compared by custom comparator isEquals.
+ * @param other the values to exclude
+ * @param isEquals the comparator
+ * @signature
+ *    P.differenceWith(other, isEquals)(array)
+ * @example
+ *    P.differenceWith(
+ *      [{a: 2}, {a: 5}, {a: 3}],
+ *      P.equals,
+ *    )([{a: 1}, {a: 2}, {a: 3}, {a: 4}]) // => [{a: 1}, {a: 4}]
+ *    P.pipe(
+ *      [{a: 1}, {a: 2}, {a: 3}, {a: 4}, {a: 5}, {a: 6}], // only 4 iterations
+ *      P.differenceWith([{a: 2}, {a: 3}], P.equals),
+ *      P.take(2),
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+export declare function differenceWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>, isEquals: IsEquals<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
+export declare namespace differenceWith {
+    function lazy<TFirst, TSecond>(other: Array<TSecond>, isEquals: IsEquals<TFirst, TSecond>): (value: TFirst) => LazyResult<TFirst>;
+}
+export {};
+//# sourceMappingURL=difference-with.d.ts.map

package/dist/types/array/difference-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference-with.d.ts","sourceRoot":"","sources":["../../../src/array/difference-with.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD,KAAK,QAAQ,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;AAEpE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAC5C,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAC5B,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,KAAK,CAAC,MAAM,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAC5C,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;AAenD,yBAAiB,cAAc,CAAC;IAC9B,SAAgB,IAAI,CAAC,MAAM,EAAE,OAAO,EAClC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EACrB,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,WAEpB,MAAM,KAAG,WAAW,MAAM,CAAC,CAa3C;CACF"}

package/dist/types/array/difference.d.ts

@@ -0,0 +1,35 @@
+import { type LazyResult } from '../utils/reduce-lazy';
+/**
+ * Excludes the values from `other` array.
+ * @param array the source array
+ * @param other the values to exclude
+ * @signature
+ *    P.difference(array, other)
+ * @example
+ *    P.difference([1, 2, 3, 4], [2, 5, 3]) // => [1, 4]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+export declare function difference<T>(array: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;
+/**
+ * Excludes the values from `other` array.
+ * @param other the values to exclude
+ * @signature
+ *    P.difference(other)(array)
+ * @example
+ *    P.difference([2, 5, 3])([1, 2, 3, 4]) // => [1, 4]
+ *    P.pipe(
+ *      [1, 2, 3, 4, 5, 6], // only 4 iterations
+ *      P.difference([2, 3]),
+ *      P.take(2)
+ *    ) // => [1, 4]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+export declare function difference<T, K>(other: ReadonlyArray<T>): (array: ReadonlyArray<K>) => Array<T>;
+export declare namespace difference {
+    function lazy<T>(other: Array<T>): (value: T) => LazyResult<T>;
+}
+//# sourceMappingURL=difference.d.ts.map

package/dist/types/array/difference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.d.ts","sourceRoot":"","sources":["../../../src/array/difference.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GACtB,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAWzC,yBAAiB,UAAU,CAAC;IAC1B,SAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,WAEtB,CAAC,KAAG,WAAW,CAAC,CAAC,CAajC;CACF"}

package/dist/types/array/drop-first-by.d.ts

@@ -0,0 +1,39 @@
+import type { NonEmptyArray } from '../utils/types';
+import { type OrderRule } from '../utils/purry-order-rules';
+/**
+ * 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
+ */
+export 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
+ */
+export declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=drop-first-by.d.ts.map

package/dist/types/array/drop-first-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-first-by.d.ts","sourceRoot":"","sources":["../../../src/array/drop-first-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGrE,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,4BAA4B,CAAC;AAEzF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,CAAC,EAAE,MAAM,EACT,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,CAAC,EAAE,MAAM,EACT,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/drop-last-while.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+export 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
+ */
+export declare function dropLastWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=drop-last-while.d.ts.map

package/dist/types/array/drop-last-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-last-while.d.ts","sourceRoot":"","sources":["../../../src/array/drop-last-while.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/drop-last.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Removes last `n` elements from the `array`.
+ * @param array the target array
+ * @param n the number of elements to skip
+ * @signature
+ *    P.dropLast(array, n)
+ * @example
+ *    P.dropLast([1, 2, 3, 4, 5], 2) // => [1, 2, 3]
+ * @dataFirst
+ * @category Array
+ */
+export 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)
+ * @example
+ *    P.dropLast(2)([1, 2, 3, 4, 5]) // => [1, 2, 3]
+ * @dataLast
+ * @category Array
+ */
+export declare function dropLast<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=drop-last.d.ts.map

package/dist/types/array/drop-last.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-last.d.ts","sourceRoot":"","sources":["../../../src/array/drop-last.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAE1E;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/drop-while.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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
+ */
+export 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
+ */
+export declare function dropWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=drop-while.d.ts.map

package/dist/types/array/drop-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-while.d.ts","sourceRoot":"","sources":["../../../src/array/drop-while.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/drop.d.ts

@@ -0,0 +1,31 @@
+import { type LazyResult } from '../utils/reduce-lazy';
+/**
+ * Removes first `n` elements from the `array`.
+ * @param array the target array
+ * @param n the number of elements to skip
+ * @signature
+ *    P.drop(array, n)
+ * @example
+ *    P.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+export 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)
+ * @example
+ *    P.drop(2)([1, 2, 3, 4, 5]) // => [3, 4, 5]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+export declare function drop<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+export declare namespace drop {
+    function lazy<T>(n: number): (value: T) => LazyResult<T>;
+}
+//# sourceMappingURL=drop.d.ts.map

package/dist/types/array/drop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../src/array/drop.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAU1E,yBAAiB,IAAI,CAAC;IACpB,SAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,WAEhB,CAAC,KAAG,WAAW,CAAC,CAAC,CAcjC;CACF"}

package/dist/types/array/filter.d.ts

@@ -0,0 +1,49 @@
+import type { Pred, PredIndexed, PredIndexedOptional } from '../utils/types';
+import { type LazyResult } from '../utils/reduce-lazy';
+/**
+ * Filter the elements of an array that meet the condition specified in a callback function.
+ * @param array The array to filter.
+ * @param fn the callback function.
+ * @signature
+ *    P.filter(array, fn)
+ *    P.filter.indexed(array, fn)
+ * @example
+ *    P.filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]
+ *    P.filter.indexed([1, 2, 3], (x, i, array) => x % 2 === 1) // => [1, 3]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function filter<T, S extends T>(array: ReadonlyArray<T>, fn: (value: T) => value is S): Array<S>;
+export declare function filter<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): Array<T>;
+/**
+ * Filter the elements of an array that meet the condition specified in a callback function.
+ * @param fn the callback function.
+ * @signature
+ *    P.filter(fn)(array)
+ *    P.filter.indexed(fn)(array)
+ * @example
+ *    P.pipe([1, 2, 3], P.filter(x => x % 2 === 1)) // => [1, 3]
+ *    P.pipe([1, 2, 3], P.filter.indexed((x, i) => x % 2 === 1)) // => [1, 3]
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function filter<T, S extends T>(fn: (input: T) => input is S): (array: ReadonlyArray<T>) => Array<S>;
+export declare function filter<T>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => Array<T>;
+export declare namespace filter {
+    function indexed<T, S extends T>(array: ReadonlyArray<T>, fn: (input: T, index: number, array: Array<T>) => input is S): Array<S>;
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): Array<T>;
+    /**
+     * @dataLast
+     */
+    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?: 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;
+    };
+}
+//# sourceMappingURL=filter.d.ts.map

package/dist/types/array/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../src/array/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG7E,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,sBAAsB,CAAC;AAGnE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACnC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,GAC3B,KAAK,CAAC,CAAC,CAAC,CAAC;AACZ,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACnC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,GAC3B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AACzC,wBAAgB,MAAM,CAAC,CAAC,EACtB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAmCzC,yBAAiB,MAAM,CAAC;IACtB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACpC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,GAC3D,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ;;OAEG;IACH,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACpC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,GAC3D,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;IACzC,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;IAKlC,MAAM,IAAI,uIAAe,CAAC;IAC1B,MAAM,WAAW;;KAA6B,CAAC;CACvD"}

package/dist/types/array/find-index.d.ts

@@ -0,0 +1,67 @@
+import type { Pred, PredIndexed, PredIndexedOptional } from '../utils/types';
+/**
+ * Returns the index of the first element in the array where predicate is true, and -1 otherwise.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.findIndex(items, fn)
+ *    P.findIndex.indexed(items, fn)
+ * @example
+ *    P.findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2
+ *    P.findIndex.indexed([1, 3, 4, 6], (n, i) => n % 2 === 0) // => 2
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function findIndex<T>(items: ReadonlyArray<T>, fn: Pred<T, boolean>): number;
+/**
+ * Returns the index of the first element in the array where predicate is true, and -1 otherwise.
+ * @param fn the predicate
+ * @signature
+ *    P.findIndex(fn)(items)
+ *    P.findIndex.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex(n => n % 2 === 0)
+ *    ) // => 2
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex.indexed((n, i) => n % 2 === 0)
+ *    ) // => 2
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function findIndex<T>(fn: Pred<T, boolean>): (items: ReadonlyArray<T>) => number;
+export declare namespace findIndex {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): number;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => number;
+    const lazy: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+        done: boolean;
+        hasNext: boolean;
+        next: number;
+    } | {
+        done: boolean;
+        hasNext: boolean;
+        next?: never;
+    }) & {
+        single: true;
+    };
+    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?: never;
+    }) & {
+        readonly indexed: true;
+    } & {
+        single: true;
+    };
+}
+//# sourceMappingURL=find-index.d.ts.map

package/dist/types/array/find-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-index.d.ts","sourceRoot":"","sources":["../../../src/array/find-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAM7E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,MAAM,CAAC;AAEV;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAqCvC,yBAAiB,SAAS,CAAC;IACzB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,MAAM,CAAC;IACV,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;IAKhC,MAAM,IAAI;;;;;;;;;;KAAyB,CAAC;IAEpC,MAAM,WAAW;;;;;;;;;;;;KAAuC,CAAC;CACjE"}