@pithos/core 2.0.0

package/dist/taphos/array/pullAt.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Removes elements from array at specified indexes and returns removed elements.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param indexes - The indexes of elements to remove.
+ * @returns An array of removed elements.
+ * @deprecated Use `.filter()` with index check for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = ['a', 'b', 'c', 'd'];
+ * const pulled = pullAt(array, [1, 3]);
+ * console.log(pulled); // ['b', 'd']
+ * console.log(array);  // ['a', 'c']
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = ['a', 'b', 'c', 'd'];
+ * const indexesToRemove = new Set([1, 3]);
+ * const remaining = array.filter((_, i) => !indexesToRemove.has(i));
+ * const pulled = array.filter((_, i) => indexesToRemove.has(i));
+ * console.log(pulled);    // ['b', 'd']
+ * console.log(remaining); // ['a', 'c']
+ * console.log(array);     // ['a', 'b', 'c', 'd'] (unchanged)
+ * ```
+ */
+export declare function pullAt<T>(array: T[], indexes: number[]): T[];
+//# sourceMappingURL=pullAt.d.ts.map

package/dist/taphos/array/pullAt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pullAt.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/pullAt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,CAmB5D"}

package/dist/taphos/array/pullAt.js

@@ -0,0 +1,49 @@
+/**
+ * Removes elements from array at specified indexes and returns removed elements.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param indexes - The indexes of elements to remove.
+ * @returns An array of removed elements.
+ * @deprecated Use `.filter()` with index check for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = ['a', 'b', 'c', 'd'];
+ * const pulled = pullAt(array, [1, 3]);
+ * console.log(pulled); // ['b', 'd']
+ * console.log(array);  // ['a', 'c']
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = ['a', 'b', 'c', 'd'];
+ * const indexesToRemove = new Set([1, 3]);
+ * const remaining = array.filter((_, i) => !indexesToRemove.has(i));
+ * const pulled = array.filter((_, i) => indexesToRemove.has(i));
+ * console.log(pulled);    // ['b', 'd']
+ * console.log(remaining); // ['a', 'c']
+ * console.log(array);     // ['a', 'b', 'c', 'd'] (unchanged)
+ * ```
+ */
+export function pullAt(array, indexes) {
+    const indexSet = new Set(indexes);
+    const pulled = [];
+    for (const index of indexes) {
+        if (index >= 0 && index < array.length) {
+            pulled.push(array[index]);
+        }
+    }
+    let writeIndex = 0;
+    for (let readIndex = 0; readIndex < array.length; readIndex++) {
+        if (!indexSet.has(readIndex)) {
+            array[writeIndex++] = array[readIndex];
+        }
+    }
+    array.length = writeIndex;
+    return pulled;
+}
+//# sourceMappingURL=pullAt.js.map

package/dist/taphos/array/pullAt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pullAt.js","sourceRoot":"","sources":["../../../src/taphos/array/pullAt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,MAAM,CAAI,KAAU,EAAE,OAAiB;IACrD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;IAClC,MAAM,MAAM,GAAQ,EAAE,CAAC;IAEvB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;YACvC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC;QAC9D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7B,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC;IAE1B,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/taphos/array/remove.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Removes all elements from array that predicate returns truthy for.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param predicate - The function invoked per iteration.
+ * @returns An array of removed elements.
+ * @deprecated Use `.filter()` for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = [1, 2, 3, 4];
+ * const evens = remove(array, n => n % 2 === 0);
+ * console.log(evens); // [2, 4]
+ * console.log(array); // [1, 3]
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = [1, 2, 3, 4];
+ * const evens = array.filter(n => n % 2 === 0);
+ * const odds = array.filter(n => n % 2 !== 0);
+ * console.log(evens); // [2, 4]
+ * console.log(odds);  // [1, 3]
+ * console.log(array); // [1, 2, 3, 4] (unchanged)
+ * ```
+ */
+export declare function remove<T>(array: T[], predicate: (value: T, index: number, array: T[]) => boolean): T[];
+//# sourceMappingURL=remove.d.ts.map

package/dist/taphos/array/remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/remove.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,EAAE,EACV,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,GAC1D,CAAC,EAAE,CAeL"}

package/dist/taphos/array/remove.js

@@ -0,0 +1,46 @@
+/**
+ * Removes all elements from array that predicate returns truthy for.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param predicate - The function invoked per iteration.
+ * @returns An array of removed elements.
+ * @deprecated Use `.filter()` for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = [1, 2, 3, 4];
+ * const evens = remove(array, n => n % 2 === 0);
+ * console.log(evens); // [2, 4]
+ * console.log(array); // [1, 3]
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = [1, 2, 3, 4];
+ * const evens = array.filter(n => n % 2 === 0);
+ * const odds = array.filter(n => n % 2 !== 0);
+ * console.log(evens); // [2, 4]
+ * console.log(odds);  // [1, 3]
+ * console.log(array); // [1, 2, 3, 4] (unchanged)
+ * ```
+ */
+export function remove(array, predicate) {
+    const removed = [];
+    let writeIndex = 0;
+    for (let readIndex = 0; readIndex < array.length; readIndex++) {
+        const value = array[readIndex];
+        if (predicate(value, readIndex, array)) {
+            removed.push(value);
+        }
+        else {
+            array[writeIndex++] = value;
+        }
+    }
+    array.length = writeIndex;
+    return removed;
+}
+//# sourceMappingURL=remove.js.map

