@vinicunca/perkakas 0.2.1 → 0.3.1

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

@@ -0,0 +1,66 @@
+export * from './all-pass';
+export * from './any-pass';
+export * from './chunk';
+export * from './compact';
+export * from './concat';
+export * from './count-by';
+export * from './difference-with';
+export * from './difference';
+export * from './drop-last';
+export * from './drop';
+export * from './drop-first-by';
+export * from './drop-last-while';
+export * from './drop-while';
+export * from './filter';
+export * from './find-index';
+export * from './find-last-index';
+export * from './find-last';
+export * from './find';
+export * from './first';
+export * from './first-by';
+export * from './flat-map-to-obj';
+export * from './flat-map';
+export * from './flatten-deep';
+export * from './flatten';
+export * from './for-each';
+export * from './group-by';
+export * from './has-at-least';
+export * from './index-by';
+export * from './intersection';
+export * from './intersection-with';
+export * from './join';
+export * from './last';
+export * from './length';
+export * from './map';
+export * from './map-to-obj';
+export * from './max-by';
+export * from './mean-by';
+export * from './merge-all';
+export * from './min-by';
+export * from './nth-by';
+export * from './only';
+export * from './partition';
+export * from './range';
+export * from './rank-by';
+export * from './reduce';
+export * from './reject';
+export * from './reverse';
+export * from './sample';
+export * from './shuffle';
+export * from './sort';
+export * from './sort-by';
+export * from './splice';
+export * from './split-at';
+export * from './split-when';
+export * from './sum-by';
+export * from './swap-indices';
+export * from './take';
+export * from './take-first-by';
+export * from './take-while';
+export * from './uniq';
+export * from './uniq-by';
+export * from './uniq-with';
+export * from './zip';
+export * from './zip-obj';
+export * from './zip-with';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/array/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,OAAO,CAAC;AACtB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}

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

@@ -0,0 +1,54 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+type Comparator<TFirst, TSecond> = (a: TFirst, b: TSecond) => boolean;
+/**
+ * Returns a list of intersecting values based on a custom
+ * comparator function that compares elements of both arrays.
+ * @param array the source array
+ * @param other the second array
+ * @param comparator the custom comparator
+ * @signature
+ *    P.intersectionWith(array, other, comparator)
+ * @example
+ *    P.intersectionWith(
+ *      [
+ *        { id: 1, name: 'Ryan' },
+ *        { id: 3, name: 'Emma' },
+ *      ],
+ *      [3, 5],
+ *      (a, b) => a.id === b,
+ *    ) // => [{ id: 3, name: 'Emma' }]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+export declare function intersectionWith<TFirst, TSecond>(array: ReadonlyArray<TFirst>, other: ReadonlyArray<TSecond>, comparator: Comparator<TFirst, TSecond>): Array<TFirst>;
+/**
+ * Returns a list of intersecting values based on a custom
+ * comparator function that compares elements of both arrays.
+ * @param other the second array
+ * @param comparator the custom comparator
+ * @signature
+ *    P.intersectionWith(other, comparator)(array)
+ * @example
+ *    P.intersectionWith(
+ *      [3, 5],
+ *      (a, b) => a.id === b
+ *      )([
+ *        { id: 1, name: 'Ryan' },
+ *        { id: 3, name: 'Emma' },
+ *      ]); // => [{ id: 3, name: 'Emma' }]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+export declare function intersectionWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>, 
+/**
+ * type inference doesn't work properly for the comparator's first parameter
+ * in data last variant
+ */
+comparator: Comparator<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
+export declare namespace intersectionWith {
+    function lazy<TFirst, TSecond>(other: Array<TSecond>, comparator: Comparator<TFirst, TSecond>): (value: TFirst) => LazyResult<TFirst>;
+}
+export {};
+//# sourceMappingURL=intersection-with.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersection-with.d.ts","sourceRoot":"","sources":["../../../src/array/intersection-with.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD,KAAK,UAAU,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAC9C,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAC5B,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,UAAU,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC,KAAK,CAAC,MAAM,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAC9C,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC;AAC7B;;;GAGG;AACH,UAAU,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;AAenD,yBAAiB,gBAAgB,CAAC;IAChC,SAAgB,IAAI,CAAC,MAAM,EAAE,OAAO,EAClC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EACrB,UAAU,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,WAExB,MAAM,KAAG,WAAW,MAAM,CAAC,CAa3C;CACF"}

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

