@vinicunca/perkakas 0.2.1 → 0.3.1

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

@@ -0,0 +1,60 @@
+import type { PredIndexed } from '../utils/types';
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` type guard passes, and the second one containing the rest.
+ * @param items the items to split
+ * @param predicate a type guard function to invoke on every item
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(array, fn)
+ * @example
+ *    P.partition(['one', 'two', 'forty two'], x => x.length === 3) // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function partition<T, S extends T>(items: ReadonlyArray<T>, predicate: (item: T) => item is S): [Array<S>, Array<Exclude<T, S>>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` function matches, and the second one containing the rest.
+ * @param items the items to split
+ * @param predicate the function invoked per iteration
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(array, fn)
+ * @example
+ *    P.partition(['one', 'two', 'forty two'], x => x.length === 3) // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function partition<T>(items: ReadonlyArray<T>, predicate: (item: T) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` type guard passes, and the second one containing the rest.
+ * @param predicate the grouping function
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(fn)(array)
+ * @example
+ *    P.pipe(['one', 'two', 'forty two'], P.partition(x => x.length === 3)) // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function partition<T, S extends T>(predicate: (item: T) => item is S): (array: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` function matches, and the second one containing the rest.
+ * @param predicate the grouping function
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(fn)(array)
+ * @example
+ *    P.pipe(['one', 'two', 'forty two'], P.partition(x => x.length === 3)) // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function partition<T>(predicate: (item: T) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+export declare namespace partition {
+    function indexed<T>(array: ReadonlyArray<T>, predicate: PredIndexed<T, boolean>): [Array<T>, Array<T>];
+    function indexed<T>(predicate: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+}
+//# sourceMappingURL=partition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../src/array/partition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAIvE;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACtC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,GAChC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAExB;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACtC,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,GAChC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAiBrD,yBAAiB,SAAS,CAAC;IACzB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GACjC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxB,SAAgB,OAAO,CAAC,CAAC,EACvB,SAAS,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GACjC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;CAItD"}

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

@@ -0,0 +1,22 @@
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ * @param start the start number
+ * @param end the end number
+ * @signature range(start, end)
+ * @example
+ *    P.range(1, 5) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+export declare function range(start: number, end: number): Array<number>;
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ * @param end the end number
+ * @signature range(end)(start)
+ * @example
+ *    P.range(5)(1) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+export declare function range(end: number): (start: number) => Array<number>;
+//# sourceMappingURL=range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../../src/array/range.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC"}

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