package/dist/taphos/array/remove.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.js","sourceRoot":"","sources":["../../../src/taphos/array/remove.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,MAAM,CACpB,KAAU,EACV,SAA2D;IAE3D,MAAM,OAAO,GAAQ,EAAE,CAAC;IACxB,IAAI,UAAU,GAAG,CAAC,CAAC;IAEnB,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC;QAC9D,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QAC/B,IAAI,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC;YACvC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC;IAC1B,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/taphos/array/slice.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Creates a slice of array from start up to, but not including, end.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to slice.
+ * @param start - The start position.
+ * @param end - The end position.
+ * @returns A new sliced array.
+ * @deprecated Use `array.slice(start, end)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | Array.slice() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_slice | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const sliced = slice(numbers, 1, 4);
+ * console.log(sliced); // [2, 3, 4]
+ *
+ * // ✅ Recommended approach
+ * const slicedNative = numbers.slice(1, 4);
+ * console.log(slicedNative); // [2, 3, 4]
+ * ```
+ */
+export declare function slice<T>(array: T[], start?: number, end?: number): T[];
+//# sourceMappingURL=slice.d.ts.map

package/dist/taphos/array/slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,CAEtE"}

package/dist/taphos/array/slice.js

@@ -0,0 +1,31 @@
+/**
+ * Creates a slice of array from start up to, but not including, end.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to slice.
+ * @param start - The start position.
+ * @param end - The end position.
+ * @returns A new sliced array.
+ * @deprecated Use `array.slice(start, end)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | Array.slice() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_slice | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const sliced = slice(numbers, 1, 4);
+ * console.log(sliced); // [2, 3, 4]
+ *
+ * // ✅ Recommended approach
+ * const slicedNative = numbers.slice(1, 4);
+ * console.log(slicedNative); // [2, 3, 4]
+ * ```
+ */
+export function slice(array, start, end) {
+    return array.slice(start, end);
+}
+//# sourceMappingURL=slice.js.map

package/dist/taphos/array/slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.js","sourceRoot":"","sources":["../../../src/taphos/array/slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,KAAK,CAAI,KAAU,EAAE,KAAc,EAAE,GAAY;IAC/D,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AACjC,CAAC"}

package/dist/taphos/array/tail.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Gets all but the first element of array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @returns A new array with all elements except the first.
+ * @deprecated Use `array.slice(1)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | Array.slice() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_slice | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const rest = tail(numbers);
+ * console.log(rest); // [2, 3, 4, 5]
+ *
+ * // ✅ Recommended approach
+ * const restNative = numbers.slice(1);
+ * console.log(restNative); // [2, 3, 4, 5]
+ * ```
+ */
+export declare function tail<T>(array: T[]): T[];
+//# sourceMappingURL=tail.d.ts.map

package/dist/taphos/array/tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/tail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAEvC"}

package/dist/taphos/array/tail.js

