@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/pick-by.d.cts

@@ -1,68 +0,0 @@
-import { t as IsBoundedRecord } from "./is-bounded-record-DV6ZQk9H.cjs";
-import { t as ToString } from "./to-string-DkC3zRUJ.cjs";
-import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-DhcNc5iz.cjs";
-import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-icm2q60J.cjs";
-import { IsNever, Simplify } from "type-fest";
-
-//#region src/pick-by.d.ts
-type EnumeratedPartial<T> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? { -readonly [P in keyof T as ToString<P>]?: Required<T>[P] } : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>> : never;
-type EnumeratedPartialNarrowed<T, S> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? ExactProps<T, S> & PartialProps<T, S> : Record<EnumerableStringKeyOf<T>, Extract<EnumerableStringKeyedValueOf<T>, S>>> : never;
-type ExactProps<T, S> = { -readonly [P in keyof T as ToString<IsExactProp<T, P, S> extends true ? P : never>]: Extract<Required<T>[P], S> };
-type PartialProps<T, S> = { -readonly [P in keyof T as ToString<IsPartialProp<T, P, S> extends true ? P : never>]?: IsNever<Extract<T[P], S>> extends true ? S extends T[P] ? S : never : Extract<T[P], S> };
-type IsExactProp<T, P$1 extends keyof T, S> = T[P$1] extends Extract<T[P$1], S> ? true : false;
-type IsPartialProp<T, P$1 extends keyof T, S> = IsExactProp<T, P$1, S> extends true ? false : IsNever<Extract<T[P$1], S>> extends true ? S extends T[P$1] ? true : false : true;
-/**
- * Iterates over the entries of `data` and reconstructs the object using only
- * entries that `predicate` accepts. Symbol keys are not passed to the predicate
- * and would be filtered out from the output object.
- *
- * See `omitBy` for a complementary function which starts with a shallow copy of
- * the input object and removes the entries that the predicate rejects. Because
- * it is subtractive symbol keys would be copied over to the output object.
- * See also `entries`, `filter`, and `fromEntries` which could be used to build
- * your own version of `pickBy` if you need more control (though the resulting
- * type might be less precise).
- *
- * @param data - The target object.
- * @param predicate - A function that takes the value, key, and the data itself
- * and returns true if the entry should be part of the output object, or `false`
- * to remove it. If the function is a type-guard on the value the output type
- * would be narrowed accordingly.
- * @returns A shallow copy of the input object with the rejected entries
- * removed.
- * @signature P.pickBy(data, predicate)
- * @example
- *    P.pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}
- * @dataFirst
- * @category Object
- */
-declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): EnumeratedPartialNarrowed<T, S>;
-declare function pickBy<T extends object>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): EnumeratedPartial<T>;
-/**
- * Iterates over the entries of `data` and reconstructs the object using only
- * entries that `predicate` accepts. Symbol keys are not passed to the predicate
- * and would be filtered out from the output object.
- *
- * See `omitBy` for a complementary function which starts with a shallow copy of
- * the input object and removes the entries that the predicate rejects. Because
- * it is subtractive symbol keys would be copied over to the output object.
- * See also `entries`, `filter`, and `fromEntries` which could be used to build
- * your own version of `pickBy` if you need more control (though the resulting
- * type might be less precise).
- *
- * @param predicate - A function that takes the value, key, and the data itself
- * and returns true if the entry should be part of the output object, or `false`
- * to remove it. If the function is a type-guard on the value the output type
- * would be narrowed accordingly.
- * @signature
- *   P.pickBy(predicate)(data)
- * @example
- *    P.pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}
- * @dataLast
- * @category Object
- */
-declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): (data: T) => EnumeratedPartialNarrowed<T, S>;
-declare function pickBy<T extends object>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): (data: T) => EnumeratedPartial<T>;
-//#endregion
-export { pickBy };
-//# sourceMappingURL=pick-by.d.cts.map

package/dist/pick-by.d.cts.map

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

package/dist/pick-by.d.ts

@@ -1,68 +0,0 @@
-import { t as IsBoundedRecord } from "./is-bounded-record-Bx4n8QB0.js";
-import { t as ToString } from "./to-string-YIFx2KS6.js";
-import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-CZQf3ld_.js";
-import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-CRlVAvdp.js";
-import { IsNever, Simplify } from "type-fest";
-
-//#region src/pick-by.d.ts
-type EnumeratedPartial<T> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? { -readonly [P in keyof T as ToString<P>]?: Required<T>[P] } : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>> : never;
-type EnumeratedPartialNarrowed<T, S> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? ExactProps<T, S> & PartialProps<T, S> : Record<EnumerableStringKeyOf<T>, Extract<EnumerableStringKeyedValueOf<T>, S>>> : never;
-type ExactProps<T, S> = { -readonly [P in keyof T as ToString<IsExactProp<T, P, S> extends true ? P : never>]: Extract<Required<T>[P], S> };
-type PartialProps<T, S> = { -readonly [P in keyof T as ToString<IsPartialProp<T, P, S> extends true ? P : never>]?: IsNever<Extract<T[P], S>> extends true ? S extends T[P] ? S : never : Extract<T[P], S> };
-type IsExactProp<T, P$1 extends keyof T, S> = T[P$1] extends Extract<T[P$1], S> ? true : false;
-type IsPartialProp<T, P$1 extends keyof T, S> = IsExactProp<T, P$1, S> extends true ? false : IsNever<Extract<T[P$1], S>> extends true ? S extends T[P$1] ? true : false : true;
-/**
- * Iterates over the entries of `data` and reconstructs the object using only
- * entries that `predicate` accepts. Symbol keys are not passed to the predicate
- * and would be filtered out from the output object.
- *
- * See `omitBy` for a complementary function which starts with a shallow copy of
- * the input object and removes the entries that the predicate rejects. Because
- * it is subtractive symbol keys would be copied over to the output object.
- * See also `entries`, `filter`, and `fromEntries` which could be used to build
- * your own version of `pickBy` if you need more control (though the resulting
- * type might be less precise).
- *
- * @param data - The target object.
- * @param predicate - A function that takes the value, key, and the data itself
- * and returns true if the entry should be part of the output object, or `false`
- * to remove it. If the function is a type-guard on the value the output type
- * would be narrowed accordingly.
- * @returns A shallow copy of the input object with the rejected entries
- * removed.
- * @signature P.pickBy(data, predicate)
- * @example
- *    P.pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}
- * @dataFirst
- * @category Object
- */
-declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): EnumeratedPartialNarrowed<T, S>;
-declare function pickBy<T extends object>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): EnumeratedPartial<T>;
-/**
- * Iterates over the entries of `data` and reconstructs the object using only
- * entries that `predicate` accepts. Symbol keys are not passed to the predicate
- * and would be filtered out from the output object.
- *
- * See `omitBy` for a complementary function which starts with a shallow copy of
- * the input object and removes the entries that the predicate rejects. Because
- * it is subtractive symbol keys would be copied over to the output object.
- * See also `entries`, `filter`, and `fromEntries` which could be used to build
- * your own version of `pickBy` if you need more control (though the resulting
- * type might be less precise).
- *
- * @param predicate - A function that takes the value, key, and the data itself
- * and returns true if the entry should be part of the output object, or `false`
- * to remove it. If the function is a type-guard on the value the output type
- * would be narrowed accordingly.
- * @signature
- *   P.pickBy(predicate)(data)
- * @example
- *    P.pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}
- * @dataLast
- * @category Object
- */
-declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): (data: T) => EnumeratedPartialNarrowed<T, S>;
-declare function pickBy<T extends object>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): (data: T) => EnumeratedPartial<T>;
-//#endregion
-export { pickBy };
-//# sourceMappingURL=pick-by.d.ts.map