@@ -0,0 +1,41 @@
+import type { NonEmptyArray } from '../utils/types';
+import { type OrderRule } from '../utils/purry-order-rules';
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param data - The input array.
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns - The rank of the item in the sorted array in the range [0..data.length]
+ * @signature
+ *   P.rankBy(data, item, ...rules)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.rankBy(DATA, 0, P.prop('a')) // => 0
+ *   P.rankBy(DATA, 1, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 2, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 3, P.prop('a')) // => 2
+ * @dataFirst
+ * @category Array
+ */
+export declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param data - The input array.
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns - The rank of the item in the sorted array in the range [0..data.length]
+ * @signature
+ *   P.rankBy(item, ...rules)(data)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
+ *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
+ * @dataLast
+ * @category Array
+ */
+export declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => number;
+//# sourceMappingURL=rank-by.d.ts.map

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+ * @param items the array to reduce
+ * @param fn the callback function
+ * @param initialValue the initial value to use as an accumulator value in the callback function
+ * @signature
+ *    P.reduce(items, fn, initialValue)
+ *    P.reduce.indexed(items, fn, initialValue)
+ * @example
+ *    P.reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115
+ *    P.reduce.indexed([1, 2, 3, 4, 5], (acc, x, i, array) => acc + x, 100) // => 115
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function reduce<T, K>(items: ReadonlyArray<T>, fn: (acc: K, item: T) => K, initialValue: K): K;
+/**
+ * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+ * @param fn the callback function
+ * @param initialValue the initial value to use as an accumulator value in the callback function
+ * @signature
+ *    P.reduce(fn, initialValue)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 5], P.reduce((acc, x) => acc + x, 100)) // => 115
+ *    P.pipe([1, 2, 3, 4, 5], P.reduce.indexed((acc, x, i, array) => acc + x, 100)) // => 115
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function reduce<T, K>(fn: (acc: K, item: T) => K, initialValue: K): (items: ReadonlyArray<T>) => K;
+export declare namespace reduce {
+    function indexed<T, K>(array: ReadonlyArray<T>, fn: (acc: K, item: T, index: number, items: Array<T>) => K, initialValue: K): K;
+    function indexed<T, K>(fn: (acc: K, item: T, index: number, items: Array<T>) => K, initialValue: K): (array: ReadonlyArray<T>) => K;
+}
+//# sourceMappingURL=reduce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reduce.d.ts","sourceRoot":"","sources":["../../../src/array/reduce.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC1B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC;AAEL;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC1B,YAAY,EAAE,CAAC,GACd,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAmBlC,yBAAiB,MAAM,CAAC;IACtB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,EAC1D,YAAY,EAAE,CAAC,GACd,CAAC,CAAC;IACL,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,EAC1D,YAAY,EAAE,CAAC,GACd,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;CAInC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"reject.d.ts","sourceRoot":"","sources":["../../../src/array/reject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAM7E;;;;;;;;;;;;;;GAcG;AACH,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,EACtB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAuCzC,yBAAiB,MAAM,CAAC;IACtB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,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/reverse.d.ts

@@ -0,0 +1,25 @@
+type Reverse<T extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown> = []> = ReturnType<T extends IsNoTuple<T> ? () => [...T, ...R] : T extends readonly [infer F, ...infer L] ? () => Reverse<L, [F, ...R]> : () => R>;
+type IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;
+/**
+ * Reverses array.
+ * @param array the array
+ * @signature
+ *    P.reverse(arr);
+ * @example
+ *    P.reverse([1, 2, 3]) // [3, 2, 1]
+ * @dataFirst
+ * @category Array
+ */
+export declare function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;
+/**
+ * Reverses array.
+ * @signature
+ *    P.reverse()(array);
+ * @example
+ *    P.reverse()([1, 2, 3]) // [3, 2, 1]
+ * @dataLast
+ * @category Array
+ */
+export declare function reverse<T extends ReadonlyArray<unknown>>(): (array: T) => Reverse<T>;
+export {};
+//# sourceMappingURL=reverse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.d.ts","sourceRoot":"","sources":["../../../src/array/reverse.ts"],"names":[],"mappings":"AAEA,KAAK,OAAO,CACV,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAChC,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,IACnC,UAAU,CACd,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,GAClB,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,GAClB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GACtC,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAC3B,MAAM,CAAC,CACZ,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;AAEhF;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhF;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,KAAK,CAC3D,KAAK,EAAE,CAAC,KACL,OAAO,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,54 @@
+import type { IterableContainer } from '../utils/types';
+type Sampled<T extends IterableContainer, N extends number> = number extends N ? SampledGeneric<T> : undefined extends T[N] ? T : SampledLiteral<T, N>;
+type SampledGeneric<T extends IterableContainer> = T[number] extends never ? T : T extends readonly [infer First, ...infer Rest] ? [First, ...SampledGeneric<Rest>] | SampledGeneric<Rest> : Array<T[number]>;
+type SampledLiteral<T extends IterableContainer, N extends number, Iteration extends Array<unknown> = []> = Iteration['length'] extends N ? [] : T extends readonly [infer First, ...infer Tail] ? [
+    First | Tail[number],
+    ...SampledLiteral<Tail, N, [unknown, ...Iteration]>
+] : T extends readonly [...infer Head, infer Last] ? [...SampledLiteral<Head, N, [unknown, ...Iteration]>, Last] : [T[number], ...SampledLiteral<T, N, [unknown, ...Iteration]>] | SampledLiteral<T, N, [unknown, ...Iteration]>;
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param data the array
+ * @param sampleSize the number of elements to take
+ * @signature
+ *    P.sample(array, sampleSize)
+ * @example
+ *    P.sample(["hello", "world"], 1); // => ["hello"] // typed string[]
+ *    P.sample(["hello", "world"] as const, 1); // => ["world"] // typed ["hello" | "world"]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+export declare function sample<T extends IterableContainer, N extends number = number>(data: T, sampleSize: N): Sampled<T, N>;
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param sampleSize the number of elements to take
+ * @signature
+ *    P.sample(sampleSize)(array)
+ * @example
+ *    P.sample(1)(["hello", "world"]); // => ["hello"] // typed string[]
+ *    P.sample(1)(["hello", "world"] as const); // => ["world"] // typed ["hello" | "world"]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+export declare function sample<T extends IterableContainer, N extends number = number>(sampleSize: N): (data: T) => Sampled<T, N>;
+export {};
+//# sourceMappingURL=sample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../../../src/array/sample.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,KAAK,OAAO,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,MAAM,IAExD,MAAM,SAAS,CAAC,GACZ,cAAc,CAAC,CAAC,CAAC,GAGnB,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAClB,CAAC,GACD,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE7B,KAAK,cAAc,CAAC,CAAC,SAAS,iBAAiB,IAE7C,CAAC,CAAC,MAAM,CAAC,SAAS,KAAK,GACnB,CAAC,GAGH,CAAC,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC3C,CAAC,KAAK,EAAE,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,GAGzD,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEvB,KAAK,cAAc,CACjB,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,IAGrC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,GACzB,EAAE,GAGJ,CAAC,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC3C;IACE,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;IACpB,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC;CACpD,GACD,CAAC,SAAS,SAAS,CAAC,GAAG,MAAM,IAAI,EAAE,MAAM,IAAI,CAAC,GAC5C,CAAC,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,GAI3D,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,GAC7D,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC3E,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,CAAC,GACZ,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC3E,UAAU,EAAE,CAAC,GACZ,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,22 @@
+/**
+ * Shuffles the input array, returning a new array with the same elements in a random order.
+ * @param items the array to shuffle
+ * @signature
+ *    P.shuffle(array)
+ * @example
+ *    P.shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]
+ * @category Array
+ * @dataFirst
+ */
+export declare function shuffle<T>(items: ReadonlyArray<T>): Array<T>;
+/**
+ * Shuffles the input array, returning a new array with the same elements in a random order.
+ * @signature
+ *    P.shuffle()(array)
+ * @example
+ *    P.pipe([4, 2, 7, 5], P.shuffle()) // => [7, 5, 4, 2]
+ * @category Array
+ * @dataLast
+ */
+export declare function shuffle<T>(): (items: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=shuffle.d.ts.map

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

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

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

@@ -0,0 +1,99 @@
+import type { IterableContainer, NonEmptyArray } from '../utils/types';
+declare const ALL_DIRECTIONS: readonly ["asc", "desc"];
+type Direction = (typeof ALL_DIRECTIONS)[number];
+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> = SortPair<T> | SortProjection<T>;
+/**
+ * Sorts the list according to the supplied functions and directions.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * Directions are applied to functions in order and default to ascending if not specified.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param sortRules main sort rule
+ * @signature
+ *    P.sortBy(sortRule, ...additionalSortRules)(array)
+ *    P.sortBy.strict(sortRule, ...additionalSortRules)(array)
+ * @example
+ *    P.pipe(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      P.sortBy(x => x.a)
+ *    ) // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }] typed Array<{a:number}>
+ *    P.pipe(
+ *      [{ a: 1 }, { a: 3 }] as const,
+ *      P.sortBy.strict(x => x.a)
+ *    ) // => [{ a: 1 }, { a: 3 }] typed [{a: 1 | 3}, {a: 1 | 3}]
+ * @dataLast
+ * @category Array
+ * @strict
+ */
+export declare function sortBy<T>(...sortRules: Readonly<NonEmptyArray<SortRule<T>>>): (array: ReadonlyArray<T>) => Array<T>;
+/**
+ * Sorts the list according to the supplied functions and directions.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * Directions are applied to functions in order and default to ascending if not specified.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param array the array to sort
+ * @param sortRules main sort rule
+ * @signature
+ *    P.sortBy(array, sortRule, ...additionalSortRules)
+ *    P.sortBy.strict(array, sortRule, ...additionalSortRules)
+ * @example
+ *    P.sortBy(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      x => x.a
+ *    )
+ *    // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }] typed Array<{a:number}>
+ *
+ *    P.sortBy(
+ *     [
+ *       {color: 'red', weight: 2},
+ *       {color: 'blue', weight: 3},
+ *       {color: 'green', weight: 1},
+ *       {color: 'purple', weight: 1},
+ *     ],
+ *      [x => x.weight, 'asc'], x => x.color
+ *    )
+ *    // =>
+ *    //   {color: 'green', weight: 1},
+ *    //   {color: 'purple', weight: 1},
+ *    //   {color: 'red', weight: 2},
+ *    //   {color: 'blue', weight: 3},
+ *    // typed Array<{color: string, weight: number}>
+ *
+ *    P.sortBy.strict(
+ *      [{ a: 1 }, { a: 3 }] as const,
+ *      x => x.a
+ *    )
+ *    // => [{ a: 1 }, { a: 3 }] typed [{a: 1 | 3}, {a: 1 | 3}]
+ * @dataFirst
+ * @category Array
+ * @strict
+ */
+export declare function sortBy<T>(array: ReadonlyArray<T>, ...sortRules: Readonly<NonEmptyArray<SortRule<T>>>): Array<T>;
+interface Strict {
+    <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>;
+}
+type SortedBy<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+export declare namespace sortBy {
+    const strict: Strict;
+}
+export {};
+//# sourceMappingURL=sort-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort-by.d.ts","sourceRoot":"","sources":["../../../src/array/sort-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIvE,QAAA,MAAM,cAAc,0BAA2B,CAAC;AAChD,KAAK,SAAS,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,KAAK,mBAAmB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AACrD,KAAK,UAAU,GAAG;IAAE,OAAO,IAAI,mBAAmB,CAAA;CAAE,GAAG,mBAAmB,CAAC;AAC3E,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,UAAU,CAAC;AAC9C,KAAK,QAAQ,CAAC,CAAC,IAAI,SAAS;IAC1B,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;IAC5B,SAAS,EAAE,SAAS;CACrB,CAAC;AACF,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;AAOnD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,GAAG,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,GACjD,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,GAAG,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,GACjD,KAAK,CAAC,CAAC,CAAC,CAAC;AA8EZ,UAAU,MAAM;IACd,CAAC,CAAC,SAAS,iBAAiB,EAC1B,GAAG,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACzD,CAAC,KAAK,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE7B,CAAC,CAAC,SAAS,iBAAiB,EAC1B,KAAK,EAAE,CAAC,EACR,GAAG,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACzD,QAAQ,CAAC,CAAC,CAAC,CAAC;CAChB;AAED,KAAK,QAAQ,CAAC,CAAC,SAAS,iBAAiB,IAAI;IAC3C,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;CACpC,CAAC;AAEF,yBAAiB,MAAM,CAAC;IACf,MAAM,MAAM,EAAE,MAAe,CAAC;CACtC"}

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

@@ -0,0 +1,52 @@
+import type { IterableContainer } from '../utils/types';
+/**
+ * Sorts an array. The comparator function should accept two values at a time and return a negative number if the first value is smaller, a positive number if it's larger, and zero if they are equal.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param items the array to sort
+ * @param cmp the comparator function
+ * @signature
+ *    P.sort(items, cmp)
+ *    P.sort.strict(items, cmp)
+ * @example
+ *    P.sort([4, 2, 7, 5], (a, b) => a - b) // => [2, 4, 5, 7] typed Array<number>
+ *    P.sort.strict([4, 2] as [number, number], (a, b) => a - b) // [2, 4] typed [number, number]
+ * @dataFirst
+ * @category Array
+ * @strict
+ */
+export declare function sort<T>(items: ReadonlyArray<T>, cmp: (a: T, b: T) => number): Array<T>;
+/**
+ * Sorts an array. The comparator function should accept two values at a time and return a negative number if the first value is smaller, a positive number if it's larger, and zero if they are equal.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param cmp the comparator function
+ * @signature
+ *    P.sort(cmp)(items)
+ *    P.sort.strict(cmp)(items)
+ * @example
+ *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7] typed Array<number>
+ *    P.pipe([4, 2] as [number, number], P.sort.strict((a, b) => a - b)) // => [2, 4] typed [number, number]
+ * @dataLast
+ * @category Array
+ * @strict
+ */
+export declare function sort<T>(cmp: (a: T, b: T) => number): (items: ReadonlyArray<T>) => Array<T>;
+interface Strict {
+    <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>;
+}
+type Sorted<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+export declare namespace sort {
+    const strict: Strict;
+}
+export {};
+//# sourceMappingURL=sort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../src/array/sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAC1B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAYzC,UAAU,MAAM;IACd,CAAC,CAAC,SAAS,iBAAiB,EAC1B,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,MAAM,GAC1C,MAAM,CAAC,CAAC,CAAC,CAAC;IAEb,CAAC,CAAC,SAAS,iBAAiB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,MAAM,GAAG,CAC1E,KAAK,EAAE,CAAC,KACL,MAAM,CAAC,CAAC,CAAC,CAAC;CAChB;AAED,KAAK,MAAM,CAAC,CAAC,SAAS,iBAAiB,IAAI;IACzC,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;CACpC,CAAC;AAEF,yBAAiB,IAAI,CAAC;IACb,MAAM,MAAM,EAAE,MAAa,CAAC;CACpC"}

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

@@ -0,0 +1,31 @@
+/**
+ * Removes elements from an array and, inserts new elements in their place.
+ * @param items the array to splice.
+ * @param start the index from which to start removing elements.
+ * @param deleteCount the number of elements to remove.
+ * @param replacement the elements to insert into the array in place of the deleted elements.
+ * @signature
+ *    P.splice(items, start, deleteCount, replacement)
+ * @example
+ *    P.splice([1,2,3,4,5,6,7,8], 2, 3, []); //=> [1,2,6,7,8]
+ *    P.splice([1,2,3,4,5,6,7,8], 2, 3, [9, 10]); //=> [1,2,9,10,6,7,8]
+ * @dataFirst
+ * @category Array
+ */
+export declare function splice<T>(items: ReadonlyArray<T>, start: number, deleteCount: number, replacement: ReadonlyArray<T>): Array<T>;
+/**
+ * Removes elements from an array and, inserts new elements in their place.
+ * @param items the array to splice.
+ * @param start the index from which to start removing elements.
+ * @param deleteCount the number of elements to remove.
+ * @param replacement the elements to insert into the array in place of the deleted elements.
+ * @signature
+ *    P.splice(start, deleteCount, replacement)(items)
+ * @example
+ *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [])) // => [1,2,6,7,8]
+ *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [9, 10])) // => [1,2,9,10,6,7,8]
+ * @dataLast
+ * @category Array
+ */
+export declare function splice<T>(start: number, deleteCount: number, replacement: ReadonlyArray<T>): (items: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=splice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"splice.d.ts","sourceRoot":"","sources":["../../../src/array/splice.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAC5B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAC5B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/split-at.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Splits a given array at a given index.
+ * @param array the array to split
+ * @param index the index to split at
+ * @signature
+ *    P.splitAt(array, index)
+ * @example
+ *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]
+ *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]
+ * @dataFirst
+ * @category Array
+ */
+export declare function splitAt<T>(array: ReadonlyArray<T>, index: number): [Array<T>, Array<T>];
+/**
+ * Splits a given array at a given index.
+ * @param index the index to split at
+ * @signature
+ *    P.splitAt(index)(array)
+ * @example
+ *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]
+ *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]
+ * @dataLast
+ * @category Array
+ */
+export declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//# sourceMappingURL=split-at.d.ts.map

package/dist/types/array/split-at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-at.d.ts","sourceRoot":"","sources":["../../../src/array/split-at.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,MAAM,GACZ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAExB;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,MAAM,GACZ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/split-when.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Splits a given array at the first index where the given predicate returns true.
+ * @param array the array to split
+ * @param fn the predicate
+ * @signature
+ *    P.splitWhen(array, fn)
+ * @example
+ *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]
+ * @dataFirst
+ * @category Array
+ */
+export declare function splitWhen<T>(array: ReadonlyArray<T>, fn: (item: T) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a given array at an index where the given predicate returns true.
+ * @param fn the predicate
+ * @signature
+ *    P.splitWhen(fn)(array)
+ * @example
+ *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]
+ * @dataLast
+ * @category Array
+ */
+export declare function splitWhen<T>(fn: (item: T) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//# sourceMappingURL=split-when.d.ts.map

package/dist/types/array/split-when.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-when.d.ts","sourceRoot":"","sources":["../../../src/array/split-when.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GACvB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAExB;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GACvB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC"}