@vinicunca/perkakas 0.2.1 → 0.3.1

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sum-by.d.ts","sourceRoot":"","sources":["../../../src/array/sum-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAevE;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,KAAK,CAAC,CAAC,EACrB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,MAAM,CAAC;AAMV,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,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/swap-indices.d.ts

@@ -0,0 +1,68 @@
+import type { IterableContainer } from '../utils/types';
+import type { Joined } from './join';
+/**
+ * @link https://github.com/sindresorhus/type-fest/blob/main/source/is-equal.d.ts
+ */
+type isEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2 ? true : false;
+type Difference<A extends number, B extends number> = TupleOfLength<A> extends [
+    ...infer U,
+    ...TupleOfLength<B>
+] ? U['length'] : never;
+type isLessThan<A extends number, B extends number> = isEqual<A, B> extends true ? false : 0 extends A ? true : 0 extends B ? false : isLessThan<Difference<A, 1>, Difference<B, 1>>;
+type TupleOfLength<L extends number, T extends IterableContainer = []> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;
+type IsNonNegative<T extends number> = number extends T ? false : `${T}` extends `-${string}` ? false : true;
+type CharactersTuple<T extends string> = string extends T ? Array<string> : T extends `${infer C}${infer R}` ? [C, ...CharactersTuple<R>] : [];
+type SwapArrayInternal<T extends IterableContainer, Index1 extends number, Index2 extends number, Position extends ReadonlyArray<unknown> = [], Original extends IterableContainer = T> = T extends readonly [infer AtPosition, ...infer Rest] ? [
+    Position['length'] extends Index1 ? Original[Index2] : Position['length'] extends Index2 ? Original[Index1] : AtPosition,
+    ...SwapArrayInternal<Rest, Index1, Index2, [
+        unknown,
+        ...Position
+    ], Original>
+] : T;
+type SwapString<T extends string, K1 extends number, K2 extends number> = Joined<SwapArray<CharactersTuple<T>, K1, K2>, ''>;
+type SwapArray<T extends IterableContainer, K1 extends number, K2 extends number> = IsNonNegative<K1> extends false ? Array<T[number]> : IsNonNegative<K2> extends false ? Array<T[number]> : isLessThan<K1, T['length']> extends false ? T : isLessThan<K2, T['length']> extends false ? T : SwapArrayInternal<T, K1, K2>;
+type SwappedIndices<T extends IterableContainer | string, K1 extends number, K2 extends number> = T extends string ? SwapString<T, K1, K2> : T extends IterableContainer ? SwapArray<T, K1, K2> : never;
+/**
+ * Swaps the positions of two elements in an array or string at the provided indices.
+ *
+ * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.
+ *
+ * If either index is out of bounds the result would be a shallow copy of the input, as-is.
+ *
+ * @param data the item to be manipulated. This can be an array, or a string.
+ * @param index1 the first index
+ * @param index2 the second index
+ *
+ * @signature
+ *   swapIndices(data, index1, index2)
+ *
+ * @example
+ *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']
+ *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['c', 'b', 'a']
+ *   swapIndices('abc', 0, 1) // => 'bac'
+ *
+ * @category Array
+ *
+ * @returns Returns the manipulated array or string.
+ *
+ * @dataFirst
+ */
+export declare function swapIndices<T extends IterableContainer | string, K1 extends number, K2 extends number>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;
+/**
+ * @param index1 the first index
+ * @param index2 the second index
+ *
+ * @signature
+ *   swapIndices(index1, index2)(data)
+ *
+ * @example
+ *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']
+ *   swapIndices(0, -1)('abc') // => 'cba'
+ *
+ * @category Array
+ * @returns Returns the manipulated array or string.
+ * @dataLast
+ */
+export declare function swapIndices<K1 extends number, K2 extends number>(index1: K1, index2: K2): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;
+export {};
+//# sourceMappingURL=swap-indices.d.ts.map

