@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/find-index-BO_tEYVo.d.ts

@@ -1,50 +0,0 @@
-//#region src/find-index.d.ts
-/**
- * Returns the index of the first element in an array that satisfies the
- * provided testing function. If no elements satisfy the testing function, -1 is
- * returned.
- *
- * See also the `find` method, which returns the first element that satisfies
- * the testing function (rather than its index).
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return a `true` to indicate a matching element has been found, and a
- * `false` otherwise.
- * @returns The index of the first element in the array that passes the test.
- * Otherwise, -1.
- * @signature
- *    P.findIndex(data, predicate)
- * @example
- *    P.findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2
- * @dataFirst
- * @category Array
- */
-declare function findIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number;
-/**
- * Returns the index of the first element in an array that satisfies the
- * provided testing function. If no elements satisfy the testing function, -1 is
- * returned.
- *
- * See also the `find` method, which returns the first element that satisfies
- * the testing function (rather than its index).
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return a `true` to indicate a matching element has been found, and a
- * `false` otherwise.
- * @returns The index of the first element in the array that passes the test.
- * Otherwise, -1.
- * @signature
- *    P.findIndex(predicate)(data)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.findIndex(n => n % 2 === 0)
- *    ); // => 2
- * @dataLast
- * @category Array
- */
-declare function findIndex<T>(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { findIndex };
-//# sourceMappingURL=find-index-BO_tEYVo.d.ts.map

package/dist/find-index-BO_tEYVo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-index-BO_tEYVo.d.ts","names":[],"sources":["../src/find-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;;AA4BA;;;;;;;;;;;;iBA5BgB,mBACR,cAAc,uBACD,uBAAuB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBA0B1C,gCACK,uBAAuB,cAAc,wBAChD,cAAc"}

package/dist/find-last-CekkNCww.d.ts

@@ -1,62 +0,0 @@
-//#region src/find-last.d.ts
-/**
- * Iterates the array in reverse order and returns the value of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, undefined is returned.
- *
- * Similar functions:
- * `find` - If you need the first element that satisfies the provided testing function.
- * `findLastIndex` - If you need the index of the found element in the array.
- * `lastIndexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The last (highest-index) element in the array that satisfies the
- * provided testing function; undefined if no matching element is found.
- * @signature
- *    P.findLast(data, predicate)
- * @example
- *    P.findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3
- * @dataFirst
- * @category Array
- */
-declare function findLast<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
-declare function findLast<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
-/**
- * Iterates the array in reverse order and returns the value of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, undefined is returned.
- *
- * Similar functions:
- * `find` - If you need the first element that satisfies the provided testing function.
- * `findLastIndex` - If you need the index of the found element in the array.
- * `lastIndexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The last (highest-index) element in the array that satisfies the
- * provided testing function; undefined if no matching element is found.
- * @signature
- *    P.findLast(predicate)(data)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.findLast(n => n % 2 === 1)
- *    ) // => 3
- * @dataLast
- * @category Array
- */
-declare function findLast<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
-declare function findLast<T = never>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
-//#endregion
-export { findLast };
-//# sourceMappingURL=find-last-CekkNCww.d.ts.map

package/dist/find-last-CekkNCww.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-last-CekkNCww.d.ts","names":[],"sources":["../src/find-last.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;;;;;;AAIA;;;;;;;;;AAiCA;;;;;AAC6C,iBAtC7B,QAsC6B,CAAA,CAAA,EAAA,UAtCP,CAsCO,CAAA,CAAA,IAAA,EArCrC,aAqCqC,CArCvB,CAqCuB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EApCxB,CAoCwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EApCA,aAoCA,CApCc,CAoCd,CAAA,EAAA,GAAA,KAAA,IApC8B,CAoC9B,CAAA,EAnC1C,CAmC0C,GAAA,SAAA;AAA8B,iBAlC3D,QAkC2D,CAAA,CAAA,CAAA,CAAA,IAAA,EAjCnE,aAiCmE,CAjCrD,CAiCqD,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAhCtD,CAgCsD,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAhC9B,aAgC8B,CAhChB,CAgCgB,CAAA,EAAA,GAAA,OAAA,CAAA,EA/BxE,CA+BwE,GAAA,SAAA;;;;;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,sBAAsB,sBACjB,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,uCACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find-last-index-XB_3-4xj.d.ts

@@ -1,50 +0,0 @@
-//#region src/find-last-index.d.ts
-/**
- * Iterates the array in reverse order and returns the index of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, -1 is returned.
- *
- * See also `findLast` which returns the value of last element that satisfies
- * the testing function (rather than its index).
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise.
- * @returns The index of the last (highest-index) element in the array that
- * passes the test. Otherwise -1 if no matching element is found.
- * @signature
- *    P.findLastIndex(data, predicate)
- * @example
- *    P.findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1
- * @dataFirst
- * @category Array
- */
-declare function findLastIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
-/**
- * Iterates the array in reverse order and returns the index of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, -1 is returned.
- *
- * See also `findLast` which returns the value of last element that satisfies
- * the testing function (rather than its index).
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise.
- * @returns The index of the last (highest-index) element in the array that
- * passes the test. Otherwise -1 if no matching element is found.
- * @signature
- *    P.findLastIndex(fn)(items)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.findLastIndex(n => n % 2 === 1)
- *    ) // => 1
- * @dataLast
- * @category Array
- */
-declare function findLastIndex<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => number;
-//#endregion
-export { findLastIndex };
-//# sourceMappingURL=find-last-index-XB_3-4xj.d.ts.map

package/dist/find-last-index-XB_3-4xj.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-last-index-XB_3-4xj.d.ts","names":[],"sources":["../src/find-last-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;;AA4BA;;;;;;;;;;;;iBA5BgB,uBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBA0B3C,oCACK,wBAAwB,cAAc,yBAChD,cAAc"}

package/dist/first-1NtfTucX.d.ts

@@ -1,40 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-
-//#region src/first.d.ts
-type First<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Last | Pre[0] : T[0] | undefined;
-/**
- * Gets the first element of `array`.
- *
- * @param data - The array.
- * @returns The first element of the array.
- * @signature
- *    P.first(array)
- * @example
- *    P.first([1, 2, 3]) // => 1
- *    P.first([]) // => undefined
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function first<T extends IterableContainer>(data: T): First<T>;
-/**
- * Gets the first element of `array`.
- *
- * @returns The first element of the array.
- * @signature
- *    P.first()(array)
- * @example
- *    P.pipe(
- *      [1, 2, 4, 8, 16],
- *      P.filter(x => x > 3),
- *      P.first(),
- *      x => x + 1
- *    ); // => 5
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function first(): <T extends IterableContainer>(data: T) => First<T>;
-//#endregion
-export { first };
-//# sourceMappingURL=first-1NtfTucX.d.ts.map

package/dist/first-1NtfTucX.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"first-1NtfTucX.d.ts","names":[],"sources":["../src/first.ts"],"sourcesContent":[],"mappings":";;;KAKK,gBAAgB,qBAAqB,2BAEtC,gCAAgC,kBAC9B,OACA,gDACE,OAAO,SACP;;AAXqE;;;;;;;;;;;;AA2B7E;AAAqB,iBAAL,KAAK,CAAA,UAAW,iBAAX,CAAA,CAAA,IAAA,EAAoC,CAApC,CAAA,EAAwC,KAAxC,CAA8C,CAA9C,CAAA;;;;;;AAmBrB;;;;;;;;;;;;iBAAgB,KAAA,CAAA,cAAoB,yBAAyB,MAAM,MAAM"}

package/dist/first-by-C0qf5rwh.d.ts

@@ -1,60 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { NonEmptyArray } from "./non-empty-array-D3HWDPMt.js";
-import { OrderRule } from "./curry-order-rules-Cthu8rj4.js";
-
-//#region src/first-by.d.ts
-type FirstBy<T extends IterableContainer> = T[number] | (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined);
-/**
- * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
- *
- * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
- *
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The first element by the order criteria, or `undefined` if the array
- * is empty. (The function provides strong typing if the input type assures the
- * array isn't empty).
- * @signature
- *   P.firstBy(...rules)(data);
- * @example
- *   const max = P.pipe([1,2,3], P.firstBy([P.identity(), "desc"])); // => 3;
- *   const min = P.pipe([1,2,3], P.firstBy(P.identity())); // => 1;
- *
- *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
- *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
- *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
- *
- *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
- *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
- * @dataLast
- * @category Array
- */
-declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
-/**
- * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
- *
- * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
- *
- * @param data - An array of items.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The first element by the order criteria, or `undefined` if the array
- * is empty. (The function provides strong typing if the input type assures the
- * array isn't empty).
- * @signature
- *   P.firstBy(data, ...rules);
- * @example
- *   const max = P.firstBy([1,2,3], [P.identity(), "desc"]); // => 3;
- *   const min = P.firstBy([1,2,3], P.identity()); // => 1;
- *
- *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
- *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
- *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
- *
- *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
- *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
- * @dataFirst
- * @category Array
- */
-declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
-//#endregion
-export { firstBy };
-//# sourceMappingURL=first-by-C0qf5rwh.d.ts.map

package/dist/first-by-C0qf5rwh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"first-by-C0qf5rwh.d.ts","names":[],"sources":["../src/first-by.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,kBAAkB,qBACjB,aACC,gCAAgC,kCAE/B,uBAAuB;;AARuC;;;;;;;;;AAoCtE;;;;;;;;;;;AA6BA;;;AACQ,iBA9BQ,OA8BR,CAAA,UA9B0B,iBA8B1B,CAAA,CAAA,GAAA,KAAA,EA7BI,QA6BJ,CA7Ba,aA6Bb,CA7B2B,SA6B3B,CA7BqC,CA6BrC,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,IAAA,EA5BE,CA4BF,EAAA,GA5BQ,OA4BR,CA5BgB,CA4BhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBADQ,kBAAkB,yBAC1B,aACI,SAAS,cAAc,UAAU,eAC1C,QAAQ"}

package/dist/flat-BbBf5kJs.d.ts

@@ -1,53 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { IsNumericLiteral } from "type-fest";
-
-//#region src/flat.d.ts
-type FlatArray<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = []> = Depth extends Iteration['length'] ? T : T extends readonly [] ? [] : T extends readonly [infer Item, ...infer Rest] ? [...(Item extends IterableContainer ? FlatArray<Item, Depth, [...Iteration, unknown]> : [Item]), ...FlatArray<Rest, Depth, Iteration>] : Array<FlatSimpleArrayItems<T, Depth, Iteration>>;
-type FlatSimpleArrayItems<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = [], IsDone extends boolean = false> = {
-  done: T;
-  recur: T extends ReadonlyArray<infer InnerArr> ? FlatSimpleArrayItems<InnerArr, Depth, [...Iteration, unknown], Iteration['length'] extends Depth ? true : false> : T;
-}[IsDone extends true ? 'done' : 'recur'];
-/**
- * Creates a new array with all sub-array elements concatenated into it
- * recursively up to the specified depth. Equivalent to the built-in
- * `Array.prototype.flat` method.
- *
- * @param data - The items to flatten.
- * @param depth - The depth level specifying how deep a nested array structure
- * should be flattened. Defaults to 1. Non literal values (those typed as
- * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and
- * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For
- * "unlimited" depth use a literal value that would exceed your expected
- * practical maximum nesting level.
- * @signature
- *   P.flat(data)
- *   P.flat(data, depth)
- * @example
- *   P.flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]
- *   P.flat([[[1]], [[2]]], 2); // => [1, 2]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flat<T extends IterableContainer, Depth extends number = 1>(data: T, depth?: IsNumericLiteral<Depth> extends true ? Depth : never): FlatArray<T, Depth>;
-/**
- * Creates a new array with all sub-array elements concatenated into it
- * recursively up to the specified depth. Equivalent to the built-in
- * `Array.prototype.flat` method.
- *
- * @param depth - The depth level specifying how deep a nested array structure
- * should be flattened. Defaults to 1.
- * @signature
- *   P.flat()(data)
- *   P.flat(depth)(data)
- * @example
- *   P.pipe([[1, 2], [3, 4], [5], [[6]]], P.flat()); // => [1, 2, 3, 4, 5, [6]]
- *   P.pipe([[[1]], [[2]]], P.flat(2)); // => [1, 2]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flat<Depth extends number = 1>(depth?: IsNumericLiteral<Depth> extends true ? Depth : never): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;
-//#endregion
-export { flat };
-//# sourceMappingURL=flat-BbBf5kJs.d.ts.map

package/dist/flat-BbBf5kJs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-BbBf5kJs.d.ts","names":[],"sources":["../src/flat.ts"],"sourcesContent":[],"mappings":";;;;KASK,qDAGe,+BAChB,cAAc,sBAEd,IACA,6BAGE,sDAKQ,aAAa,oBAEb,UAAU,MAAM,WAAW,wBAE1B,QAnBV,GAqBQ,SArBC,CAqBS,IArBT,EAqBe,KArBf,EAqBsB,SArBtB,CAAA,CAAA,GAwBN,KAxBM,CAwBA,oBAxBA,CAwBqB,CAxBrB,EAwBwB,KAxBxB,EAwB+B,SAxB/B,CAAA,CAAA;KA8BT,oBA3Be,CAAA,CAAA,EAAA,cAAA,MAAA,EAAA,kBA8BA,aA9BA,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,eAAA,OAAA,GAAA,KAAA,CAAA,GAAA;MAChB,EAgCI,CAhCJ;OAAc,EAiCT,CAjCS,SAiCC,aAjCD,CAAA,KAAA,SAAA,CAAA,GAkCZ,oBAlCY,CAmCZ,QAnCY,EAoCZ,KApCY,EAAA,CAEd,GAmCM,SAnCN,EACA,OAAA,GAqCE,SAlCA,CAAA,QAAA,CAAA,SAkC4B,KAlC5B,GAAA,IAAA,GAAA,KAAA,CAAA,GAoCA,CApCA;EAqCJ,MAhCY,SAAA,IAAA,GAAA,MAAA,GAAA,OAAA,CAAA;;;;;;;;;;;;;;;;;AASD;;;;;;AAeP,iBAgCU,IAhCV,CAAA,UAiCM,iBAjCN,EAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,IAAA,EAoCE,CApCF,EAAA,KAAA,CAAA,EAqCI,gBArCJ,CAqCqB,KArCrB,CAAA,SAAA,IAAA,GAqC2C,KArC3C,GAAA,KAAA,CAAA,EAsCH,SAtCG,CAsCO,CAtCP,EAsCU,KAtCV,CAAA;;;;;;;;;AAgCN;;;;;;;;;AAMG,iBAmBa,IAnBb,CAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,KAAA,CAAA,EAoBO,gBApBP,CAoBwB,KApBxB,CAAA,SAAA,IAAA,GAoB8C,KApB9C,GAAA,KAAA,CAAA,EAAA,CAAA,UAqBW,iBArBX,CAAA,CAAA,IAAA,EAqBoC,CArBpC,EAAA,GAqB0C,SArB1C,CAqBoD,CArBpD,EAqBuD,KArBvD,CAAA"}

package/dist/flat-map-Ok5sZOb2.d.ts

@@ -1,47 +0,0 @@
-//#region src/flat-map.d.ts
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param data - The items to map and flatten.
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(data, callbackfn)
- * @example
- *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(data: ReadonlyArray<T>, callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U>;
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(callbackfn)(data)
- * @example
- *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): (data: ReadonlyArray<T>) => Array<U>;
-//#endregion
-export { flatMap };
-//# sourceMappingURL=flat-map-Ok5sZOb2.d.ts.map

package/dist/flat-map-Ok5sZOb2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-map-Ok5sZOb2.d.ts","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;;;;;;;;;AA6BA;;;;;;;AAK0B,iBAlCV,OAkCU,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAjClB,aAiCkB,CAjCJ,CAiCI,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EA/Bf,CA+Be,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA7BhB,aA6BgB,CA7BF,CA6BE,CAAA,EAAA,GA5BnB,aA4BmB,CA5BL,CA4BK,CAAA,GA5BA,CA4BA,CAAA,EA3BvB,KA2BuB,CA3BjB,CA2BiB,CAAA;;;;;;;;;;;;;;;;;;;;;iBALV,kCAEL,wBAED,cAAc,OACjB,cAAc,KAAK,WAChB,cAAc,OAAO,MAAM"}

package/dist/floor-C9us6h14.d.ts

@@ -1,39 +0,0 @@
-//#region src/floor.d.ts
-/**
- * Rounds down a given number to a specific precision.
- * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.floor` instead, as it won't incur the additional library overhead.
- *
- * @param value - The number to round down.
- * @param precision - The precision to round down to. Must be an integer between -15 and 15.
- * @signature
- *    P.floor(value, precision);
- * @example
- *    P.floor(123.9876, 3) // => 123.987
- *    P.floor(483.22243, 1) // => 483.2
- *    P.floor(8541, -1) // => 8540
- *    P.floor(456789, -3) // => 456000
- * @dataFirst
- * @category Number
- */
-declare function floor(value: number, precision: number): number;
-/**
- * Rounds down a given number to a specific precision.
- * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.floor` instead, as it won't incur the additional library overhead.
- *
- * @param precision - The precision to round down to. Must be an integer between -15 and 15.
- * @signature
- *    P.floor(precision)(value);
- * @example
- *    P.floor(3)(123.9876) // => 123.987
- *    P.floor(1)(483.22243) // => 483.2
- *    P.floor(-1)(8541) // => 8540
- *    P.floor(-3)(456789) // => 456000
- * @dataLast
- * @category Number
- */
-declare function floor(precision: number): (value: number) => number;
-//#endregion
-export { floor };
-//# sourceMappingURL=floor-C9us6h14.d.ts.map

package/dist/floor-C9us6h14.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floor-C9us6h14.d.ts","names":[],"sources":["../src/floor.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,KAAA;;;;;;;;;;;;;;;;;iBAkBA,KAAA"}

package/dist/for-each-DIxtfnNY.d.ts

@@ -1,54 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { Writable } from "type-fest";
-
-//#region src/for-each.d.ts
-
-/**
- * Executes a provided function once for each array element. Equivalent to
- * `Array.prototype.forEach`.
- *
- * The dataLast version returns the original array (instead of not returning
- * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the
- * returned array is equal to the input array (by reference), and not a shallow
- * copy of it!
- *
- * @param data - The values that would be iterated on.
- * @param callbackfn - A function to execute for each element in the array.
- * @signature
- *    P.forEach(data, callbackfn)
- * @example
- *    P.forEach([1, 2, 3], x => {
- *      console.log(x)
- *    });
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function forEach<T extends IterableContainer>(data: T, callbackfn: (value: T[number], index: number, data: T) => void): void;
-/**
- * Executes a provided function once for each array element. Equivalent to
- * `Array.prototype.forEach`.
- *
- * The dataLast version returns the original array (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned array is the
- * same reference as the input array, and not a shallow copy of it!
- *
- * @param callbackfn - A function to execute for each element in the array.
- * @returns The original array (the ref itself, not a shallow copy of it).
- * @signature
- *    P.forEach(callbackfn)(data)
- * @example
- *    P.pipe(
- *      [1, 2, 3],
- *      P.forEach(x => {
- *        console.log(x)
- *      })
- *    ) // => [1, 2, 3]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function forEach<T extends IterableContainer>(callbackfn: (value: T[number], index: number, data: T) => void): (data: T) => Writable<T>;
-//#endregion
-export { forEach };
-//# sourceMappingURL=for-each-DIxtfnNY.d.ts.map

package/dist/for-each-DIxtfnNY.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-DIxtfnNY.d.ts","names":[],"sources":["../src/for-each.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4BA;;;;;;;AA4BA;;;;;;;;;;;;iBA5BgB,kBAAkB,yBAC1B,uBACc,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;iBA0BtC,kBAAkB,uCACZ,gCAAgC,oBAC5C,MAAM,SAAS"}

package/dist/for-each-obj-DRgFFti8.d.ts

@@ -1,47 +0,0 @@
-import { EnumerableStringKeyOf } from "./enumerable-string-key-of-DKzYIarp.js";
-import { EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-Bf_owt8O.js";
-
-//#region src/for-each-obj.d.ts
-
-/**
- * Iterate an object using a defined callback function.
- *
- * The dataLast version returns the original object (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned object is the
- * same reference as the input object, and not a shallow copy of it!
- *
- * @param data - The object who'se entries would be iterated on.
- * @param callbackfn - A function to execute for each element in the array.
- * @signature
- *    P.forEachObj(object, fn)
- * @example
- *    P.forEachObj({a: 1}, (val, key, obj) => {
- *      console.log(`${key}: ${val}`)
- *    }) // "a: 1"
- * @dataFirst
- * @category Object
- */
-declare function forEachObj<T extends object>(data: T, callbackfn: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, obj: T) => void): void;
-/**
- * Iterate an object using a defined callback function.
- *
- * The dataLast version returns the original object (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned object is the
- * same reference as the input object, and not a shallow copy of it!
- *
- * @param callbackfn - A function to execute for each element in the array.
- * @returns The original object (the ref itself, not a shallow copy of it).
- * @signature
- *    P.forEachObj(fn)(object)
- * @example
- *    P.pipe(
- *      {a: 1},
- *      P.forEachObj((val, key) => console.log(`${key}: ${val}`))
- *    ) // "a: 1"
- * @dataLast
- * @category Object
- */
-declare function forEachObj<T extends object>(callbackfn: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, obj: T) => void): (object: T) => T;
-//#endregion
-export { forEachObj };
-//# sourceMappingURL=for-each-obj-DRgFFti8.d.ts.map

