@vinicunca/perkakas 0.5.4 → 1.0.1

package/dist/types-BMu1PIvo.d.ts

@@ -0,0 +1,115 @@
+import { EmptyObject, IsAny, Simplify, IsLiteral, IsNever, KeysOfUnion, IsStringLiteral, IsNumericLiteral, IsSymbolLiteral, Split } from 'type-fest';
+
+declare const __brand: unique symbol;
+type Branded<T, Brand extends symbol> = T & {
+    [__brand]: Brand;
+};
+type NonEmptyArray<T> = [T, ...Array<T>];
+type Mapped<T extends IterableContainer, K> = {
+    -readonly [P in keyof T]: K;
+};
+/**
+ * This should only be used for defining generics which extend any kind of JS
+ * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
+ * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
+ * allows us to be more inclusive to what functions can process.
+ *
+ * @example map<T extends ArrayLike>(items: T) { ... }
+ *
+ * We would've named this `ArrayLike`, but that's already used by typescript...
+ * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
+ */
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+/**
+ * Check if a type is guaranteed to be a bounded record: a record with a finite
+ * set of keys.
+ *
+ * @example
+ *     IfBoundedRecord<{ a: 1, 1: "a" }>; //=> true
+ *     IfBoundedRecord<Record<string | number, unknown>>; //=> false
+ *     IfBoundedRecord<Record<`prefix_${number}`, unknown>>; //=> false
+ */
+type IfBoundedRecord<T, TypeIfBoundedRecord = true, TypeIfUnboundedRecord = false> = IsBoundedKey<KeysOfUnion<T>> extends true ? TypeIfBoundedRecord : TypeIfUnboundedRecord;
+/**
+ * Checks if a type is a bounded key: a union of bounded strings, numeric
+ * literals, or symbol literals.
+ */
+type IsBoundedKey<T> = T extends unknown ? IsStringLiteral<T> extends true ? IsBoundedString<T> : IsNumericLiteral<T> extends true ? true : IsSymbolLiteral<T> : never;
+/**
+ * Checks if a type is a bounded string: a type that only has a finite
+ * number of strings that are that type.
+ *
+ * Most relevant for template literals: IsBoundedString<`${1 | 2}_${3 | 4}`> is
+ * true, and IsBoundedString<`${1 | 2}_${number}`> is false.
+ */
+type IsBoundedString<T> = T extends string ? Split<T, ''>[number] extends infer U ? [
+    `${number}`
+] extends [U] ? false : [string] extends [U] ? false : true : false : false;
+/**
+ * A union of all keys of T which are not symbols, and where number keys are
+ * converted to strings, following the definition of `Object.keys` and
+ * `Object.entries`.
+ *
+ * Inspired and largely copied from [`sindresorhus/ts-extras`](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts).
+ *
+ * @see EnumerableStringKeyedValueOf
+ */
+type EnumerableStringKeyOf<T> = Required<T> extends Record<infer K, unknown> ? `${Exclude<K, symbol>}` : never;
+/**
+ * A union of all values of properties in T which are not keyed by a symbol,
+ * following the definition of `Object.values` and `Object.entries`.
+ */
+type EnumerableStringKeyedValueOf<T> = ValuesOf<{
+    [K in keyof T]-?: K extends symbol ? never : T[K];
+}>;
+/**
+ * Extracts the value type from an object type T.
+ */
+type ValuesOf<T> = T extends EmptyObject ? T[keyof T] : T extends Record<PropertyKey, infer V> ? V : never;
+/**
+ * This is the type you'd get from doing:
+ * `Object.fromEntries(Object.entries(x))`.
+ */
+type ReconstructedRecord<T> = Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>;
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ *
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
+type ExactRecord<Key extends PropertyKey, Value> = IfBoundedRecord<Record<Key, Value>, Partial<Record<Key, Value>>, Record<Key, Value>>;
+type ReorderedArray<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+type UpsertProp<T, K extends PropertyKey, V> = Simplify<Omit<T, K> & (IsSingleLiteral<K> extends true ? {
+    -readonly [P in K]-?: V;
+} : // The key is either a broad type (`string`) or union of literals
+{
+    -readonly [P in keyof T as P extends K ? P : never]: T[P] | V;
+} & {
+    -readonly [P in K as P extends keyof T ? never : P]?: V;
+})>;
+/**
+ * This type attempts to detect when a type is a single literal value
+ * (e.g. "cat"), and not anything else (e.g. "cat" | "dog", string, etc...)
+ */
+type IsSingleLiteral<K> = IsLiteral<K> extends true ? (IsUnion<K> extends true ? false : true) : false;
+/**
+ * This is copied from type-fest because currently
+ * it isn't exported.
+ * TODO: Check whenever this type is exported.
+ */
+type IsUnion<T> = InternalIsUnion<T>;
+type InternalIsUnion<T, U = T> = (IsNever<T> extends true ? false : T extends any ? [U] extends [T] ? false : true : never) extends infer Result ? boolean extends Result ? true : Result : never;
+/**
+ * Extracts a type predicate from a type guard function for the first argument.
+ *
+ * @example
+ * type TypeGuardFn = (x: unknown) => x is string;
+ * type Result = GuardType<TypeGuardFn>; // `string`
+ */
+type GuardType<T, Fallback = never> = T extends (x: any, ...rest: any) => x is infer U ? U : Fallback;
+
+export type { Branded as B, EnumerableStringKeyedValueOf as E, GuardType as G, IterableContainer as I, Mapped as M, NonEmptyArray as N, ReconstructedRecord as R, UpsertProp as U, EnumerableStringKeyOf as a, ExactRecord as b, NarrowedTo as c, IsUnion as d, IfBoundedRecord as e, ReorderedArray as f };