package/dist/types/array/swap-indices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-indices.d.ts","sourceRoot":"","sources":["../../../src/array/swap-indices.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,43 @@
+import type { NonEmptyArray } from '../utils/types';
+import { type OrderRule } from '../utils/purry-order-rules';
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before taking the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria.
+ * Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.takeFirstBy(data, n, ...rules);
+ * @example
+ *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
+ * @dataFirst
+ * @category Array
+ */
+export declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before taking the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria.
+ * Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.takeFirstBy(n, ...rules)(data);
+ * @example
+ *   R.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
+ * @dataLast
+ * @category Array
+ */
+export declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=take-first-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-first-by.d.ts","sourceRoot":"","sources":["../../../src/array/take-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;;;;;;;;;;;;;;;;;;GAkBG;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;;;;;;;;;;;;;;;;;;GAkBG;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/take-while.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Returns elements from the array until predicate returns false.
+ * @param array the array
+ * @param fn the predicate
+ * @signature
+ *    P.takeWhile(array, fn)
+ * @example
+ *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]
+ * @dataFirst
+ * @category Array
+ */
+export declare function takeWhile<T>(array: ReadonlyArray<T>, fn: (item: T) => boolean): Array<T>;
+/**
+ * Returns elements from the array until predicate returns false.
+ * @param fn the predicate
+ * @signature
+ *    P.takeWhile(fn)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]
+ * @dataLast
+ * @category Array
+ */
+export declare function takeWhile<T>(fn: (item: T) => boolean): (array: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=take-while.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../src/array/take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;GAUG;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,WAChB,CAAC,KAAG,WAAW,CAAC,CAAC,CAqBjC;CACF"}

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

@@ -0,0 +1,22 @@
+export declare function uniqBy<T, K>(array: ReadonlyArray<T>, transformer: (item: T) => K): Array<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original list transformed by a function.
+ * Elements are compared by reference using Set.
+ * @param array
+ * @signature
+ *    P.uniqBy(array, fn)
+ * @example
+ *    P.uniqBy(
+ *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],
+ *     (obj) => obj.n,
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]
+ *    P.pipe(
+ *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations
+ *      P.uniqBy(obj => obj.n),
+ *      P.take(3)
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}]
+ * @pipeable
+ * @category Array
+ */
+export declare function uniqBy<T, K>(transformer: (item: T) => K): (array: ReadonlyArray<T>) => Array<T>;
+//# sourceMappingURL=uniq-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniq-by.d.ts","sourceRoot":"","sources":["../../../src/array/uniq-by.ts"],"names":[],"mappings":"AAKA,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAC1B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,44 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+type IsEquals<T> = (a: T, b: T) => boolean;
+/**
+ * Returns a new array containing only one copy of each element in the original list.
+ * Elements are compared by custom comparator isEquals.
+ * @param array
+ * @param isEquals the comparator
+ * @signature
+ *    P.uniqWith(array, isEquals)
+ * @example
+ *    P.uniqWith(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *      P.equals,
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ * @dataFirst
+ * @category Array
+ */
+export declare function uniqWith<T>(array: ReadonlyArray<T>, isEquals: IsEquals<T>): Array<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original list.
+ * Elements are compared by custom comparator isEquals.
+ * @param isEquals the comparator
+ * @signature P.uniqWith(isEquals)(array)
+ * @example
+ *    P.uniqWith(P.equals)(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ *    P.pipe(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations
+ *      P.uniqWith(P.equals),
+ *      P.take(3)
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}]
+ * @dataLast
+ * @category Object
+ */
+export declare function uniqWith<T>(isEquals: IsEquals<T>): (array: ReadonlyArray<T>) => Array<T>;
+declare function _lazy<T>(isEquals: IsEquals<T>): (value: T, index?: number, array?: ReadonlyArray<T>) => LazyResult<T>;
+export declare namespace uniqWith {
+    const lazy: typeof _lazy & {
+        readonly indexed: true;
+    };
+}
+export {};
+//# sourceMappingURL=uniq-with.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniq-with.d.ts","sourceRoot":"","sources":["../../../src/array/uniq-with.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAMvD,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE3C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAWzC,iBAAS,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,WAE5B,CAAC,UACA,MAAM,UACN,cAAc,CAAC,CAAC,KACvB,WAAW,CAAC,CAAC,CAgBjB;AAED,yBAAiB,QAAQ,CAAC;IACjB,MAAM,IAAI;;KAAuB,CAAC;CAC1C"}

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

@@ -0,0 +1,24 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+/**
+ * Returns a new array containing only one copy of each element in the original list.
+ * Elements are compared by reference using Set.
+ * Note: In `pipe`, use `uniq()` form instead of `uniq`. Otherwise, the inferred type is lost.
+ * @param array
+ * @signature
+ *    P.uniq(array)
+ * @example
+ *    P.uniq([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
+ *    P.pipe(
+ *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
+ *      P.uniq(),
+ *      P.take(3)
+ *    ) // => [1, 2, 5]
+ * @pipeable
+ * @category Array
+ */
+export declare function uniq<T>(array: ReadonlyArray<T>): Array<T>;
+export declare function uniq<T>(): (array: ReadonlyArray<T>) => Array<T>;
+export declare namespace uniq {
+    function lazy<T>(): (value: T) => LazyResult<T>;
+}
+//# sourceMappingURL=uniq.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../../src/array/uniq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAC3D,wBAAgB,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAUjE,yBAAiB,IAAI,CAAC;IACpB,SAAgB,IAAI,CAAC,CAAC,aAEL,CAAC,KAAG,WAAW,CAAC,CAAC,CAcjC;CACF"}