package/dist/pick-by.d.ts.map

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

package/dist/pick.d.cts

@@ -1,55 +0,0 @@
-import { t as TupleParts } from "./tuple-parts-CzQQupgi.cjs";
-import { n as IsBounded, t as IsBoundedRecord } from "./is-bounded-record-DV6ZQk9H.cjs";
-import { t as PartitionByUnion } from "./partition-by-union-BztEpKVh.cjs";
-import { EmptyObject, IsNever, KeysOfUnion, Writable } from "type-fest";
-
-//#region src/pick.d.ts
-type PickFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = T extends unknown ? Keys extends unknown ? IsNever<Extract<Keys[number], keyof T>> extends true ? EmptyObject : Writable<IsBoundedRecord<T> extends true ? PickBoundedFromArray<T, Keys> : PickUnbounded<T, Extract<Keys[number], keyof T>>> : never : never;
-/**
- * Bounded records have bounded keys and result in a bounded output. The only
- * question left is whether to add the prop as-is, or make it optional. This
- * can be determined by the part of the keys array the prop is defined in, and
- * the way that element is defined: if the array contains a singular literal
- * key in either the required prefix or the suffix, we know that prop should be
- * picked as-is, otherwise, the key might not be present in the keys array so it
- * can only be picked optionally.
- */
-type PickBoundedFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = Pick<T, Extract<PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular'], keyof T>> & Partial<Pick<T, Extract<PartitionByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | PartitionByUnion<TupleParts<Keys>['suffix']>['union'], keyof T>>>;
-/**
- * The built-in `Pick` is weird when it comes to picking bounded keys from
- * unbounded records. It reconstructs the output object regardless of the shape
- * of the input: `Pick<Record<string, "world">, "hello">` results in the type
- * `{ hello: "world" }`, but you'd expect it to be optional because we don't
- * know if the record contains a `hello` prop or not!
- *
- * !Important: We assume T is unbounded and don't test for it!
- *
- * See: https://www.typescriptlang.org/play/?#code/PTAEE0HsFcHIBNQFMAeAHJBjALqAGqNpKAEZKigAGA3qABZIA2jkA-AFygBEA7pAE6N4XUAF9KAGlLRcAQ0ayAzgChsATwz5QAXlAAFAJaYA1gB4ASlgHxTi7PwMA7AOZTeAoVwB8bhs0jeANzKIBSgAHqsykA.
- */
-type PickUnbounded<T, Keys extends keyof T> = IsBounded<Keys> extends true ? Partial<Pick<T, Keys>> : Pick<T, Keys>;
-/**
- * Creates an object composed of the picked `data` properties.
- *
- * @param keys - The property names.
- * @signature P.pick([prop1, prop2])(object)
- * @example
- *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.pick(['a', 'd'])) // => { a: 1, d: 4 }
- * @dataLast
- * @category Object
- */
-declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(keys: Keys): (data: T) => PickFromArray<T, Keys>;
-/**
- * Creates an object composed of the picked `data` properties.
- *
- * @param data - The target object.
- * @param keys - The property names.
- * @signature P.pick(object, [prop1, prop2])
- * @example
- *    P.pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }
- * @dataFirst
- * @category Object
- */
-declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(data: T, keys: Keys): PickFromArray<T, Keys>;
-//#endregion
-export { pick };
-//# sourceMappingURL=pick.d.cts.map

package/dist/pick.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pick.d.cts","names":[],"sources":["../src/pick.ts"],"sourcesContent":[],"mappings":";;;;;;KAOK,8BAA8B,cAAc,YAAY,OAEzD,oBACE,uBAOE,QAAQ,QAAQ,oBAAoB,mBAClC,cAIA,SACA,gBAAgB,kBACZ,qBAAqB,GAAG,QACxB,cAAc,GAAG,QAAQ,oBAAoB;AArBI;;;;;;;;;KAmC1D,oBAtBG,CAAA,CAAA,EAAA,aAsBkC,aAtBlC,CAsBgD,WAtBhD,CAsB4D,CAtB5D,CAAA,CAAA,CAAA,GAwBJ,IAxBI,CAyBJ,CAzBI,EA4BJ,OA5BI,CA6BA,gBA7BA,CA6BiB,UA7BjB,CA6B4B,IA7B5B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GA8BA,gBA9BA,CA8BiB,UA9BjB,CA8B4B,IA9B5B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,EAAA,MA+BI,CA/BJ,CAAA,CAAA,GAmCJ,OAnCI,CAoCJ,IApCI,CAqCF,CArCE,EAwCF,OAxCE,CAyCE,gBAzCF,CAyCmB,UAzCnB,CAyC8B,IAzC9B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,OAAA,CAAA,GA2CE,UA3CF,CA2Ca,IA3Cb,CAAA,CAAA,UAAA,CAAA,CAAA,MAAA,CAAA,GA4CE,UA5CF,CA4Ca,IA5Cb,CAAA,CAAA,MAAA,CAAA,GA6CE,gBA7CF,CA6CmB,UA7CnB,CA6C8B,IA7C9B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,OAAA,CAAA,EAAA,MA8CM,CA9CN,CAAA,CAAA,CAAA;;;;;;;;;;;;KA8DH,aAzDK,CAAA,CAAA,EAAA,aAAA,MAyD+B,CAzD/B,CAAA,GAyDoC,SAzDpC,CAyD8C,IAzD9C,CAAA,SAAA,IAAA,GAyDmE,OAzDnE,CAyD2E,IAzD3E,CAyDgF,CAzDhF,EAyDmF,IAzDnF,CAAA,CAAA,GAyD4F,IAzD5F,CAyDiG,CAzDjG,EAyDoG,IAzDpG,CAAA;;AAAQ;;;;;;;;;AAyBO,iBA4CT,IA5CS,CAAA,UAAA,MAAA,EAAA,mBA8CJ,aA9CI,CA8CU,WA9CV,CA8CsB,CA9CtB,CAAA,CAAA,CAAA,CAAA,IAAA,EA+CjB,IA/CiB,CAAA,EAAA,CAAA,IAAA,EA+CH,CA/CG,EAAA,GA+CG,aA/CH,CA+CiB,CA/CjB,EA+CoB,IA/CpB,CAAA;;;;;;;;;;;;AAcf,iBA8CM,IA9CN,CAAA,UAAA,MAAA,EAAA,mBAgDW,aAhDX,CAgDyB,WAhDzB,CAgDqC,CAhDrC,CAAA,CAAA,CAAA,CAAA,IAAA,EAiDF,CAjDE,EAAA,IAAA,EAiDO,IAjDP,CAAA,EAiDc,aAjDd,CAiD4B,CAjD5B,EAiD+B,IAjD/B,CAAA"}

package/dist/pick.d.ts