package/dist/for-each-obj-DRgFFti8.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-obj-DRgFFti8.d.ts","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsBA;;;;;;;;;AA4BA;;;;;;;AAMY,iBAlCI,UAkCJ,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAjCJ,CAiCI,EAAA,UAAA,EAAA,CAAA,KAAA,EA/BD,4BA+BC,CA/B4B,CA+B5B,CAAA,EAAA,GAAA,EA9BH,qBA8BG,CA9BmB,CA8BnB,CAAA,EAAA,GAAA,EA7BH,CA6BG,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;;;;;;;;;;;;;;;;;;;;iBANI,iDAEL,6BAA6B,SAC/B,sBAAsB,SACtB,sBAEG,MAAM"}

package/dist/from-entries-BqW53CyR.d.ts

@@ -1,68 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { PerkakasTypeError } from "./perkakas-type-error-Da3ni385.js";
-import { Simplify } from "type-fest";
-
-//#region src/from-entries.d.ts
-type FromEntriesError<Message extends string> = PerkakasTypeError<'fromEntries', Message>;
-type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [key: Key, value: Value];
-type FromEntries<Entries> = Entries extends readonly [infer First, ...infer Tail] ? FromEntriesTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromEntriesTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromEntriesArray<Entries> : FromEntriesError<'Entries array-like could not be inferred'>;
-type FromEntriesTuple<E, Rest> = E extends Entry ? FromEntries<Rest> & Record<E[0], E[1]> : FromEntriesError<'Array-like contains a non-entry element'>;
-type FromEntriesArray<Entries extends IterableContainer<Entry>> = string extends AllKeys<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys<Entries> ? Record<symbol, Entries[number][1]> : FromEntriesArrayWithLiteralKeys<Entries>;
-type FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = { [P in AllKeys<Entries>]?: ValueForKey<Entries, P> };
-type AllKeys<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
-type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
-/**
- * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
- * If a tuple is not supplied for any element in the array, the element will be ignored
- * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
- *
- * The strict option supports more sophisticated use-cases like those that would
- * result when calling the strict `toPairs` function.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * - `fromKeys`: Builds an object from an array of *keys* and a mapper for values.
- * - `indexBy`: Builds an object from an array of *values* and a mapper for keys.
- * - `pullObject`: Builds an object from an array of items with mappers for *both* keys and values.
- * - `mapToObj`: Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param entries - An array of key-value pairs.
- * @signature
- *   P.fromEntries(tuples)
- * @example
- *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}
- * @dataFirst
- * @category Object
- */
-declare function fromEntries<Entries extends IterableContainer<Entry>>(entries: Entries): Simplify<FromEntries<Entries>>;
-/**
- * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
- * If a tuple is not supplied for any element in the array, the element will be ignored
- * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
- *
- * The strict option supports more sophisticated use-cases like those that would
- * result when calling the strict `toPairs` function.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @signature
- *   P.fromEntries()(tuples)
- * @example
- *   P.pipe(
- *     [['a', 'b'], ['c', 'd']] as const,
- *     P.fromEntries(),
- *   ); // => {a: 'b', c: 'd'}
- * @dataLast
- * @category Object
- */
-declare function fromEntries(): <Entries extends IterableContainer<Entry>>(entries: Entries) => Simplify<FromEntries<Entries>>;
-//#endregion
-export { fromEntries };
-//# sourceMappingURL=from-entries-BqW53CyR.d.ts.map