package/dist/types/array/zip-obj.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Creates a new object from two supplied lists by pairing up equally-positioned items.
+ * Key/value pairing is truncated to the length of the shorter of the two lists
+ * @param first the first input list
+ * @param second the second input list
+ * @signature
+ *   P.zipObj(first, second)
+ * @example
+ *   P.zipObj(['a', 'b'], [1, 2]) // => {a: 1, b: 2}
+ * @dataFirst
+ * @category Array
+ */
+export declare function zipObj<F extends number | string | symbol, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Record<F, S>;
+/**
+ * Creates a new object from two supplied lists by pairing up equally-positioned items.
+ * Key/value pairing is truncated to the length of the shorter of the two lists
+ * @param second the second input list
+ * @signature
+ *   P.zipObj(second)(first)
+ * @example
+ *   P.zipObj([1, 2])(['a', 'b']) // => {a: 1, b: 2}
+ * @dataLast
+ * @category Array
+ */
+export declare function zipObj<S>(second: ReadonlyArray<S>): <F extends number | string | symbol>(first: ReadonlyArray<F>) => Record<F, S>;
+//# sourceMappingURL=zip-obj.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip-obj.d.ts","sourceRoot":"","sources":["../../../src/array/zip-obj.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEhB;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACpC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KACpB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,42 @@
+type ZippingFunction<F = unknown, S = unknown, R = unknown> = (f: F, s: S) => R;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ * @param first the first input list
+ * @param second the second input list
+ * @param fn the function applied to each position of the list
+ * @signature
+ *   P.zipWith(first, second, fn)
+ * @example
+ *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']
+ * @dataFirst
+ * @category Array
+ */
+export declare function zipWith<F, S, R>(first: ReadonlyArray<F>, second: ReadonlyArray<S>, fn: ZippingFunction<F, S, R>): Array<R>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ * @param fn the function applied to each position of the list
+ * @signature
+ *   P.zipWith(fn)(first, second)
+ * @example
+ *   P.zipWith((a, b) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @category Array
+ */
+export declare function zipWith<F, S, R>(fn: ZippingFunction<F, S, R>): (first: ReadonlyArray<F>, second: ReadonlyArray<S>) => Array<R>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ * @param fn the function applied to each position of the list
+ * @param second the second input list
+ * @signature
+ *   P.zipWith(fn)(first, second)
+ * @example
+ *   P.zipWith((a, b) => a + b, ['a', 'b', 'c'])(['1', '2', '3']) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @category Array
+ */
+export declare function zipWith<F, S, R>(fn: ZippingFunction<F, S, R>, second: ReadonlyArray<S>): (first: ReadonlyArray<F>) => Array<R>;
+export {};
+//# sourceMappingURL=zip-with.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip-with.d.ts","sourceRoot":"","sources":["../../../src/array/zip-with.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAEhF;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EACxB,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC3B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC3B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,52 @@
+import type { IterableContainer } from '../utils/types';
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned items.
+ * The length of the returned list will match the shortest of the two inputs.
+ *
+ * If the input array are tuples, you can use the strict option
+ * to get another tuple instead of a generic array type.
+ * @param first the first input list
+ * @param second the second input list
+ * @signature
+ *   P.zip(first, second)
+ * @example
+ *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']] (type: [number, string][])
+ *   P.zip.strict([1, 2] as const, ['a', 'b'] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
+ * @dataFirst
+ * @category Array
+ * @strict
+ */
+export declare function zip<F, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Array<[F, S]>;
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned items.
+ * The length of the returned list will match the shortest of the two inputs.
+ *
+ * If the input array are tuples, you can use the strict option
+ * to get another tuple instead of a generic array type.
+ * @param second the second input list
+ * @signature
+ *   P.zip(second)(first)
+ * @example
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']] (type: [number, string][])
+ *   P.zip.strict(['a', 'b'] as const)([1, 2] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
+ * @dataLast
+ * @category Array
+ * @strict
+ */
+export declare function zip<S>(second: ReadonlyArray<S>): <F>(first: ReadonlyArray<F>) => Array<[F, S]>;
+interface Strict {
+    <F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zip<F, S>;
+    <S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zip<F, S>;
+}
+type Zip<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [
+    [LeftHead, RightHead],
+    ...Zip<LeftRest, RightRest>
+] : [
+    [LeftHead, Right[number]],
+    ...Zip<LeftRest, Right>
+] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zip<Left, RightRest>] : Array<[Left[number], Right[number]]>;
+export declare namespace zip {
+    const strict: Strict;
+}
+export {};
+//# sourceMappingURL=zip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../src/array/zip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,CAAC,EACnB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAiBjD,UAAU,MAAM;IACd,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,iBAAiB,EACvD,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,CAAC,GACR,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEb,CAAC,CAAC,SAAS,iBAAiB,EAC1B,MAAM,EAAE,CAAC,GACR,CAAC,CAAC,SAAS,iBAAiB,EAAE,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACzD;AAED,KAAK,GAAG,CAAC,IAAI,SAAS,iBAAiB,EAAE,KAAK,SAAS,iBAAiB,IAEtE,IAAI,SAAS,SAAS,EAAE,GACpB,EAAE,GACF,KAAK,SAAS,SAAS,EAAE,GACvB,EAAE,GAEJ,IAAI,SAAS,SAAS,CAAC,MAAM,QAAQ,EAAE,GAAG,MAAM,QAAQ,CAAC,GACrD,KAAK,SAAS,SAAS,CAAC,MAAM,SAAS,EAAE,GAAG,MAAM,SAAS,CAAC,GAE1D;IAAC,CAAC,QAAQ,EAAE,SAAS,CAAC;IAAE,GAAG,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC;CAAC,GAGpD;IAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAE,GAAG,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;CAAC,GACtD,KAAK,SAAS,SAAS,CAAC,MAAM,SAAS,EAAE,GAAG,MAAM,SAAS,CAAC,GAC1D,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,GAGtD,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAE/C,yBAAiB,GAAG,CAAC;IAGZ,MAAM,MAAM,EAAE,MAAY,CAAC;CACnC"}

package/dist/types/function/conditional.d.ts

@@ -0,0 +1,108 @@
+type Case<In, Out, Thru extends In = In> = readonly [
+    when: ((data: In) => boolean) | ((data: In) => data is Thru),
+    then: (data: Thru) => Out
+];
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(...cases)(data);
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.conditional.defaultCase(
+ *         (something) => `Hello something (${JSON.stringify(something)})`,
+ *       ),
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataLast
+ * @category Function
+ */
+export declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(data, ...cases);
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.conditional.defaultCase(
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataFirst
+ * @category Function
+ */
+export declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(data: T, case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+export declare namespace conditional {
+    /**
+     * A simplified case that accepts all data. Put this as the last case to
+     * prevent an exception from being thrown when none of the previous cases
+     * match.
+     * If this is not the last case it will short-circuit anything after it.
+     * @param then - You only need to provide the transformer, the predicate is
+     * implicit. @default () => undefined, which is how Lodash and Ramda handle
+     * the final fallback case.
+     */
+    function defaultCase<In>(then?: (data: In) => unknown): readonly [() => boolean, (data: In) => unknown];
+}
+export {};
+//# sourceMappingURL=conditional.d.ts.map

package/dist/types/function/conditional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional.d.ts","sourceRoot":"","sources":["../../../src/function/conditional.ts"],"names":[],"mappings":"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"}

package/dist/types/function/create-pipe.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Creates a data-last pipe function. First function must be always annotated. Other functions are automatically inferred.
+ * @signature
+ *    P.createPipe(op1, op2, op3)(data);
+ * @example
+ *    P.createPipe(
+ *      (x: number) => x * 2,
+ *      x => x * 3
+ *    )(1) // => 6
+ * @category Function
+ */
+export declare function createPipe<A, B>(op1: (input: A) => B): (value: A) => B;
+export declare function createPipe<A, B, C>(op1: (input: A) => B, op2: (input: B) => C): (value: A) => C;
+export declare function createPipe<A, B, C, D>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): (value: A) => D;
+export declare function createPipe<A, B, C, D, E>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): (value: A) => E;
+export declare function createPipe<A, B, C, D, E, F>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): (value: A) => F;
+export declare function createPipe<A, B, C, D, E, F, G>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): (value: A) => G;
+export declare function createPipe<A, B, C, D, E, F, G, H>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): (value: A) => H;
+//# sourceMappingURL=create-pipe.d.ts.map

package/dist/types/function/create-pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-pipe.d.ts","sourceRoot":"","sources":["../../../src/function/create-pipe.ts"],"names":[],"mappings":"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"}