@@ -0,0 +1,29 @@
+/**
+ * Gets all but the first element of array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @returns A new array with all elements except the first.
+ * @deprecated Use `array.slice(1)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | Array.slice() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_slice | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const rest = tail(numbers);
+ * console.log(rest); // [2, 3, 4, 5]
+ *
+ * // ✅ Recommended approach
+ * const restNative = numbers.slice(1);
+ * console.log(restNative); // [2, 3, 4, 5]
+ * ```
+ */
+export function tail(array) {
+    return array.slice(1);
+}
+//# sourceMappingURL=tail.js.map

package/dist/taphos/array/tail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.js","sourceRoot":"","sources":["../../../src/taphos/array/tail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,IAAI,CAAI,KAAU;IAC9B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAC1B,CAAC"}

package/dist/taphos/array/without.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Creates an array excluding all given values.
+ *
+ * Alias for {@link difference}.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to filter.
+ * @param values - The values to exclude.
+ * @returns A new array without the specified values.
+ * @deprecated Use `difference` from Arkhe instead.
+ * Reason: Alias of {@link difference}
+ * @see {@link difference}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const filtered = without(numbers, 2, 4);
+ * console.log(filtered); // [1, 3, 5]
+ *
+ * // ✅ Recommended approach (Arkhe)
+ * import { difference } from "pithos/arkhe/array/difference";
+ * const filteredArkhe = difference(numbers, [2, 4]);
+ * console.log(filteredArkhe); // [1, 3, 5]
+ * ```
+ */
+export declare function without<T>(array: T[], ...values: T[]): T[];
+//# sourceMappingURL=without.d.ts.map

package/dist/taphos/array/without.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"without.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/without.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAE1D"}

package/dist/taphos/array/without.js

@@ -0,0 +1,33 @@
+import { difference } from "../../arkhe/array/difference";
+/**
+ * Creates an array excluding all given values.
+ *
+ * Alias for {@link difference}.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to filter.
+ * @param values - The values to exclude.
+ * @returns A new array without the specified values.
+ * @deprecated Use `difference` from Arkhe instead.
+ * Reason: Alias of {@link difference}
+ * @see {@link difference}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const filtered = without(numbers, 2, 4);
+ * console.log(filtered); // [1, 3, 5]
+ *
+ * // ✅ Recommended approach (Arkhe)
+ * import { difference } from "pithos/arkhe/array/difference";
+ * const filteredArkhe = difference(numbers, [2, 4]);
+ * console.log(filteredArkhe); // [1, 3, 5]
+ * ```
+ */
+export function without(array, ...values) {
+    return difference(array, values);
+}
+//# sourceMappingURL=without.js.map

package/dist/taphos/array/without.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"without.js","sourceRoot":"","sources":["../../../src/taphos/array/without.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAG1D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,OAAO,CAAI,KAAU,EAAE,GAAG,MAAW;IACjD,OAAO,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACrC,CAAC"}

package/dist/taphos/array/zipObject.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Creates an object composed from arrays of keys and values.
+ *
+ * @template K - The type of keys (must be valid property key).
+ * @template V - The type of values.
+ * @param keys - The property keys.
+ * @param values - The property values.
+ * @returns The new object.
+ * @deprecated Use `Object.fromEntries()` with `map()` or `zip()` directly instead.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries | Object.fromEntries() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_object_fromentries | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach
+ * zipObject(['a', 'b'], [1, 2]);
+ * // => { a: 1, b: 2 }
+ *
+ * // ✅ Recommended approach
+ * Object.fromEntries(['a', 'b'].map((k, i) => [k, [1, 2][i]]));
+ * // => { a: 1, b: 2 }
+ *
+ * // Or using zip from Arkhe
+ * import { zip } from '@pithos/arkhe/array/zip';
+ * Object.fromEntries(zip(['a', 'b'], [1, 2]));
+ * // => { a: 1, b: 2 }
+ * ```
+ */
+export declare function zipObject<K extends PropertyKey, V>(keys: readonly K[], values: readonly V[]): Record<K, V>;
+//# sourceMappingURL=zipObject.d.ts.map

package/dist/taphos/array/zipObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipObject.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/zipObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,EAChD,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,MAAM,EAAE,SAAS,CAAC,EAAE,GACnB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAQd"}

package/dist/taphos/array/zipObject.js

@@ -0,0 +1,37 @@
+/**
+ * Creates an object composed from arrays of keys and values.
+ *
+ * @template K - The type of keys (must be valid property key).
+ * @template V - The type of values.
+ * @param keys - The property keys.
+ * @param values - The property values.
+ * @returns The new object.
+ * @deprecated Use `Object.fromEntries()` with `map()` or `zip()` directly instead.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries | Object.fromEntries() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_object_fromentries | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach
+ * zipObject(['a', 'b'], [1, 2]);
+ * // => { a: 1, b: 2 }
+ *
+ * // ✅ Recommended approach
+ * Object.fromEntries(['a', 'b'].map((k, i) => [k, [1, 2][i]]));
+ * // => { a: 1, b: 2 }
+ *
+ * // Or using zip from Arkhe
+ * import { zip } from '@pithos/arkhe/array/zip';
+ * Object.fromEntries(zip(['a', 'b'], [1, 2]));
+ * // => { a: 1, b: 2 }
+ * ```
+ */
+export function zipObject(keys, values) {
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        result[keys[i]] = values[i];
+    }
+    return result;
+}
+//# sourceMappingURL=zipObject.js.map

