@vinicunca/perkakas 0.5.4 → 1.0.1

package/dist/first.d.cts

@@ -0,0 +1,39 @@
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+import 'type-fest';
+
+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>;
+
+export { first };

package/dist/first.d.ts

@@ -0,0 +1,39 @@
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+import 'type-fest';
+
+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>;
+
+export { first };

package/dist/first.js

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

package/dist/flat-map.cjs

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

package/dist/flat-map.d.cts

@@ -0,0 +1,45 @@
+/**
+ * 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>;
+
+export { flatMap };

package/dist/flat-map.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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>;
+
+export { flatMap };

package/dist/flat-map.js

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

package/dist/flat.cjs

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

package/dist/flat.d.cts

@@ -0,0 +1,61 @@
+import { IsNumericLiteral } from 'type-fest';
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+
+declare const DEFAULT_DEPTH = 1;
+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 = typeof DEFAULT_DEPTH>(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 = typeof DEFAULT_DEPTH>(depth?: IsNumericLiteral<Depth> extends true ? Depth : never): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;
+
+export { flat };

package/dist/flat.d.ts

@@ -0,0 +1,61 @@
+import { IsNumericLiteral } from 'type-fest';
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+
+declare const DEFAULT_DEPTH = 1;
+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 = typeof DEFAULT_DEPTH>(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 = typeof DEFAULT_DEPTH>(depth?: IsNumericLiteral<Depth> extends true ? Depth : never): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;
+
+export { flat };

package/dist/flat.js

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

package/dist/floor.cjs

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

package/dist/floor.d.cts

@@ -0,0 +1,37 @@
+/**
+ * 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;
+
+export { floor };

package/dist/floor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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;
+
+export { floor };

package/dist/floor.js

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

package/dist/for-each-obj.cjs

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

package/dist/for-each-obj.d.cts

@@ -0,0 +1,44 @@
+import { E as EnumerableStringKeyedValueOf, a as EnumerableStringKeyOf } from './types-BMu1PIvo.cjs';
+import 'type-fest';
+
+/**
+ * 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;
+
+export { forEachObj };

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

@@ -0,0 +1,44 @@
+import { E as EnumerableStringKeyedValueOf, a as EnumerableStringKeyOf } from './types-BMu1PIvo.js';
+import 'type-fest';
+
+/**
+ * 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;
+
+export { forEachObj };

package/dist/for-each-obj.js

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

package/dist/for-each.cjs

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

package/dist/for-each.d.cts

@@ -0,0 +1,51 @@
+import { Writable } from 'type-fest';
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+
+/**
+ * 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>;
+
+export { forEach };

package/dist/for-each.d.ts

@@ -0,0 +1,51 @@
+import { Writable } from 'type-fest';
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+
+/**
+ * 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>;
+
+export { forEach };

package/dist/for-each.js

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

package/dist/from-entries.cjs

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