@@ -0,0 +1,30 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+/**
+ * Returns a list of elements that exist in both array.
+ * @param array the source array
+ * @param other the second array
+ * @signature
+ *    P.intersection(array, other)
+ * @example
+ *    P.intersection([1, 2, 3], [2, 3, 5]) // => [2, 3]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+export declare function intersection<T>(array: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;
+/**
+ * Returns a list of elements that exist in both array.
+ * @param other the second array
+ * @signature
+ *    P.intersection(other)(array)
+ * @example
+ *    P.intersection([2, 3, 5])([1, 2, 3]) // => [2, 3]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+export declare function intersection<T, K>(other: ReadonlyArray<T>): (source: ReadonlyArray<K>) => Array<T>;
+export declare namespace intersection {
+    function lazy<T>(other: Array<T>): (value: T) => LazyResult<T>;
+}
+//# sourceMappingURL=intersection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../../src/array/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GACtB,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GACtB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAW1C,yBAAiB,YAAY,CAAC;IAC5B,SAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,WACtB,CAAC,KAAG,WAAW,CAAC,CAAC,CAcjC;CACF"}

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

@@ -0,0 +1,45 @@
+import type { IterableContainer } from '../utils/types';
+type Joinable = bigint | boolean | null | number | string | undefined;
+export 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 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
+ * every two elements.
+ *
+ * When called on a tuple and with stricter item types (union of literal values,
+ * the result is strictly typed to the tuples shape and it's item types).
+ *
+ * @param data The array to join
+ * @param glue The string to put in between every two elements
+ * @signature
+ *    P.join(data, glue)
+ * @example
+ *    P.join([1,2,3], ",") // => "1,2,3" (typed `string`)
+ *    P.join(['a','b','c'], "") // => "abc" (typed `string`)
+ *    P.join(['hello', 'world'] as const, " ") // => "hello world" (typed `hello world`)
+ * @dataFirst
+ * @category Array
+ */
+export 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
+ * every two elements.
+ *
+ * When called on a tuple and with stricter item types (union of literal values,
+ * the result is strictly typed to the tuples shape and it's item types).
+ *
+ * @param glue The string to put in between every two elements
+ * @signature
+ *    P.join(glue)(data)
+ * @example
+ *    P.pipe([1,2,3], P.join(",")) // => "1,2,3" (typed `string`)
+ *    P.pipe(['a','b','c'], P.join("")) // => "abc" (typed `string`)
+ *    P.pipe(['hello', 'world'] as const, P.join(" ")) // => "hello world" (typed `hello world`)
+ * @dataLast
+ * @category Array
+ */
+export declare function join<T extends [] | ReadonlyArray<Joinable>, Glue extends string>(glue: Glue): (data: T) => Joined<T, Glue>;
+export {};
+//# sourceMappingURL=join.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../src/array/join.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,KAAK,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAEtE,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,iBAAiB,EAAE,IAAI,SAAS,MAAM,IAEjE,CAAC,CAAC,MAAM,CAAC,SAAS,KAAK,GACnB,EAAE,GAEJ,CAAC,SAAS,SAAS,CAAC,QAAQ,CAAC,CAAC,GAC1B,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,GAEhC,CAAC,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC3C,GAAG,eAAe,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,GAE7D,CAAC,SAAS,SAAS,CAAC,GAAG,MAAM,IAAI,EAAE,MAAM,IAAI,CAAC,GAC1C,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,IAAI,GAAG,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,GAE5D,MAAM,CAAC;AAMjB,KAAK,eAAe,CAAC,CAAC,EAAE,QAAQ,IAAI,CAAC,SAAS,QAAQ,GAClD,CAAC,SAAS,IAAI,GAAG,SAAS,GACxB,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,GACzB,CAAC,GACH,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAClB,CAAC,SAAS,EAAE,GAAG,aAAa,CAAC,QAAQ,CAAC,EACtC,IAAI,SAAS,MAAM,EACnB,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAClB,CAAC,SAAS,EAAE,GAAG,aAAa,CAAC,QAAQ,CAAC,EACtC,IAAI,SAAS,MAAM,EACnB,IAAI,EAAE,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC"}

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

@@ -0,0 +1,24 @@
+import type { NonEmptyArray } from '../utils/types';
+/**
+ * Gets the last element of `array`.
+ * Note: In `pipe`, use `last()` form instead of `last`. Otherwise, the inferred type is lost.
+ * @param array the array
+ * @signature
+ *    P.last(array)
+ * @example
+ *    P.last([1, 2, 3]) // => 3
+ *    P.last([]) // => undefined
+ *    P.pipe(
+ *      [1, 2, 4, 8, 16],
+ *      P.filter(x => x > 3),
+ *      P.last(),
+ *      x => x + 1
+ *    ); // => 17
+ *
+ * @category Array
+ * @pipeable
+ */
+export declare function last<T>(array: NonEmptyArray<T>): T;
+export declare function last<T>(array: ReadonlyArray<T>): T | undefined;
+export declare function last<T>(): (array: ReadonlyArray<T>) => T | undefined;
+//# sourceMappingURL=last.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"last.d.ts","sourceRoot":"","sources":["../../../src/array/last.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpD,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;AAChE,wBAAgB,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC"}

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

@@ -0,0 +1,14 @@
+type Enumerable<T> = ArrayLike<T> | Iterable<T>;
+/**
+ * Counts values of the collection or iterable.
+ * @param items The input data.
+ * @signature
+ *    P.length(array)
+ * @example
+ *    P.length([1, 2, 3]) // => 3
+ * @category Array
+ */
+export declare function length<T>(items: Enumerable<T>): number;
+export declare function length<T>(): (items: Enumerable<T>) => number;
+export {};
+//# sourceMappingURL=length.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"length.d.ts","sourceRoot":"","sources":["../../../src/array/length.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AACxD,wBAAgB,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC"}

package/dist/types/array/map-to-obj.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Map each element of an array into an object using a defined callback function.
+ * @param array The array to map.
+ * @param fn The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries
+ * @returns The new mapped object.
+ * @signature
+ *    P.mapToObj(array, fn)
+ *    P.mapToObj.indexed(array, fn)
+ * @example
+ *    P.mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}
+ *    P.mapToObj.indexed([0, 0, 0], (x, i) => [i, i]) // => {0: 0, 1: 1, 2: 2}
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export 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
+ * @returns The new mapped object.
+ * @signature
+ *    P.mapToObj(fn)(array)
+ *    P.mapToObj.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.mapToObj(x => [String(x), x * 2])
+ *    ) // => {1: 2, 2: 4, 3: 6}
+ *    P.pipe(
+ *      [0, 0, 0],
+ *      P.mapToObj.indexed((x, i) => [i, i])
+ *    ) // => {0: 0, 1: 1, 2: 2}
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function mapToObj<T, K extends PropertyKey, V>(fn: (element: T) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
+export declare namespace mapToObj {
+    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>;
+}
+//# sourceMappingURL=map-to-obj.d.ts.map

package/dist/types/array/map-to-obj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-to-obj.d.ts","sourceRoot":"","sources":["../../../src/array/map-to-obj.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,EAClD,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACzB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEhB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,EAClD,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACzB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAsB7C,yBAAiB,QAAQ,CAAC;IACxB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,EACjD,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACjE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEhB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,EACjD,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACjE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAI9C"}

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

@@ -0,0 +1,62 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+import type { IterableContainer, Pred, PredIndexed, PredIndexedOptional } from '../utils/types';
+/**
+ * Map each element of an array using a defined callback function. If the input
+ * array is a tuple use the `strict` variant to maintain it's shape.
+ * @param array The array to map.
+ * @param fn The function mapper.
+ * @returns The new mapped array.
+ * @signature
+ *    P.map(array, fn)
+ *    P.map.indexed(array, fn)
+ *    P.map.strict(array, fn)
+ *    P.map.strict.indexed(array, fn)
+ * @example
+ *    P.map([1, 2, 3], x => x * 2) // => [2, 4, 6], typed number[]
+ *    P.map.indexed([0, 0, 0], (x, i) => i) // => [0, 1, 2], typed number[]
+ *    P.map.strict([0, 0] as const, x => x + 1) // => [1, 1], typed [number, number]
+ *    P.map.strict.indexed([0, 0] as const, (x, i) => x + i) // => [0, 1], typed [number, number]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @strict
+ * @category Array
+ */
+export declare function map<T, K>(array: ReadonlyArray<T>, fn: Pred<T, K>): Array<K>;
+/**
+ * Map each value of an object using a defined callback function.
+ * @param fn the function mapper
+ * @signature
+ *    P.map(fn)(array)
+ *    P.map.indexed(fn)(array)
+ * @example
+ *    P.pipe([0, 1, 2], P.map(x => x * 2)) // => [0, 2, 4]
+ *    P.pipe([0, 0, 0], P.map.indexed((x, i) => i)) // => [0, 1, 2]
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function map<T, K>(fn: Pred<T, K>): (array: ReadonlyArray<T>) => Array<K>;
+interface Strict {
+    <T extends IterableContainer, K>(items: T, mapper: Pred<T[number], K>): StrictOut<T, K>;
+    <T extends IterableContainer, K>(mapper: Pred<T[number], K>): (items: T) => StrictOut<T, K>;
+    readonly indexed: {
+        <T extends IterableContainer, K>(items: T, mapper: PredIndexed<T[number], K>): StrictOut<T, K>;
+        <T extends IterableContainer, K>(mapper: PredIndexed<T[number], K>): (items: T) => StrictOut<T, K>;
+    };
+}
+type StrictOut<T extends IterableContainer, K> = {
+    -readonly [P in keyof T]: K;
+};
+export 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?: 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;
+}
+export {};
+//# sourceMappingURL=map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/array/map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EACV,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAMxB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAE7E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACb,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAkCzC,UAAU,MAAM;IACd,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,EAC7B,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GACzB,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEnB,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,CAC5D,KAAK,EAAE,CAAC,KACL,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAErB,QAAQ,CAAC,OAAO,EAAE;QAChB,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,EAC7B,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GAChC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEnB,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,CACnE,KAAK,EAAE,CAAC,KACL,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KACtB,CAAC;CACH;AAED,KAAK,SAAS,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,IAAI;IAC/C,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC;CAC5B,CAAC;AAEF,yBAAiB,GAAG,CAAC;IACnB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACpB,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACpB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;IAKlC,MAAM,IAAI,oIAAe,CAAC;IAC1B,MAAM,WAAW;;KAA6B,CAAC;IAE/C,MAAM,MAAM,EAAE,MAAY,CAAC;CACnC"}

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

@@ -0,0 +1,39 @@
+import type { PredIndexed } from '../utils/types';
+/**
+ * Returns the max element using the provided predicate.
+ * @param fn the predicate
+ * @signature
+ *    P.maxBy(fn)(array)
+ *    P.maxBy.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.maxBy(x => x.a)
+ *    ) // { a: 5 }
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function maxBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => T | undefined;
+/**
+ * Returns the max element using the provided predicate.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.maxBy(array, fn)
+ *    P.maxBy.indexed(array, fn)
+ * @example
+ *    P.maxBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // { a: 5 }
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function maxBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): T | undefined;
+export declare namespace maxBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => T | undefined;
+}
+//# sourceMappingURL=max-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"max-by.d.ts","sourceRoot":"","sources":["../../../src/array/max-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAoBvE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,GAAG,SAAS,CAAC;AAMjB,yBAAiB,KAAK,CAAC;IACrB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,GAAG,SAAS,CAAC;IACjB,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;CAI/C"}

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

@@ -0,0 +1,39 @@
+import type { PredIndexed } from '../utils/types';
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ * @param fn predicate function
+ * @signature
+ *   P.meanBy(fn)(array)
+ *   P.meanBy.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.meanBy(x => x.a)
+ *    ) // 3
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function meanBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => number;
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ * @param items the array
+ * @param fn predicate function
+ * @signature
+ *   P.meanBy(array, fn)
+ *   P.meanBy.indexed(array, fn)
+ * @example
+ *    P.meanBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // 3
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function meanBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): number;
+export declare namespace meanBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): number;
+    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => number;
+}
+//# sourceMappingURL=mean-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mean-by.d.ts","sourceRoot":"","sources":["../../../src/array/mean-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAmBvE;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,MAAM,CAAC;AAMV,yBAAiB,MAAM,CAAC;IACtB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,MAAM,CAAC;IAEV,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAKxC"}

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

@@ -0,0 +1,16 @@
+/**
+ * Merges a list of objects into a single object.
+ * @param array the array of objects
+ * @signature
+ *    P.mergeAll(objects)
+ * @example
+ *    P.mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }
+ * @category Array
+ */
+export declare function mergeAll<A>(array: readonly [A]): A;
+export declare function mergeAll<A, B>(array: readonly [A, B]): A & B;
+export declare function mergeAll<A, B, C>(array: readonly [A, B, C]): A & B & C;
+export declare function mergeAll<A, B, C, D>(array: readonly [A, B, C, D]): A & B & C & D;
+export declare function mergeAll<A, B, C, D, E>(array: [A, B, C, D, E]): A & B & C & D & E;
+export declare function mergeAll(array: ReadonlyArray<object>): object;
+//# sourceMappingURL=merge-all.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge-all.d.ts","sourceRoot":"","sources":["../../../src/array/merge-all.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC9D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACxE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC3B,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACjB,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACpC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GACrB,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACrB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC"}

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

@@ -0,0 +1,39 @@
+import type { PredIndexed } from '../utils/types';
+/**
+ * Returns the min element using the provided predicate.
+ * @param fn the predicate
+ * @signature
+ *    P.minBy(fn)(array)
+ *    P.minBy.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.minBy(x => x.a)
+ *    ) // { a: 1 }
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function minBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => T | undefined;
+/**
+ * Returns the min element using the provided predicate.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.minBy(array, fn)
+ *    P.minBy.indexed(array, fn)
+ * @example
+ *    P.minBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // { a: 1 }
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function minBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): T | undefined;
+export declare namespace minBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => T | undefined;
+}
+//# sourceMappingURL=min-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"min-by.d.ts","sourceRoot":"","sources":["../../../src/array/min-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAoBvE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,GAAG,SAAS,CAAC;AAMjB,yBAAiB,KAAK,CAAC;IACrB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,GAAG,SAAS,CAAC;IACjB,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;CAI/C"}

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

@@ -0,0 +1,45 @@
+import type { IterableContainer, NonEmptyArray } from '../utils/types';
+import { type OrderRule } from '../utils/purry-order-rules';
+/**
+ * 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
+ */
+export 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
+ */
+export declare function nthBy<T extends IterableContainer>(index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => T[number] | undefined;
+//# sourceMappingURL=nth-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nth-by.d.ts","sourceRoot":"","sources":["../../../src/array/nth-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,iBAAiB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExF,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,4BAA4B,CAAC;AAGzF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,MAAM,EACb,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtD,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,KAAK,EAAE,MAAM,EACb,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtD,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC"}

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

@@ -0,0 +1,36 @@
+import type { IterableContainer } from 'src/utils/types';
+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
+ */
+export 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
+ */
+export declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
+export {};
+//# sourceMappingURL=only.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"only.d.ts","sourceRoot":"","sources":["../../../src/array/only.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIzD,KAAK,IAAI,CAAC,CAAC,SAAS,iBAAiB,IAAI,CAAC,SACtC,SAAS,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAC9C,SAAS,EAAE,GACX,SAAS,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAC9C,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,GAC9C,SAAS,GACT,CAAC,SAAS,SAAS,CAAC,OAAO,CAAC,GAC1B,CAAC,CAAC,MAAM,CAAC,GACT,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAE5B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,iBAAiB,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,iBAAiB,KAAK,CACnD,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KACf,IAAI,CAAC,CAAC,CAAC,CAAC"}