package/dist/taphos/array/zipObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipObject.js","sourceRoot":"","sources":["../../../src/taphos/array/zipObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,SAAS,CACvB,IAAkB,EAClB,MAAoB;IAEpB,MAAM,MAAM,GAAG,EAAkB,CAAC;IAElC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/taphos/collection/each.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Iterates over elements of collection and invokes iteratee for each element.
+ *
+ * @template T - The type of elements in the array, or the object type.
+ * @param collection - The collection to iterate over.
+ * @param iteratee - The function invoked per iteration.
+ * @returns The original collection.
+ * @deprecated Use `array.forEach()` or `for...of` loop directly instead.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach | Array.forEach() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_foreach | Browser support - Can I Use}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries | Object.entries() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_object_entries | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * each(numbers, (value, index) => {
+ *   console.log(`Index ${index}: ${value}`);
+ * });
+ *
+ * // ✅ Recommended approach (for arrays)
+ * numbers.forEach((value, index) => {
+ *   console.log(`Index ${index}: ${value}`);
+ * });
+ *
+ * // ✅ Alternative with for...of
+ * for (const [index, value] of numbers.entries()) {
+ *   console.log(`Index ${index}: ${value}`);
+ * }
+ *
+ * // ✅ Recommended approach (for objects)
+ * const obj = { a: 1, b: 2, c: 3 };
+ * Object.entries(obj).forEach(([key, value]) => {
+ *   console.log(`${key}: ${value}`);
+ * });
+ * ```
+ */
+export declare function each<T>(collection: T[], iteratee: (value: T, index: number, array: T[]) => void): T[];
+export declare function each<T extends Record<string, unknown>>(collection: T, iteratee: (value: T[keyof T], key: keyof T, object: T) => void): T;
+//# sourceMappingURL=each.d.ts.map

package/dist/taphos/collection/each.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"each.d.ts","sourceRoot":"","sources":["../../../src/taphos/collection/each.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,wBAAgB,IAAI,CAAC,CAAC,EACpB,UAAU,EAAE,CAAC,EAAE,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,GACtD,CAAC,EAAE,CAAC;AACP,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpD,UAAU,EAAE,CAAC,EACb,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,IAAI,GAC7D,CAAC,CAAC"}

package/dist/taphos/collection/each.js

@@ -0,0 +1,51 @@
+/**
+ * Iterates over elements of collection and invokes iteratee for each element.
+ *
+ * @template T - The type of elements in the array, or the object type.
+ * @param collection - The collection to iterate over.
+ * @param iteratee - The function invoked per iteration.
+ * @returns The original collection.
+ * @deprecated Use `array.forEach()` or `for...of` loop directly instead.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach | Array.forEach() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_foreach | Browser support - Can I Use}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries | Object.entries() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_object_entries | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * each(numbers, (value, index) => {
+ *   console.log(`Index ${index}: ${value}`);
+ * });
+ *
+ * // ✅ Recommended approach (for arrays)
+ * numbers.forEach((value, index) => {
+ *   console.log(`Index ${index}: ${value}`);
+ * });
+ *
+ * // ✅ Alternative with for...of
+ * for (const [index, value] of numbers.entries()) {
+ *   console.log(`Index ${index}: ${value}`);
+ * }
+ *
+ * // ✅ Recommended approach (for objects)
+ * const obj = { a: 1, b: 2, c: 3 };
+ * Object.entries(obj).forEach(([key, value]) => {
+ *   console.log(`${key}: ${value}`);
+ * });
+ * ```
+ */
+// INTENTIONAL: Implementation signature uses `unknown` to satisfy both overloads - public API is type-safe via overloads
+export function each(collection, iteratee) {
+    if (Array.isArray(collection)) {
+        collection.forEach(iteratee);
+        return collection;
+    }
+    const obj = collection;
+    Object.entries(obj).forEach(([key, value]) => iteratee(value, key, obj));
+    return collection;
+}
+//# sourceMappingURL=each.js.map