@@ -1,55 +0,0 @@
-import { t as TupleParts } from "./tuple-parts-BYI4o8Vk.js";
-import { n as IsBounded, t as IsBoundedRecord } from "./is-bounded-record-Bx4n8QB0.js";
-import { t as PartitionByUnion } from "./partition-by-union-DnfiiEMU.js";
-import { EmptyObject, IsNever, KeysOfUnion, Writable } from "type-fest";
-
-//#region src/pick.d.ts
-type PickFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = T extends unknown ? Keys extends unknown ? IsNever<Extract<Keys[number], keyof T>> extends true ? EmptyObject : Writable<IsBoundedRecord<T> extends true ? PickBoundedFromArray<T, Keys> : PickUnbounded<T, Extract<Keys[number], keyof T>>> : never : never;
-/**
- * Bounded records have bounded keys and result in a bounded output. The only
- * question left is whether to add the prop as-is, or make it optional. This
- * can be determined by the part of the keys array the prop is defined in, and
- * the way that element is defined: if the array contains a singular literal
- * key in either the required prefix or the suffix, we know that prop should be
- * picked as-is, otherwise, the key might not be present in the keys array so it
- * can only be picked optionally.
- */
-type PickBoundedFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = Pick<T, Extract<PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular'], keyof T>> & Partial<Pick<T, Extract<PartitionByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | PartitionByUnion<TupleParts<Keys>['suffix']>['union'], keyof T>>>;
-/**
- * The built-in `Pick` is weird when it comes to picking bounded keys from
- * unbounded records. It reconstructs the output object regardless of the shape
- * of the input: `Pick<Record<string, "world">, "hello">` results in the type
- * `{ hello: "world" }`, but you'd expect it to be optional because we don't
- * know if the record contains a `hello` prop or not!
- *
- * !Important: We assume T is unbounded and don't test for it!
- *
- * See: https://www.typescriptlang.org/play/?#code/PTAEE0HsFcHIBNQFMAeAHJBjALqAGqNpKAEZKigAGA3qABZIA2jkA-AFygBEA7pAE6N4XUAF9KAGlLRcAQ0ayAzgChsATwz5QAXlAAFAJaYA1gB4ASlgHxTi7PwMA7AOZTeAoVwB8bhs0jeANzKIBSgAHqsykA.
- */
-type PickUnbounded<T, Keys extends keyof T> = IsBounded<Keys> extends true ? Partial<Pick<T, Keys>> : Pick<T, Keys>;
-/**
- * Creates an object composed of the picked `data` properties.
- *
- * @param keys - The property names.
- * @signature P.pick([prop1, prop2])(object)
- * @example
- *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.pick(['a', 'd'])) // => { a: 1, d: 4 }
- * @dataLast
- * @category Object
- */
-declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(keys: Keys): (data: T) => PickFromArray<T, Keys>;
-/**
- * Creates an object composed of the picked `data` properties.
- *
- * @param data - The target object.
- * @param keys - The property names.
- * @signature P.pick(object, [prop1, prop2])
- * @example
- *    P.pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }
- * @dataFirst
- * @category Object
- */
-declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(data: T, keys: Keys): PickFromArray<T, Keys>;
-//#endregion
-export { pick };
-//# sourceMappingURL=pick.d.ts.map

package/dist/pick.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pick.d.ts","names":[],"sources":["../src/pick.ts"],"sourcesContent":[],"mappings":";;;;;;KAOK,8BAA8B,cAAc,YAAY,OAEzD,oBACE,uBAOE,QAAQ,QAAQ,oBAAoB,mBAClC,cAIA,SACA,gBAAgB,kBACZ,qBAAqB,GAAG,QACxB,cAAc,GAAG,QAAQ,oBAAoB;AArBI;;;;;;;;;KAmC1D,oBAtBG,CAAA,CAAA,EAAA,aAsBkC,aAtBlC,CAsBgD,WAtBhD,CAsB4D,CAtB5D,CAAA,CAAA,CAAA,GAwBJ,IAxBI,CAyBJ,CAzBI,EA4BJ,OA5BI,CA6BA,gBA7BA,CA6BiB,UA7BjB,CA6B4B,IA7B5B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GA8BA,gBA9BA,CA8BiB,UA9BjB,CA8B4B,IA9B5B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,EAAA,MA+BI,CA/BJ,CAAA,CAAA,GAmCJ,OAnCI,CAoCJ,IApCI,CAqCF,CArCE,EAwCF,OAxCE,CAyCE,gBAzCF,CAyCmB,UAzCnB,CAyC8B,IAzC9B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,OAAA,CAAA,GA2CE,UA3CF,CA2Ca,IA3Cb,CAAA,CAAA,UAAA,CAAA,CAAA,MAAA,CAAA,GA4CE,UA5CF,CA4Ca,IA5Cb,CAAA,CAAA,MAAA,CAAA,GA6CE,gBA7CF,CA6CmB,UA7CnB,CA6C8B,IA7C9B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,OAAA,CAAA,EAAA,MA8CM,CA9CN,CAAA,CAAA,CAAA;;;;;;;;;;;;KA8DH,aAzDK,CAAA,CAAA,EAAA,aAAA,MAyD+B,CAzD/B,CAAA,GAyDoC,SAzDpC,CAyD8C,IAzD9C,CAAA,SAAA,IAAA,GAyDmE,OAzDnE,CAyD2E,IAzD3E,CAyDgF,CAzDhF,EAyDmF,IAzDnF,CAAA,CAAA,GAyD4F,IAzD5F,CAyDiG,CAzDjG,EAyDoG,IAzDpG,CAAA;;AAAQ;;;;;;;;;AAyBO,iBA4CT,IA5CS,CAAA,UAAA,MAAA,EAAA,mBA8CJ,aA9CI,CA8CU,WA9CV,CA8CsB,CA9CtB,CAAA,CAAA,CAAA,CAAA,IAAA,EA+CjB,IA/CiB,CAAA,EAAA,CAAA,IAAA,EA+CH,CA/CG,EAAA,GA+CG,aA/CH,CA+CiB,CA/CjB,EA+CoB,IA/CpB,CAAA;;;;;;;;;;;;AAcf,iBA8CM,IA9CN,CAAA,UAAA,MAAA,EAAA,mBAgDW,aAhDX,CAgDyB,WAhDzB,CAgDqC,CAhDrC,CAAA,CAAA,CAAA,CAAA,IAAA,EAiDF,CAjDE,EAAA,IAAA,EAiDO,IAjDP,CAAA,EAiDc,aAjDd,CAiD4B,CAjD5B,EAiD+B,IAjD/B,CAAA"}

package/dist/pipe-CB7Lufqv.cjs

@@ -1 +0,0 @@
-const e=require(`./utility-evaluators-CAbODbuk.cjs`);function t(e,...t){let a=e,o=t.map(e=>`lazy`in e?r(e):void 0),s=0;for(;s<t.length;){if(o[s]===void 0||!i(a)){let e=t[s];a=e(a),s+=1;continue}let e=[];for(let n=s;n<t.length;n++){let t=o[n];if(t===void 0||(e.push(t),t.isSingle))break}let r=[];for(let t of a)if(n(t,r,e))break;let{isSingle:c}=e.at(-1);a=c?r[0]:r,s+=e.length}return a}function n(t,r,i){if(i.length===0)return r.push(t),!1;let a=t,o=e.t,s=!1;for(let[e,t]of i.entries()){let{index:c,items:l}=t;if(l.push(a),o=t(a,c,l),t.index+=1,o.hasNext){if(o.hasMany??!1){for(let t of o.next)if(n(t,r,i.slice(e+1)))return!0;return s}a=o.next}if(!o.hasNext)break;o.done&&(s=!0)}return o.hasNext&&r.push(a),s}function r(e){let{lazy:t,lazyArgs:n}=e,r=t(...n);return Object.assign(r,{isSingle:t.single??!1,index:0,items:[]})}function i(e){return typeof e==`string`||typeof e==`object`&&!!e&&Symbol.iterator in e}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});

package/dist/pipe-CZKusDA-.js

@@ -1,2 +0,0 @@
-import{t as e}from"./utility-evaluators-Boc-TMbq.js";function t(e,...t){let a=e,o=t.map(e=>`lazy`in e?r(e):void 0),s=0;for(;s<t.length;){if(o[s]===void 0||!i(a)){let e=t[s];a=e(a),s+=1;continue}let e=[];for(let n=s;n<t.length;n++){let t=o[n];if(t===void 0||(e.push(t),t.isSingle))break}let r=[];for(let t of a)if(n(t,r,e))break;let{isSingle:c}=e.at(-1);a=c?r[0]:r,s+=e.length}return a}function n(t,r,i){if(i.length===0)return r.push(t),!1;let a=t,o=e,s=!1;for(let[e,t]of i.entries()){let{index:c,items:l}=t;if(l.push(a),o=t(a,c,l),t.index+=1,o.hasNext){if(o.hasMany??!1){for(let t of o.next)if(n(t,r,i.slice(e+1)))return!0;return s}a=o.next}if(!o.hasNext)break;o.done&&(s=!0)}return o.hasNext&&r.push(a),s}function r(e){let{lazy:t,lazyArgs:n}=e,r=t(...n);return Object.assign(r,{isSingle:t.single??!1,index:0,items:[]})}function i(e){return typeof e==`string`||typeof e==`object`&&!!e&&Symbol.iterator in e}export{t};
-//# sourceMappingURL=pipe-CZKusDA-.js.map