package/dist/unique-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkDWPHE3F2cjs = require('./chunk-DWPHE3F2.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.uniqueBy = _chunkDWPHE3F2cjs.a;

package/dist/unique-by.d.cts

@@ -0,0 +1,38 @@
+/**
+ * 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 data - The array to filter.
+ * @param keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(data, keyFunction)
+ * @example
+ *    P.uniqueBy(
+ *     [{ 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}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T, K>(data: ReadonlyArray<T>, keyFunction: (item: T, index: number, data: ReadonlyArray<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 keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(keyFunction)(data)
+ * @example
+ *    P.pipe(
+ *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations
+ *      P.uniqueBy(obj => obj.n),
+ *      P.take(3)
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T, K>(keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K): (data: ReadonlyArray<T>) => Array<T>;
+
+export { uniqueBy };

package/dist/unique-by.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 data - The array to filter.
+ * @param keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(data, keyFunction)
+ * @example
+ *    P.uniqueBy(
+ *     [{ 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}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T, K>(data: ReadonlyArray<T>, keyFunction: (item: T, index: number, data: ReadonlyArray<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 keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(keyFunction)(data)
+ * @example
+ *    P.pipe(
+ *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations
+ *      P.uniqueBy(obj => obj.n),
+ *      P.take(3)
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T, K>(keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K): (data: ReadonlyArray<T>) => Array<T>;
+
+export { uniqueBy };

package/dist/unique-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-DUKQ2ODK.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as uniqueBy};

package/dist/unique-with.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkXQOKSJ5Rcjs = require('./chunk-XQOKSJ5R.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.uniqueWith = _chunkXQOKSJ5Rcjs.a;

package/dist/unique-with.d.cts

@@ -0,0 +1,41 @@
+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 data - The array to filter.
+ * @param isEquals - The comparator.
+ * @signature
+ *    P.uniqueWith(array, isEquals)
+ * @example
+ *    P.uniqueWith(
+ *      [{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
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T>(data: 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.uniqueWith(isEquals)(array)
+ * @example
+ *    P.uniqueWith(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.uniqueWith(P.equals),
+ *      P.take(3)
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T>(isEquals: IsEquals<T>): (data: ReadonlyArray<T>) => Array<T>;
+
+export { uniqueWith };

package/dist/unique-with.d.ts

@@ -0,0 +1,41 @@
+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 data - The array to filter.
+ * @param isEquals - The comparator.
+ * @signature
+ *    P.uniqueWith(array, isEquals)
+ * @example
+ *    P.uniqueWith(
+ *      [{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
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T>(data: 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.uniqueWith(isEquals)(array)
+ * @example
+ *    P.uniqueWith(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.uniqueWith(P.equals),
+ *      P.take(3)
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T>(isEquals: IsEquals<T>): (data: ReadonlyArray<T>) => Array<T>;
+
+export { uniqueWith };

package/dist/unique-with.js

@@ -0,0 +1 @@
+import{a}from"./chunk-YQKPA3BB.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as uniqueWith};

package/dist/unique.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkYIUDV3OAcjs = require('./chunk-YIUDV3OA.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.unique = _chunkYIUDV3OAcjs.a;

package/dist/unique.d.cts

@@ -0,0 +1,33 @@
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by reference using Set.
+ *
+ * @param array - The array to filter.
+ * @signature
+ *    P.unique(array)
+ * @example
+ *    P.unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function unique<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.
+ *
+ * @signature
+ *    P.unique()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
+ *      P.unique(),
+ *      P.take(3)
+ *    ) // => [1, 2, 5]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function unique<T>(): (array: ReadonlyArray<T>) => Array<T>;
+
+export { unique };

package/dist/unique.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by reference using Set.
+ *
+ * @param array - The array to filter.
+ * @signature
+ *    P.unique(array)
+ * @example
+ *    P.unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function unique<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.
+ *
+ * @signature
+ *    P.unique()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
+ *      P.unique(),
+ *      P.take(3)
+ *    ) // => [1, 2, 5]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function unique<T>(): (array: ReadonlyArray<T>) => Array<T>;
+
+export { unique };

package/dist/unique.js

@@ -0,0 +1 @@
+import{a}from"./chunk-MENOHSYF.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as unique};

package/dist/values.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk47KOI7MWcjs = require('./chunk-47KOI7MW.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.values = _chunk47KOI7MWcjs.a;

package/dist/values.d.cts

@@ -0,0 +1,36 @@
+import { I as IterableContainer, E as EnumerableStringKeyedValueOf } from './types-BMu1PIvo.cjs';
+import 'type-fest';
+
+type Values<T extends object> = T extends IterableContainer ? Array<T[number]> : Array<EnumerableStringKeyedValueOf<T>>;
+/**
+ * Returns a new array containing the values of the array or object.
+ *
+ * @param data - Either an array or an object.
+ * @signature
+ *    P.values(source)
+ * @example
+ *    P.values(['x', 'y', 'z']) // => ['x', 'y', 'z']
+ *    P.values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']
+ * @dataFirst
+ * @category Object
+ */
+declare function values<T extends object>(data: T): Values<T>;
+/**
+ * Returns a new array containing the values of the array or object.
+ *
+ * @signature
+ *    P.values()(source)
+ * @example
+ *    P.pipe(['x', 'y', 'z'], P.values()) // => ['x', 'y', 'z']
+ *    P.pipe({ a: 'x', b: 'y', c: 'z' }, P.values()) // => ['x', 'y', 'z']
+ *    P.pipe(
+ *      { a: 'x', b: 'y', c: 'z' },
+ *      P.values(),
+ *      P.first(),
+ *    ) // => 'x'
+ * @dataLast
+ * @category Object
+ */
+declare function values(): <T extends object>(data: T) => Values<T>;
+
+export { values };

package/dist/values.d.ts

@@ -0,0 +1,36 @@
+import { I as IterableContainer, E as EnumerableStringKeyedValueOf } from './types-BMu1PIvo.js';
+import 'type-fest';
+
+type Values<T extends object> = T extends IterableContainer ? Array<T[number]> : Array<EnumerableStringKeyedValueOf<T>>;
+/**
+ * Returns a new array containing the values of the array or object.
+ *
+ * @param data - Either an array or an object.
+ * @signature
+ *    P.values(source)
+ * @example
+ *    P.values(['x', 'y', 'z']) // => ['x', 'y', 'z']
+ *    P.values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']
+ * @dataFirst
+ * @category Object
+ */
+declare function values<T extends object>(data: T): Values<T>;
+/**
+ * Returns a new array containing the values of the array or object.
+ *
+ * @signature
+ *    P.values()(source)
+ * @example
+ *    P.pipe(['x', 'y', 'z'], P.values()) // => ['x', 'y', 'z']
+ *    P.pipe({ a: 'x', b: 'y', c: 'z' }, P.values()) // => ['x', 'y', 'z']
+ *    P.pipe(
+ *      { a: 'x', b: 'y', c: 'z' },
+ *      P.values(),
+ *      P.first(),
+ *    ) // => 'x'
+ * @dataLast
+ * @category Object
+ */
+declare function values(): <T extends object>(data: T) => Values<T>;
+
+export { values };

package/dist/values.js

@@ -0,0 +1 @@
+import{a}from"./chunk-22S2LZ25.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as values};

package/dist/zip-with.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkPH45KQNBcjs = require('./chunk-PH45KQNB.cjs');require('./chunk-7T4AVFYJ.cjs');exports.zipWith = _chunkPH45KQNBcjs.a;

package/dist/zip-with.d.cts

@@ -0,0 +1,49 @@
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+import 'type-fest';
+
+type ZippingFunction<T1 extends IterableContainer = IterableContainer, T2 extends IterableContainer = IterableContainer, Value = unknown> = (first: T1[number], second: T2[number], index: number, data: readonly [first: T1, second: T2]) => Value;
+/**
+ * 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: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
+ * @category Array
+ */
+declare function zipWith<TItem1, TItem2, Value>(fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(first: T1, second: T2) => Array<Value>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param second - The second input list.
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(second, fn)(first)
+ * @example
+ *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;
+/**
+ * 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
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;
+
+export { zipWith };

package/dist/zip-with.d.ts

@@ -0,0 +1,49 @@
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+import 'type-fest';
+
+type ZippingFunction<T1 extends IterableContainer = IterableContainer, T2 extends IterableContainer = IterableContainer, Value = unknown> = (first: T1[number], second: T2[number], index: number, data: readonly [first: T1, second: T2]) => Value;
+/**
+ * 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: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
+ * @category Array
+ */
+declare function zipWith<TItem1, TItem2, Value>(fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(first: T1, second: T2) => Array<Value>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param second - The second input list.
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(second, fn)(first)
+ * @example
+ *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;
+/**
+ * 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
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;
+
+export { zipWith };

package/dist/zip-with.js

@@ -0,0 +1 @@
+import{a}from"./chunk-PSXTTF2V.js";import"./chunk-KQGY2DBY.js";export{a as zipWith};

package/dist/zip.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkWNL2I2YKcjs = require('./chunk-WNL2I2YK.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.zip = _chunkWNL2I2YKcjs.a;

package/dist/zip.d.cts

@@ -0,0 +1,43 @@
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+import 'type-fest';
+
+type Zipped<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],
+    ...Zipped<LeftRest, RightRest>
+] : [
+    [LeftHead, Right[number]],
+    ...Zipped<LeftRest, Right>
+] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zipped<Left, RightRest>] : Array<[Left[number], Right[number]]>;
+/**
+ * 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.
+ *
+ * @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']]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function zip<F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zipped<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.
+ *
+ * @param second - The second input list.
+ * @signature
+ *   P.zip(second)(first)
+ * @example
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zip<S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zipped<F, S>;
+
+export { zip };

package/dist/zip.d.ts

@@ -0,0 +1,43 @@
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+import 'type-fest';
+
+type Zipped<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],
+    ...Zipped<LeftRest, RightRest>
+] : [
+    [LeftHead, Right[number]],
+    ...Zipped<LeftRest, Right>
+] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zipped<Left, RightRest>] : Array<[Left[number], Right[number]]>;
+/**
+ * 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.
+ *
+ * @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']]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function zip<F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zipped<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.
+ *
+ * @param second - The second input list.
+ * @signature
+ *   P.zip(second)(first)
+ * @example
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zip<S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zipped<F, S>;
+
+export { zip };

package/dist/zip.js

@@ -0,0 +1 @@
+import{a}from"./chunk-QQQIEYAH.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as zip};