package/dist/taphos/collection/each.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"each.js","sourceRoot":"","sources":["../../../src/taphos/collection/each.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAUH,yHAAyH;AACzH,MAAM,UAAU,IAAI,CAClB,UAAmB,EACnB,QAAiB;IAEjB,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QAC7B,UAAwB,CAAC,OAAO,CAAC,QAAqE,CAAC,CAAC;QACzG,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM,GAAG,GAAG,UAAqC,CAAC;IAClD,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAC1C,QAAmF,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,CACtG,CAAC;IACF,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/taphos/collection/eachRight.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Iterates over elements of collection from right to left.
+ *
+ * @template T - The type of elements in the collection.
+ * @param collection - The collection to iterate over.
+ * @param iteratee - The function invoked per iteration.
+ * @deprecated Use `[...array].reverse().forEach()` directly instead.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach | Array.forEach() - MDN}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach
+ * eachRight([1, 2, 3], x => console.log(x));
+ * // logs: 3, 2, 1
+ *
+ * // ✅ Recommended approach
+ * [...[1, 2, 3]].reverse().forEach(x => console.log(x));
+ * // logs: 3, 2, 1
+ * ```
+ */
+export declare function eachRight<T>(collection: readonly T[], iteratee: (value: T, index: number, collection: readonly T[]) => void): void;
+/**
+ * Alias for `eachRight`.
+ *
+ * @deprecated Use `[...array].reverse().forEach()` directly instead.
+ * @since 2.0.0
+ */
+export declare const forEachRight: typeof eachRight;
+//# sourceMappingURL=eachRight.d.ts.map

package/dist/taphos/collection/eachRight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eachRight.d.ts","sourceRoot":"","sources":["../../../src/taphos/collection/eachRight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,UAAU,EAAE,SAAS,CAAC,EAAE,EACxB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,GACpE,IAAI,CAIN;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,kBAAY,CAAC"}

package/dist/taphos/collection/eachRight.js

@@ -0,0 +1,34 @@
+/**
+ * Iterates over elements of collection from right to left.
+ *
+ * @template T - The type of elements in the collection.
+ * @param collection - The collection to iterate over.
+ * @param iteratee - The function invoked per iteration.
+ * @deprecated Use `[...array].reverse().forEach()` directly instead.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach | Array.forEach() - MDN}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach
+ * eachRight([1, 2, 3], x => console.log(x));
+ * // logs: 3, 2, 1
+ *
+ * // ✅ Recommended approach
+ * [...[1, 2, 3]].reverse().forEach(x => console.log(x));
+ * // logs: 3, 2, 1
+ * ```
+ */
+export function eachRight(collection, iteratee) {
+    for (let i = collection.length - 1; i >= 0; i--) {
+        iteratee(collection[i], i, collection);
+    }
+}
+/**
+ * Alias for `eachRight`.
+ *
+ * @deprecated Use `[...array].reverse().forEach()` directly instead.
+ * @since 2.0.0
+ */
+export const forEachRight = eachRight;
+//# sourceMappingURL=eachRight.js.map

package/dist/taphos/collection/eachRight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eachRight.js","sourceRoot":"","sources":["../../../src/taphos/collection/eachRight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,SAAS,CACvB,UAAwB,EACxB,QAAqE;IAErE,KAAK,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAChD,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC;IACzC,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,SAAS,CAAC"}