package/dist/pipe-CZKusDA-.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipe-CZKusDA-.js","names":["lazySequence: Array<PreparedLazyFunction>","accumulator: Array<unknown>","lazyResult: LazyResult<any>"],"sources":["../src/pipe.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n/* eslint-disable jsdoc/check-param-names -- we don't document the op params, it'd be redundant */\n\nimport type { LazyDefinition } from './internal/types/lazy-definition';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype PreparedLazyFunction = LazyEvaluator & {\n  readonly isSingle: boolean;\n\n  // These are intentionally mutable, they maintain the lazy piped state.\n  index: number;\n  items: Array<unknown>;\n};\n\ntype LazyFunction = LazyDefinition & ((input: unknown) => unknown);\n\n/**\n * Performs left-to-right function composition, passing data through functions\n * in sequence. Each function receives the output of the previous function,\n * creating a readable top-to-bottom data flow that matches how the\n * transformation is executed. This enables converting deeply nested function\n * calls into clear, sequential steps without temporary variables.\n *\n * When consecutive functions with a `lazy` tag (e.g., `map`, `filter`, `take`,\n * `drop`, `forEach`, etc...) are used together, they process data item-by-item\n * rather than creating intermediate arrays. This enables early termination\n * when only partial results are needed, improving performance for large\n * datasets and expensive operations.\n *\n * Functions are only evaluated lazily when their data-last form is used\n * directly in the pipe. To disable lazy evaluation, use data-first calls via\n * arrow functions: `($) => map($, callback)` instead of `map(callback)`.\n *\n * Any function can be used in pipes, not just Remeda utilities. For creating\n * custom functions with currying and lazy evaluation support, see the `purry`\n * utility.\n *\n * A \"headless\" variant `piped` is available for creating reusable pipe\n * functions without initial data.\n *\n * IMPORTANT: During lazy evaluation, callbacks using the third parameter (the\n * input array) receive only items processed up to that point, not the complete\n * array.\n *\n * @param data - The input data.\n * @param functions - A sequence of functions that take one argument and\n * return a value.\n * @signature\n *   P.pipe(data, ...functions);\n * @example\n *    P.pipe([1, 2, 3], P.map(P.multiply(3))); //=> [3, 6, 9]\n *\n *    // = Early termination with lazy evaluation =\n *    P.pipe(\n *      hugeArray,\n *      P.map(expensiveComputation),\n *      P.filter(complexPredicate),\n *      // Only processes items until 2 results are found, then stops.\n *      // Most of hugeArray never gets processed.\n *      P.take(2),\n *    );\n *\n *    // = Custom logic within a pipe =\n *    P.pipe(\n *      input,\n *      P.toLowerCase(),\n *      normalize,\n *      ($) => validate($, CONFIG),\n *      P.split(\",\"),\n *      P.unique(),\n *    );\n *\n *    // = Migrating nested transformations to pipes =\n *    // Nested\n *    const result = P.prop(\n *      P.mapValues(P.groupByProp(users, \"department\"), P.length()),\n *      \"engineering\",\n *    );\n *\n *    // Piped\n *    const result = P.pipe(\n *      users,\n *      P.groupByProp(\"department\"),\n *      P.mapValues(P.length()),\n *      P.prop(\"engineering\"),\n *    );\n *\n *    // = Using the 3rd param of a callback =\n *    // The following would print out `data` in its entirety for each value\n *    // of `data`.\n *    P.forEach([1, 2, 3, 4], (_item, _index, data) => {\n *      console.log(data);\n *    }); //=> \"[1, 2, 3, 4]\" logged 4 times\n *\n *    // But with `pipe` data would only contain the items up to the current\n *    // index\n *    P.pipe([1, 2, 3, 4], P.forEach((_item, _index, data) => {\n *      console.log(data);\n *    })); //=> \"[1]\", \"[1, 2]\", \"[1, 2, 3]\", \"[1, 2, 3, 4]\"\n * @dataFirst\n * @category Function\n */\nexport function pipe<A>(data: A): A;\n\nexport function pipe<A, B>(data: A, funcA: (input: A) => B): B;\n\nexport function pipe<A, B, C>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n): C;\n\nexport function pipe<A, B, C, D>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n): D;\n\nexport function pipe<A, B, C, D, E>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n): E;\n\nexport function pipe<A, B, C, D, E, F>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n): F;\n\nexport function pipe<A, B, C, D, E, F, G>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n): G;\n\nexport function pipe<A, B, C, D, E, F, G, H>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n): H;\n\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n): I;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n): J;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n): K;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n): L;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n): M;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n): N;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n): O;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n  funcO: (input: O) => P,\n): P;\n\nexport function pipe(\n  input: unknown,\n  ...functions: ReadonlyArray<LazyFunction | ((value: any) => unknown)>\n): any {\n  let output = input;\n\n  const lazyFunctions = functions.map((op) =>\n    'lazy' in op ? prepareLazyFunction(op) : undefined);\n\n  let functionIndex = 0;\n  while (functionIndex < functions.length) {\n    const lazyFunction = lazyFunctions[functionIndex];\n    if (lazyFunction === undefined || !isIterable(output)) {\n      const func = functions[functionIndex]!;\n      output = func(output);\n      functionIndex += 1;\n      continue;\n    }\n\n    const lazySequence: Array<PreparedLazyFunction> = [];\n    for (let index = functionIndex; index < functions.length; index++) {\n      const lazyOp = lazyFunctions[index];\n      if (lazyOp === undefined) {\n        break;\n      }\n\n      lazySequence.push(lazyOp);\n      if (lazyOp.isSingle) {\n        break;\n      }\n    }\n\n    const accumulator: Array<unknown> = [];\n\n    for (const value of output) {\n      const shouldExitEarly = processItem(value, accumulator, lazySequence);\n      if (shouldExitEarly) {\n        break;\n      }\n    }\n\n    const { isSingle } = lazySequence.at(-1)!;\n    output = isSingle ? accumulator[0] : accumulator;\n    functionIndex += lazySequence.length;\n  }\n\n  return output;\n}\n\nfunction processItem(\n  item: unknown,\n  accumulator: Array<unknown>,\n  lazySequence: ReadonlyArray<PreparedLazyFunction>,\n): boolean {\n  if (lazySequence.length === 0) {\n    accumulator.push(item);\n    return false;\n  }\n\n  let currentItem = item;\n\n  let lazyResult: LazyResult<any> = SKIP_ITEM;\n  let isDone = false;\n  for (const [functionsIndex, lazyFn] of lazySequence.entries()) {\n    const { index, items } = lazyFn;\n    items.push(currentItem);\n    lazyResult = lazyFn(currentItem, index, items);\n    lazyFn.index += 1;\n    if (lazyResult.hasNext) {\n      if (lazyResult.hasMany ?? false) {\n        for (const subItem of lazyResult.next as ReadonlyArray<unknown>) {\n          const subResult = processItem(\n            subItem,\n            accumulator,\n            lazySequence.slice(functionsIndex + 1),\n          );\n          if (subResult) {\n            return true;\n          }\n        }\n        return isDone;\n      }\n      currentItem = lazyResult.next;\n    }\n    if (!lazyResult.hasNext) {\n      break;\n    }\n    // process remaining functions in the pipe\n    // but don't process remaining elements in the input array\n    if (lazyResult.done) {\n      isDone = true;\n    }\n  }\n  if (lazyResult.hasNext) {\n    accumulator.push(currentItem);\n  }\n  return isDone;\n}\n\nfunction prepareLazyFunction(func: LazyFunction): PreparedLazyFunction {\n  const { lazy, lazyArgs } = func;\n  const fn = lazy(...lazyArgs);\n  return Object.assign(fn, {\n    isSingle: lazy.single ?? false,\n    index: 0,\n    items: [] as Array<unknown>,\n  });\n}\n\nfunction isIterable(something: unknown): something is Iterable<unknown> {\n  // Check for null and undefined to avoid errors when accessing Symbol.iterator\n  return (\n    typeof something === 'string'\n    || (typeof something === 'object'\n      && something !== null\n      && Symbol.iterator in something)\n  );\n}\n"],"mappings":"qDA2RA,SAAgB,EACd,EACA,GAAG,EACE,CACL,IAAI,EAAS,EAEP,EAAgB,EAAU,IAAK,GACnC,SAAU,EAAK,EAAoB,EAAG,CAAG,IAAA,GAAU,CAEjD,EAAgB,EACpB,KAAO,EAAgB,EAAU,QAAQ,CAEvC,GADqB,EAAc,KACd,IAAA,IAAa,CAAC,EAAW,EAAO,CAAE,CACrD,IAAM,EAAO,EAAU,GACvB,EAAS,EAAK,EAAO,CACrB,GAAiB,EACjB,SAGF,IAAMA,EAA4C,EAAE,CACpD,IAAK,IAAI,EAAQ,EAAe,EAAQ,EAAU,OAAQ,IAAS,CACjE,IAAM,EAAS,EAAc,GAM7B,GALI,IAAW,IAAA,KAIf,EAAa,KAAK,EAAO,CACrB,EAAO,UACT,MAIJ,IAAMC,EAA8B,EAAE,CAEtC,IAAK,IAAM,KAAS,EAElB,GADwB,EAAY,EAAO,EAAa,EAAa,CAEnE,MAIJ,GAAM,CAAE,YAAa,EAAa,GAAG,GAAG,CACxC,EAAS,EAAW,EAAY,GAAK,EACrC,GAAiB,EAAa,OAGhC,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACS,CACT,GAAI,EAAa,SAAW,EAE1B,OADA,EAAY,KAAK,EAAK,CACf,GAGT,IAAI,EAAc,EAEdC,EAA8B,EAC9B,EAAS,GACb,IAAK,GAAM,CAAC,EAAgB,KAAW,EAAa,SAAS,CAAE,CAC7D,GAAM,CAAE,QAAO,SAAU,EAIzB,GAHA,EAAM,KAAK,EAAY,CACvB,EAAa,EAAO,EAAa,EAAO,EAAM,CAC9C,EAAO,OAAS,EACZ,EAAW,QAAS,CACtB,GAAI,EAAW,SAAW,GAAO,CAC/B,IAAK,IAAM,KAAW,EAAW,KAM/B,GALkB,EAChB,EACA,EACA,EAAa,MAAM,EAAiB,EAAE,CACvC,CAEC,MAAO,GAGX,OAAO,EAET,EAAc,EAAW,KAE3B,GAAI,CAAC,EAAW,QACd,MAIE,EAAW,OACb,EAAS,IAMb,OAHI,EAAW,SACb,EAAY,KAAK,EAAY,CAExB,EAGT,SAAS,EAAoB,EAA0C,CACrE,GAAM,CAAE,OAAM,YAAa,EACrB,EAAK,EAAK,GAAG,EAAS,CAC5B,OAAO,OAAO,OAAO,EAAI,CACvB,SAAU,EAAK,QAAU,GACzB,MAAO,EACP,MAAO,EAAE,CACV,CAAC,CAGJ,SAAS,EAAW,EAAoD,CAEtE,OACE,OAAO,GAAc,UACjB,OAAO,GAAc,YACpB,GACA,OAAO,YAAY"}

package/dist/pipe.d.cts

@@ -1,106 +0,0 @@
-//#region src/pipe.d.ts
-/**
- * Performs left-to-right function composition, passing data through functions
- * in sequence. Each function receives the output of the previous function,
- * creating a readable top-to-bottom data flow that matches how the
- * transformation is executed. This enables converting deeply nested function
- * calls into clear, sequential steps without temporary variables.
- *
- * When consecutive functions with a `lazy` tag (e.g., `map`, `filter`, `take`,
- * `drop`, `forEach`, etc...) are used together, they process data item-by-item
- * rather than creating intermediate arrays. This enables early termination
- * when only partial results are needed, improving performance for large
- * datasets and expensive operations.
- *
- * Functions are only evaluated lazily when their data-last form is used
- * directly in the pipe. To disable lazy evaluation, use data-first calls via
- * arrow functions: `($) => map($, callback)` instead of `map(callback)`.
- *
- * Any function can be used in pipes, not just Remeda utilities. For creating
- * custom functions with currying and lazy evaluation support, see the `purry`
- * utility.
- *
- * A "headless" variant `piped` is available for creating reusable pipe
- * functions without initial data.
- *
- * IMPORTANT: During lazy evaluation, callbacks using the third parameter (the
- * input array) receive only items processed up to that point, not the complete
- * array.
- *
- * @param data - The input data.
- * @param functions - A sequence of functions that take one argument and
- * return a value.
- * @signature
- *   P.pipe(data, ...functions);
- * @example
- *    P.pipe([1, 2, 3], P.map(P.multiply(3))); //=> [3, 6, 9]
- *
- *    // = Early termination with lazy evaluation =
- *    P.pipe(
- *      hugeArray,
- *      P.map(expensiveComputation),
- *      P.filter(complexPredicate),
- *      // Only processes items until 2 results are found, then stops.
- *      // Most of hugeArray never gets processed.
- *      P.take(2),
- *    );
- *
- *    // = Custom logic within a pipe =
- *    P.pipe(
- *      input,
- *      P.toLowerCase(),
- *      normalize,
- *      ($) => validate($, CONFIG),
- *      P.split(","),
- *      P.unique(),
- *    );
- *
- *    // = Migrating nested transformations to pipes =
- *    // Nested
- *    const result = P.prop(
- *      P.mapValues(P.groupByProp(users, "department"), P.length()),
- *      "engineering",
- *    );
- *
- *    // Piped
- *    const result = P.pipe(
- *      users,
- *      P.groupByProp("department"),
- *      P.mapValues(P.length()),
- *      P.prop("engineering"),
- *    );
- *
- *    // = Using the 3rd param of a callback =
- *    // The following would print out `data` in its entirety for each value
- *    // of `data`.
- *    P.forEach([1, 2, 3, 4], (_item, _index, data) => {
- *      console.log(data);
- *    }); //=> "[1, 2, 3, 4]" logged 4 times
- *
- *    // But with `pipe` data would only contain the items up to the current
- *    // index
- *    P.pipe([1, 2, 3, 4], P.forEach((_item, _index, data) => {
- *      console.log(data);
- *    })); //=> "[1]", "[1, 2]", "[1, 2, 3]", "[1, 2, 3, 4]"
- * @dataFirst
- * @category Function
- */
-declare function pipe<A>(data: A): A;
-declare function pipe<A, B>(data: A, funcA: (input: A) => B): B;
-declare function pipe<A, B, C>(data: A, funcA: (input: A) => B, funcB: (input: B) => C): C;
-declare function pipe<A, B, C, D>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D): D;
-declare function pipe<A, B, C, D, E>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E): E;
-declare function pipe<A, B, C, D, E, F>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F): F;
-declare function pipe<A, B, C, D, E, F, G>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G): G;
-declare function pipe<A, B, C, D, E, F, G, H>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H): H;
-declare function pipe<A, B, C, D, E, F, G, H, I>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I): I;
-declare function pipe<A, B, C, D, E, F, G, H, I, J>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J): J;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K): K;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L): L;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M): M;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M, funcM: (input: M) => N): N;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M, funcM: (input: M) => N, funcN: (input: N) => O): O;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M, funcM: (input: M) => N, funcN: (input: N) => O, funcO: (input: O) => P): P;
-//#endregion
-export { pipe };
-//# sourceMappingURL=pipe.d.cts.map

