@vinicunca/perkakas 0.4.0 → 0.4.3

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

@@ -1,68 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,42 +0,0 @@
-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 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

@@ -1 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;GAiBG;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

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,30 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-/**
- * 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): LazyEvaluator<T>;
-}
-//# sourceMappingURL=take.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../src/array/take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtD;;;;;;;;;;;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,GAAG,aAAa,CAAC,CAAC,CAAC,CAUnD;CACF"}

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

@@ -1,22 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,44 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-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.isDeepEqual,
- *    ) // => [{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.isDeepEqual)(
- *      [{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.isDeepEqual),
- *      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>): LazyEvaluator<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

@@ -1 +0,0 @@
-{"version":3,"file":"uniq-with.d.ts","sourceRoot":"","sources":["../../../src/array/uniq-with.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMtD,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;AAczC,iBAAS,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAMzD;AAED,yBAAiB,QAAQ,CAAC;IACjB,MAAM,IAAI;;KAAuB,CAAC;CAC1C"}

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

@@ -1,35 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-/**
- * Returns a new array containing only one copy of each element in the original list.
- * Elements are compared by reference using Set.
- * @param array
- * @signature
- *    P.uniq(array)
- * @example
- *    P.uniq([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
- * @pipeable
- * @category Array
- * @dataFirst
- */
-export declare function uniq<T>(array: ReadonlyArray<T>): Array<T>;
-/**
- * Returns a new array containing only one copy of each element in the original list.
- * Elements are compared by reference using Set.
- * @param array
- * @signature
- *    P.uniq()(array)
- * @example
- *    P.pipe(
- *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
- *      P.uniq(),
- *      P.take(3)
- *    ) // => [1, 2, 5]
- * @pipeable
- * @category Array
- * @dataLast
- */
-export declare function uniq<T>(): (array: ReadonlyArray<T>) => Array<T>;
-export declare namespace uniq {
-    function lazy<T>(): LazyEvaluator<T>;
-}
-//# sourceMappingURL=uniq.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../../src/array/uniq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtD;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,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,KAAK,aAAa,CAAC,CAAC,CAAC,CAS1C;CACF"}

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

@@ -1,26 +0,0 @@
-/**
- * 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 PropertyKey, 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 PropertyKey>(first: ReadonlyArray<F>) => Record<F, S>;
-//# sourceMappingURL=zip-obj.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"zip-obj.d.ts","sourceRoot":"","sources":["../../../src/array/zip-obj.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,EAC7C,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,WAAW,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -1,42 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,52 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;AAoBjD,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

@@ -1,107 +0,0 @@
-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 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

@@ -1 +0,0 @@
-{"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

@@ -1,19 +0,0 @@
-/**
- * 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

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