package/dist/from-entries-BqW53CyR.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-entries-BqW53CyR.d.ts","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,2CAA2C,iCAE9C;KAGG,kBAAkB,cAAc,0CALhC,GAAA,EAME,GANF,EAAgB,KAAA,EAOZ,KAPY;KAiBhB,WAjB2C,CAAA,OAAA,CAAA,GAiBpB,OAjBoB,SAAA,SAAA,CAAiB,KAAA,MAAA,EAK5D,GAAA,KAAK,KAAA,CAAA,GAgBN,gBAhBM,CAgBW,KAhBX,EAgBkB,IAhBlB,CAAA,GAiBN,OAjBM,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GAkBJ,gBAlBI,CAkBa,IAlBb,EAkBmB,IAlBnB,CAAA,GAmBJ,OAnBI,SAmBY,iBAnBZ,CAmB8B,KAnB9B,CAAA,GAoBF,gBApBE,CAoBe,OApBf,CAAA,GAqBF,gBArBE,CAAA,0CAAA,CAAA;KA0BL,gBA1BkB,CAAA,CAAA,EAAA,IAAA,CAAA,GA0BU,CA1BV,SA0BoB,KA1BpB,GA2BnB,WA3BmB,CA2BP,IA3BO,CAAA,GA2BC,MA3BD,CA2BQ,CA3BR,CAAA,CAAA,CAAA,EA2Bc,CA3Bd,CAAA,CAAA,CAAA,CAAA,GA4BnB,gBA5BmB,CAAA,yCAAA,CAAA;KAwClB,gBAxCgC,CAAA,gBAwCC,iBAxCD,CAwCmB,KAxCnB,CAAA,CAAA,GAAA,MAAA,SAyClB,OAzCkB,CAyCV,OAzCU,CAAA,GA0C/B,MA1C+B,CAAA,MAAA,EA0ChB,OA1CgB,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA2ChB,OA3CgB,CA2CR,OA3CQ,CAAA,GA4C7B,MA5C6B,CAAA,MAAA,EA4Cd,OA5Cc,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA6Cd,OA7Cc,CA6CN,OA7CM,CAAA,GA8C3B,MA9C2B,CAAA,MAAA,EA8CZ,OA9CY,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GA+C3B,+BA/C2B,CA+CK,OA/CL,CAAA;KAsDhC,+BArDE,CAAA,gBAqD8C,iBArD9C,CAqDgE,KArDhE,CAAA,CAAA,GAAA,QAuDG,OAtDD,CAsDS,OAtDT,CAAA,IAsDqB,WAtDrB,CAsDiC,OAtDjC,EAsD0C,CAtD1C,CAAA,EAAK;AAAA,KAyDT,OA/CA,CAAA,gBA+CwB,iBA/Cb,CA+C+B,KA/C/B,CAAA,CAAA,GA+CyC,OA/CzC,CAgDd,OAhDc,CAAA,MAAA,CAAA,EAiDd,KAjDc,CAAA,CAAA,CAAA,CAAA;KA0DX,WA1DW,CAAA,gBA2DE,iBA3DF,CA2DoB,KA3DpB,CAAA,EAAA,UA4DJ,WA5DI,CAAA,GAAA,CA6DX,OA7DW,CA6DH,OA7DG,CAAA,MAAA,CAAA,EA6Dc,KA7Dd,CA6DoB,CA7DpB,CAAA,CAAA,SAAA,KAAA,GA8DZ,OA9DY,CAAA,MAAA,CAAA,GA+DZ,OA/DY,CA+DJ,OA/DI,CAAA,MAAA,CAAA,EA+Da,KA/Db,CA+DmB,CA/DnB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;AASQ;;;;;;;;;AAOpB,iBAyEY,WAzEZ,CAAA,gBAyEwC,iBAzExC,CAyE0D,KAzE1D,CAAA,CAAA,CAAA,OAAA,EA0EO,OA1EP,CAAA,EA2ED,QA3EC,CA2EQ,WA3ER,CA2EoB,OA3EpB,CAAA,CAAA;;AAAgB;;;;;;;;;;;;;;;;;;;AAmBqB;;;;;;AASC,iBA2E1B,WAAA,CAAA,CA3E0B,EAAA,CAAA,gBA2EM,iBA3EN,CA2EwB,KA3ExB,CAAA,CAAA,CAAA,OAAA,EA4E/B,OA5E+B,EAAA,GA6ErC,QA7EqC,CA6E5B,WA7E4B,CA6EhB,OA7EgB,CAAA,CAAA"}