package/dist/pipe.d.cts.map

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

package/dist/pipe.d.ts

@@ -1,106 +0,0 @@
-//#region src/pipe.d.ts
-/**
- * Performs left-to-right function composition, passing data through functions
- * in sequence. Each function receives the output of the previous function,
- * creating a readable top-to-bottom data flow that matches how the
- * transformation is executed. This enables converting deeply nested function
- * calls into clear, sequential steps without temporary variables.
- *
- * When consecutive functions with a `lazy` tag (e.g., `map`, `filter`, `take`,
- * `drop`, `forEach`, etc...) are used together, they process data item-by-item
- * rather than creating intermediate arrays. This enables early termination
- * when only partial results are needed, improving performance for large
- * datasets and expensive operations.
- *
- * Functions are only evaluated lazily when their data-last form is used
- * directly in the pipe. To disable lazy evaluation, use data-first calls via
- * arrow functions: `($) => map($, callback)` instead of `map(callback)`.
- *
- * Any function can be used in pipes, not just Remeda utilities. For creating
- * custom functions with currying and lazy evaluation support, see the `purry`
- * utility.
- *
- * A "headless" variant `piped` is available for creating reusable pipe
- * functions without initial data.
- *
- * IMPORTANT: During lazy evaluation, callbacks using the third parameter (the
- * input array) receive only items processed up to that point, not the complete
- * array.
- *
- * @param data - The input data.
- * @param functions - A sequence of functions that take one argument and
- * return a value.
- * @signature
- *   P.pipe(data, ...functions);
- * @example
- *    P.pipe([1, 2, 3], P.map(P.multiply(3))); //=> [3, 6, 9]
- *
- *    // = Early termination with lazy evaluation =
- *    P.pipe(
- *      hugeArray,
- *      P.map(expensiveComputation),
- *      P.filter(complexPredicate),
- *      // Only processes items until 2 results are found, then stops.
- *      // Most of hugeArray never gets processed.
- *      P.take(2),
- *    );
- *
- *    // = Custom logic within a pipe =
- *    P.pipe(
- *      input,
- *      P.toLowerCase(),
- *      normalize,
- *      ($) => validate($, CONFIG),
- *      P.split(","),
- *      P.unique(),
- *    );
- *
- *    // = Migrating nested transformations to pipes =
- *    // Nested
- *    const result = P.prop(
- *      P.mapValues(P.groupByProp(users, "department"), P.length()),
- *      "engineering",
- *    );
- *
- *    // Piped
- *    const result = P.pipe(
- *      users,
- *      P.groupByProp("department"),
- *      P.mapValues(P.length()),
- *      P.prop("engineering"),
- *    );
- *
- *    // = Using the 3rd param of a callback =
- *    // The following would print out `data` in its entirety for each value
- *    // of `data`.
- *    P.forEach([1, 2, 3, 4], (_item, _index, data) => {
- *      console.log(data);
- *    }); //=> "[1, 2, 3, 4]" logged 4 times
- *
- *    // But with `pipe` data would only contain the items up to the current
- *    // index
- *    P.pipe([1, 2, 3, 4], P.forEach((_item, _index, data) => {
- *      console.log(data);
- *    })); //=> "[1]", "[1, 2]", "[1, 2, 3]", "[1, 2, 3, 4]"
- * @dataFirst
- * @category Function
- */
-declare function pipe<A>(data: A): A;
-declare function pipe<A, B>(data: A, funcA: (input: A) => B): B;
-declare function pipe<A, B, C>(data: A, funcA: (input: A) => B, funcB: (input: B) => C): C;
-declare function pipe<A, B, C, D>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D): D;
-declare function pipe<A, B, C, D, E>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E): E;
-declare function pipe<A, B, C, D, E, F>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F): F;
-declare function pipe<A, B, C, D, E, F, G>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G): G;
-declare function pipe<A, B, C, D, E, F, G, H>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H): H;
-declare function pipe<A, B, C, D, E, F, G, H, I>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I): I;
-declare function pipe<A, B, C, D, E, F, G, H, I, J>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J): J;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K): K;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L): L;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M): M;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M, funcM: (input: M) => N): N;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M, funcM: (input: M) => N, funcN: (input: N) => O): O;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(data: A, funcA: (input: A) => B, funcB: (input: B) => C, funcC: (input: C) => D, funcD: (input: D) => E, funcE: (input: E) => F, funcF: (input: F) => G, funcG: (input: G) => H, funcH: (input: H) => I, funcI: (input: I) => J, funcJ: (input: J) => K, funcK: (input: K) => L, funcL: (input: L) => M, funcM: (input: M) => N, funcN: (input: N) => O, funcO: (input: O) => P): P;
-//#endregion
-export { pipe };
-//# sourceMappingURL=pipe.d.ts.map

package/dist/pipe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipe.d.ts","names":[],"sources":["../src/pipe.ts"],"sourcesContent":[],"mappings":";;AAwGA;AAEA;;;;;;AAEA;;;;;;;;AAMA;;;;;;;;;;AAOA;;;;;;;;;;;;AAQA;;;;;;;;;;;;;;AASA;;;;;;;;;;;;;;;;AAUA;;;;;;;;;;;;;;;;;;AAWgB,iBAvDA,IAuDI,CAAA,CAAA,CAAA,CAAA,IAAA,EAvDU,CAuDV,CAAA,EAvDc,CAuDd;AACZ,iBAtDQ,IAsDR,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAtDyB,CAsDzB,EAAA,KAAA,EAAA,CAAA,KAAA,EAtD2C,CAsD3C,EAAA,GAtDiD,CAsDjD,CAAA,EAtDqD,CAsDrD;AACS,iBArDD,IAqDC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EApDT,CAoDS,EAAA,KAAA,EAAA,CAAA,KAAA,EAnDA,CAmDA,EAAA,GAnDM,CAmDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAlDA,CAkDA,EAAA,GAlDM,CAkDN,CAAA,EAjDd,CAiDc;AAAM,iBA/CP,IA+CO,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EA9Cf,CA8Ce,EAAA,KAAA,EAAA,CAAA,KAAA,EA7CN,CA6CM,EAAA,GA7CA,CA6CA,EAAA,KAAA,EAAA,CAAA,KAAA,EA5CN,CA4CM,EAAA,GA5CA,CA4CA,EAAA,KAAA,EAAA,CAAA,KAAA,EA3CN,CA2CM,EAAA,GA3CA,CA2CA,CAAA,EA1CpB,CA0CoB;AACN,iBAzCD,IAyCC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAxCT,CAwCS,EAAA,KAAA,EAAA,CAAA,KAAA,EAvCA,CAuCA,EAAA,GAvCM,CAuCN,EAAA,KAAA,EAAA,CAAA,KAAA,EAtCA,CAsCA,EAAA,GAtCM,CAsCN,EAAA,KAAA,EAAA,CAAA,KAAA,EArCA,CAqCA,EAAA,GArCM,CAqCN,EAAA,KAAA,EAAA,CAAA,KAAA,EApCA,CAoCA,EAAA,GApCM,CAoCN,CAAA,EAnCd,CAmCc;AAAM,iBAjCP,IAiCO,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAhCf,CAgCe,EAAA,KAAA,EAAA,CAAA,KAAA,EA/BN,CA+BM,EAAA,GA/BA,CA+BA,EAAA,KAAA,EAAA,CAAA,KAAA,EA9BN,CA8BM,EAAA,GA9BA,CA8BA,EAAA,KAAA,EAAA,CAAA,KAAA,EA7BN,CA6BM,EAAA,GA7BA,CA6BA,EAAA,KAAA,EAAA,CAAA,KAAA,EA5BN,CA4BM,EAAA,GA5BA,CA4BA,EAAA,KAAA,EAAA,CAAA,KAAA,EA3BN,CA2BM,EAAA,GA3BA,CA2BA,CAAA,EA1BpB,CA0BoB;AACN,iBAzBD,IAyBC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAxBT,CAwBS,EAAA,KAAA,EAAA,CAAA,KAAA,EAvBA,CAuBA,EAAA,GAvBM,CAuBN,EAAA,KAAA,EAAA,CAAA,KAAA,EAtBA,CAsBA,EAAA,GAtBM,CAsBN,EAAA,KAAA,EAAA,CAAA,KAAA,EArBA,CAqBA,EAAA,GArBM,CAqBN,EAAA,KAAA,EAAA,CAAA,KAAA,EApBA,CAoBA,EAAA,GApBM,CAoBN,EAAA,KAAA,EAAA,CAAA,KAAA,EAnBA,CAmBA,EAAA,GAnBM,CAmBN,EAAA,KAAA,EAAA,CAAA,KAAA,EAlBA,CAkBA,EAAA,GAlBM,CAkBN,CAAA,EAjBd,CAiBc;AAAM,iBAfP,IAeO,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAdf,CAce,EAAA,KAAA,EAAA,CAAA,KAAA,EAbN,CAaM,EAAA,GAbA,CAaA,EAAA,KAAA,EAAA,CAAA,KAAA,EAZN,CAYM,EAAA,GAZA,CAYA,EAAA,KAAA,EAAA,CAAA,KAAA,EAXN,CAWM,EAAA,GAXA,CAWA,EAAA,KAAA,EAAA,CAAA,KAAA,EAVN,CAUM,EAAA,GAVA,CAUA,EAAA,KAAA,EAAA,CAAA,KAAA,EATN,CASM,EAAA,GATA,CASA,EAAA,KAAA,EAAA,CAAA,KAAA,EARN,CAQM,EAAA,GARA,CAQA,EAAA,KAAA,EAAA,CAAA,KAAA,EAPN,CAOM,EAAA,GAPA,CAOA,CAAA,EANpB,CAMoB;AACN,iBALD,IAKC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAJT,CAIS,EAAA,KAAA,EAAA,CAAA,KAAA,EAHA,CAGA,EAAA,GAHM,CAGN,EAAA,KAAA,EAAA,CAAA,KAAA,EAFA,CAEA,EAAA,GAFM,CAEN,EAAA,KAAA,EAAA,CAAA,KAAA,EADA,CACA,EAAA,GADM,CACN,EAAA,KAAA,EAAA,CAAA,KAAA,EAAA,CAAA,EAAA,GAAM,CAAN,EAAA,KAAA,EAAA,CAAA,KAAA,EACA,CADA,EAAA,GACM,CADN,EAAA,KAAA,EAAA,CAAA,KAAA,EAEA,CAFA,EAAA,GAEM,CAFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAGA,CAHA,EAAA,GAGM,CAHN,EAAA,KAAA,EAAA,CAAA,KAAA,EAIA,CAJA,EAAA,GAIM,CAJN,CAAA,EAKd,CALc;AAAM,iBAOP,IAPO,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAQf,CARe,EAAA,KAAA,EAAA,CAAA,KAAA,EASN,CATM,EAAA,GASA,CATA,EAAA,KAAA,EAAA,CAAA,KAAA,EAUN,CAVM,EAAA,GAUA,CAVA,EAAA,KAAA,EAAA,CAAA,KAAA,EAWN,CAXM,EAAA,GAWA,CAXA,EAAA,KAAA,EAAA,CAAA,KAAA,EAYN,CAZM,EAAA,GAYA,CAZA,EAAA,KAAA,EAAA,CAAA,KAAA,EAaN,CAbM,EAAA,GAaA,CAbA,EAAA,KAAA,EAAA,CAAA,KAAA,EAcN,CAdM,EAAA,GAcA,CAdA,EAAA,KAAA,EAAA,CAAA,KAAA,EAeN,CAfM,EAAA,GAeA,CAfA,EAAA,KAAA,EAAA,CAAA,KAAA,EAgBN,CAhBM,EAAA,GAgBA,CAhBA,EAAA,KAAA,EAAA,CAAA,KAAA,EAiBN,CAjBM,EAAA,GAiBA,CAjBA,CAAA,EAkBpB,CAlBoB;AACN,iBAmBD,IAnBC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAoBT,CApBS,EAAA,KAAA,EAAA,CAAA,KAAA,EAqBA,CArBA,EAAA,GAqBM,CArBN,EAAA,KAAA,EAAA,CAAA,KAAA,EAsBA,CAtBA,EAAA,GAsBM,CAtBN,EAAA,KAAA,EAAA,CAAA,KAAA,EAuBA,CAvBA,EAAA,GAuBM,CAvBN,EAAA,KAAA,EAAA,CAAA,KAAA,EAwBA,CAxBA,EAAA,GAwBM,CAxBN,EAAA,KAAA,EAAA,CAAA,KAAA,EAyBA,CAzBA,EAAA,GAyBM,CAzBN,EAAA,KAAA,EAAA,CAAA,KAAA,EA0BA,CA1BA,EAAA,GA0BM,CA1BN,EAAA,KAAA,EAAA,CAAA,KAAA,EA2BA,CA3BA,EAAA,GA2BM,CA3BN,EAAA,KAAA,EAAA,CAAA,KAAA,EA4BA,CA5BA,EAAA,GA4BM,CA5BN,EAAA,KAAA,EAAA,CAAA,KAAA,EA6BA,CA7BA,EAAA,GA6BM,CA7BN,EAAA,KAAA,EAAA,CAAA,KAAA,EA8BA,CA9BA,EAAA,GA8BM,CA9BN,CAAA,EA+Bd,CA/Bc;AAAM,iBAiCP,IAjCO,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAkCf,CAlCe,EAAA,KAAA,EAAA,CAAA,KAAA,EAmCN,CAnCM,EAAA,GAmCA,CAnCA,EAAA,KAAA,EAAA,CAAA,KAAA,EAoCN,CApCM,EAAA,GAoCA,CApCA,EAAA,KAAA,EAAA,CAAA,KAAA,EAqCN,CArCM,EAAA,GAqCA,CArCA,EAAA,KAAA,EAAA,CAAA,KAAA,EAsCN,CAtCM,EAAA,GAsCA,CAtCA,EAAA,KAAA,EAAA,CAAA,KAAA,EAuCN,CAvCM,EAAA,GAuCA,CAvCA,EAAA,KAAA,EAAA,CAAA,KAAA,EAwCN,CAxCM,EAAA,GAwCA,CAxCA,EAAA,KAAA,EAAA,CAAA,KAAA,EAyCN,CAzCM,EAAA,GAyCA,CAzCA,EAAA,KAAA,EAAA,CAAA,KAAA,EA0CN,CA1CM,EAAA,GA0CA,CA1CA,EAAA,KAAA,EAAA,CAAA,KAAA,EA2CN,CA3CM,EAAA,GA2CA,CA3CA,EAAA,KAAA,EAAA,CAAA,KAAA,EA4CN,CA5CM,EAAA,GA4CA,CA5CA,EAAA,KAAA,EAAA,CAAA,KAAA,EA6CN,CA7CM,EAAA,GA6CA,CA7CA,CAAA,EA8CpB,CA9CoB;AACN,iBA+CD,IA/CC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAgDT,CAhDS,EAAA,KAAA,EAAA,CAAA,KAAA,EAiDA,CAjDA,EAAA,GAiDM,CAjDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAkDA,CAlDA,EAAA,GAkDM,CAlDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAmDA,CAnDA,EAAA,GAmDM,CAnDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAoDA,CApDA,EAAA,GAoDM,CApDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAqDA,CArDA,EAAA,GAqDM,CArDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAsDA,CAtDA,EAAA,GAsDM,CAtDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAuDA,CAvDA,EAAA,GAuDM,CAvDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAwDA,CAxDA,EAAA,GAwDM,CAxDN,EAAA,KAAA,EAAA,CAAA,KAAA,EAyDA,CAzDA,EAAA,GAyDM,CAzDN,EAAA,KAAA,EAAA,CAAA,KAAA,EA0DA,CA1DA,EAAA,GA0DM,CA1DN,EAAA,KAAA,EAAA,CAAA,KAAA,EA2DA,CA3DA,EAAA,GA2DM,CA3DN,EAAA,KAAA,EAAA,CAAA,KAAA,EA4DA,CA5DA,EAAA,GA4DM,CA5DN,CAAA,EA6Dd,CA7Dc;AAAM,iBA+DP,IA/DO,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAgEf,CAhEe,EAAA,KAAA,EAAA,CAAA,KAAA,EAiEN,CAjEM,EAAA,GAiEA,CAjEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAkEN,CAlEM,EAAA,GAkEA,CAlEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAmEN,CAnEM,EAAA,GAmEA,CAnEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAoEN,CApEM,EAAA,GAoEA,CApEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAqEN,CArEM,EAAA,GAqEA,CArEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAsEN,CAtEM,EAAA,GAsEA,CAtEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAuEN,CAvEM,EAAA,GAuEA,CAvEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAwEN,CAxEM,EAAA,GAwEA,CAxEA,EAAA,KAAA,EAAA,CAAA,KAAA,EAyEN,CAzEM,EAAA,GAyEA,CAzEA,EAAA,KAAA,EAAA,CAAA,KAAA,EA0EN,CA1EM,EAAA,GA0EA,CA1EA,EAAA,KAAA,EAAA,CAAA,KAAA,EA2EN,CA3EM,EAAA,GA2EA,CA3EA,EAAA,KAAA,EAAA,CAAA,KAAA,EA4EN,CA5EM,EAAA,GA4EA,CA5EA,EAAA,KAAA,EAAA,CAAA,KAAA,EA6EN,CA7EM,EAAA,GA6EA,CA7EA,CAAA,EA8EpB,CA9EoB;AACN,iBA+ED,IA/EC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAgFT,CAhFS,EAAA,KAAA,EAAA,CAAA,KAAA,EAiFA,CAjFA,EAAA,GAiFM,CAjFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAkFA,CAlFA,EAAA,GAkFM,CAlFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAmFA,CAnFA,EAAA,GAmFM,CAnFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAoFA,CApFA,EAAA,GAoFM,CApFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAqFA,CArFA,EAAA,GAqFM,CArFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAsFA,CAtFA,EAAA,GAsFM,CAtFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAuFA,CAvFA,EAAA,GAuFM,CAvFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAwFA,CAxFA,EAAA,GAwFM,CAxFN,EAAA,KAAA,EAAA,CAAA,KAAA,EAyFA,CAzFA,EAAA,GAyFM,CAzFN,EAAA,KAAA,EAAA,CAAA,KAAA,EA0FA,CA1FA,EAAA,GA0FM,CA1FN,EAAA,KAAA,EAAA,CAAA,KAAA,EA2FA,CA3FA,EAAA,GA2FM,CA3FN,EAAA,KAAA,EAAA,CAAA,KAAA,EA4FA,CA5FA,EAAA,GA4FM,CA5FN,EAAA,KAAA,EAAA,CAAA,KAAA,EA6FA,CA7FA,EAAA,GA6FM,CA7FN,EAAA,KAAA,EAAA,CAAA,KAAA,EA8FA,CA9FA,EAAA,GA8FM,CA9FN,CAAA,EA+Fd,CA/Fc;AAAM,iBAiGP,IAjGO,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAkGf,CAlGe,EAAA,KAAA,EAAA,CAAA,KAAA,EAmGN,CAnGM,EAAA,GAmGA,CAnGA,EAAA,KAAA,EAAA,CAAA,KAAA,EAoGN,CApGM,EAAA,GAoGA,CApGA,EAAA,KAAA,EAAA,CAAA,KAAA,EAqGN,CArGM,EAAA,GAqGA,CArGA,EAAA,KAAA,EAAA,CAAA,KAAA,EAsGN,CAtGM,EAAA,GAsGA,CAtGA,EAAA,KAAA,EAAA,CAAA,KAAA,EAuGN,CAvGM,EAAA,GAuGA,CAvGA,EAAA,KAAA,EAAA,CAAA,KAAA,EAwGN,CAxGM,EAAA,GAwGA,CAxGA,EAAA,KAAA,EAAA,CAAA,KAAA,EAyGN,CAzGM,EAAA,GAyGA,CAzGA,EAAA,KAAA,EAAA,CAAA,KAAA,EA0GN,CA1GM,EAAA,GA0GA,CA1GA,EAAA,KAAA,EAAA,CAAA,KAAA,EA2GN,CA3GM,EAAA,GA2GA,CA3GA,EAAA,KAAA,EAAA,CAAA,KAAA,EA4GN,CA5GM,EAAA,GA4GA,CA5GA,EAAA,KAAA,EAAA,CAAA,KAAA,EA6GN,CA7GM,EAAA,GA6GA,CA7GA,EAAA,KAAA,EAAA,CAAA,KAAA,EA8GN,CA9GM,EAAA,GA8GA,CA9GA,EAAA,KAAA,EAAA,CAAA,KAAA,EA+GN,CA/GM,EAAA,GA+GA,CA/GA,EAAA,KAAA,EAAA,CAAA,KAAA,EAgHN,CAhHM,EAAA,GAgHA,CAhHA,EAAA,KAAA,EAAA,CAAA,KAAA,EAiHN,CAjHM,EAAA,GAiHA,CAjHA,CAAA,EAkHpB,CAlHoB"}

package/dist/piped.d.cts

@@ -1,31 +0,0 @@
-//#region src/piped.d.ts
-/**
- * A dataLast version of `pipe` that could be used to provide more complex
- * computations to functions that accept a function as a param (like `map`,
- * `filter`, `groupBy`, etc.).
- *
- * The first function must be always annotated. Other functions are
- * automatically inferred.
- *
- * @signature
- *    P.piped(...ops)(data);
- * @example
- *    P.filter(
- *      [{ a: 1 }, { a: 2 }, { a: 3 }],
- *      P.piped(
- *        P.prop('a'),
- *        (x) => x % 2 === 0,
- *      ),
- *    ); // => [{ a: 2 }]
- * @category Function
- */
-declare function piped<A, B>(op1: (input: A) => B): (value: A) => B;
-declare function piped<A, B, C>(op1: (input: A) => B, op2: (input: B) => C): (value: A) => C;
-declare function piped<A, B, C, D>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): (value: A) => D;
-declare function piped<A, B, C, D, E>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): (value: A) => E;
-declare function piped<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;
-declare function piped<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;
-declare function piped<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;
-//#endregion
-export { piped };
-//# sourceMappingURL=piped.d.cts.map