@pithos/core 2.0.0

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

@@ -0,0 +1,28 @@
+/**
+ * Converts all elements in array into a string separated by separator.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to convert.
+ * @param separator - The element separator.
+ * @returns The joined string.
+ * @deprecated Use `array.join(separator)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join | Array.join() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_join | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const joined = join(numbers, '-');
+ * console.log(joined); // "1-2-3-4-5"
+ *
+ * // ✅ Recommended approach
+ * const joinedNative = numbers.join('-');
+ * console.log(joinedNative); // "1-2-3-4-5"
+ * ```
+ */
+export declare function join<T>(array: T[], separator?: string): string;
+//# sourceMappingURL=join.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,GAAE,MAAY,GAAG,MAAM,CAEnE"}

package/dist/taphos/array/join.js

@@ -0,0 +1,30 @@
+/**
+ * Converts all elements in array into a string separated by separator.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to convert.
+ * @param separator - The element separator.
+ * @returns The joined string.
+ * @deprecated Use `array.join(separator)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join | Array.join() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_join | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const joined = join(numbers, '-');
+ * console.log(joined); // "1-2-3-4-5"
+ *
+ * // ✅ Recommended approach
+ * const joinedNative = numbers.join('-');
+ * console.log(joinedNative); // "1-2-3-4-5"
+ * ```
+ */
+export function join(array, separator = ",") {
+    return array.join(separator);
+}
+//# sourceMappingURL=join.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"join.js","sourceRoot":"","sources":["../../../src/taphos/array/join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,IAAI,CAAI,KAAU,EAAE,YAAoB,GAAG;IACzD,OAAO,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAC/B,CAAC"}

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

@@ -0,0 +1,31 @@
+/**
+ * Gets the last element of array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @returns The last element of the array, or `undefined` if empty.
+ * @deprecated Use `array[array.length - 1]` or `array.at(-1)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_at | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const lastElement = last(numbers);
+ * console.log(lastElement); // 5
+ *
+ * // ✅ Recommended approach
+ * const lastNative = numbers[numbers.length - 1];
+ * console.log(lastNative); // 5
+ *
+ * // ✅ Modern approach with ES2022
+ * const lastModern = numbers.at(-1);
+ * console.log(lastModern); // 5
+ * ```
+ */
+export declare function last<T>(array: T[]): T | undefined;
+//# sourceMappingURL=last.d.ts.map

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

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

package/dist/taphos/array/last.js

@@ -0,0 +1,33 @@
+/**
+ * Gets the last element of array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @returns The last element of the array, or `undefined` if empty.
+ * @deprecated Use `array[array.length - 1]` or `array.at(-1)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_at | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const lastElement = last(numbers);
+ * console.log(lastElement); // 5
+ *
+ * // ✅ Recommended approach
+ * const lastNative = numbers[numbers.length - 1];
+ * console.log(lastNative); // 5
+ *
+ * // ✅ Modern approach with ES2022
+ * const lastModern = numbers.at(-1);
+ * console.log(lastModern); // 5
+ * ```
+ */
+export function last(array) {
+    return array[array.length - 1];
+}
+//# sourceMappingURL=last.js.map

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * Gets the index at which the last occurrence of value is found in array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to search.
+ * @param value - The value to search for.
+ * @param fromIndex - The index to search from.
+ * @returns The index of the matched value, or `-1` if not found.
+ * @deprecated Use `array.lastIndexOf(value)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf | Array.lastIndexOf() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_lastindexof | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 2, 4];
+ *
+ * // ❌ Deprecated approach
+ * const index = lastIndexOf(numbers, 2);
+ * console.log(index); // 3
+ *
+ * // ✅ Recommended approach
+ * const indexNative = numbers.lastIndexOf(2);
+ * console.log(indexNative); // 3
+ * ```
+ */
+export declare function lastIndexOf<T>(array: T[], value: T, fromIndex?: number): number;
+//# sourceMappingURL=lastIndexOf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lastIndexOf.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/lastIndexOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,EACR,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAKR"}

package/dist/taphos/array/lastIndexOf.js

@@ -0,0 +1,34 @@
+/**
+ * Gets the index at which the last occurrence of value is found in array.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to search.
+ * @param value - The value to search for.
+ * @param fromIndex - The index to search from.
+ * @returns The index of the matched value, or `-1` if not found.
+ * @deprecated Use `array.lastIndexOf(value)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf | Array.lastIndexOf() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_lastindexof | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 2, 4];
+ *
+ * // ❌ Deprecated approach
+ * const index = lastIndexOf(numbers, 2);
+ * console.log(index); // 3
+ *
+ * // ✅ Recommended approach
+ * const indexNative = numbers.lastIndexOf(2);
+ * console.log(indexNative); // 3
+ * ```
+ */
+export function lastIndexOf(array, value, fromIndex) {
+    if (fromIndex === undefined) {
+        return array.lastIndexOf(value);
+    }
+    return array.lastIndexOf(value, fromIndex);
+}
+//# sourceMappingURL=lastIndexOf.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lastIndexOf.js","sourceRoot":"","sources":["../../../src/taphos/array/lastIndexOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,WAAW,CACzB,KAAU,EACV,KAAQ,EACR,SAAkB;IAElB,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,KAAK,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAC7C,CAAC"}

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

@@ -0,0 +1,29 @@
+/**
+ * Creates an array of values by running each element in array through iteratee.
+ *
+ * @template T - The type of elements in the input array.
+ * @template Result - The type of elements in the output array.
+ * @param array - The array to iterate over.
+ * @param iteratee - The function invoked per iteration.
+ * @returns A new mapped array.
+ * @deprecated Use `array.map(callback)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map | Array.map() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_map | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const doubled = map(numbers, x => x * 2);
+ * console.log(doubled); // [2, 4, 6, 8, 10]
+ *
+ * // ✅ Recommended approach
+ * const doubledNative = numbers.map(x => x * 2);
+ * console.log(doubledNative); // [2, 4, 6, 8, 10]
+ * ```
+ */
+export declare function map<T, Result>(array: T[], iteratee: (value: T, index: number, array: T[]) => Result): Result[];
+//# sourceMappingURL=map.d.ts.map

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

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

package/dist/taphos/array/map.js

@@ -0,0 +1,31 @@
+/**
+ * Creates an array of values by running each element in array through iteratee.
+ *
+ * @template T - The type of elements in the input array.
+ * @template Result - The type of elements in the output array.
+ * @param array - The array to iterate over.
+ * @param iteratee - The function invoked per iteration.
+ * @returns A new mapped array.
+ * @deprecated Use `array.map(callback)` directly instead.
+ * Reason: Native equivalent method now available
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map | Array.map() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_map | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const doubled = map(numbers, x => x * 2);
+ * console.log(doubled); // [2, 4, 6, 8, 10]
+ *
+ * // ✅ Recommended approach
+ * const doubledNative = numbers.map(x => x * 2);
+ * console.log(doubledNative); // [2, 4, 6, 8, 10]
+ * ```
+ */
+export function map(array, iteratee) {
+    return array.map(iteratee);
+}
+//# sourceMappingURL=map.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../src/taphos/array/map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,GAAG,CACjB,KAAU,EACV,QAAyD;IAEzD,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC7B,CAAC"}

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

@@ -0,0 +1,34 @@
+/**
+ * Gets the element at index n of array.
+ *
+ * If n is negative, the nth element from the end is returned. Alias for {@link at}.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param index - The index of the element to return.
+ * @returns The element at the given index, or `undefined` if out of bounds.
+ * @deprecated Use `array.at(index)` directly instead.
+ * Reason: Alias of {@link at}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_at | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const last = nth(numbers, -1);
+ * console.log(last); // 5
+ *
+ * // ✅ Recommended approach
+ * const lastNative = numbers[numbers.length - 1];
+ * console.log(lastNative); // 5
+ *
+ * // ✅ Modern approach with ES2022
+ * const lastModern = numbers.at(-1);
+ * console.log(lastModern); // 5
+ * ```
+ */
+export declare function nth<T>(array: T[], index: number): T | undefined;
+//# sourceMappingURL=nth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nth.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/nth.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAE/D"}

package/dist/taphos/array/nth.js

@@ -0,0 +1,37 @@
+import { at } from "./at";
+/**
+ * Gets the element at index n of array.
+ *
+ * If n is negative, the nth element from the end is returned. Alias for {@link at}.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to query.
+ * @param index - The index of the element to return.
+ * @returns The element at the given index, or `undefined` if out of bounds.
+ * @deprecated Use `array.at(index)` directly instead.
+ * Reason: Alias of {@link at}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at() - MDN}
+ * @see {@link https://caniuse.com/mdn-javascript_builtins_array_at | Browser support - Can I Use}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * // ❌ Deprecated approach
+ * const last = nth(numbers, -1);
+ * console.log(last); // 5
+ *
+ * // ✅ Recommended approach
+ * const lastNative = numbers[numbers.length - 1];
+ * console.log(lastNative); // 5
+ *
+ * // ✅ Modern approach with ES2022
+ * const lastModern = numbers.at(-1);
+ * console.log(lastModern); // 5
+ * ```
+ */
+export function nth(array, index) {
+    return at(array, index);
+}
+//# sourceMappingURL=nth.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nth.js","sourceRoot":"","sources":["../../../src/taphos/array/nth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,GAAG,CAAI,KAAU,EAAE,KAAa;IAC5C,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC5B,CAAC"}

package/dist/taphos/array/pull-all.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Creates an array excluding all specified values.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to exclude.
+ * @returns The mutated array.
+ * @deprecated Use {@link difference} from Arkhe instead.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @see {@link difference}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 2];
+ * pullAll(numbers, [2, 3]);
+ * console.log(numbers); // [1, 4]
+ * ```
+ */
+export declare function pullAll<T>(array: T[], values: T[]): T[];
+//# sourceMappingURL=pull-all.d.ts.map

package/dist/taphos/array/pull-all.d.ts.map

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

package/dist/taphos/array/pull-all.js

@@ -0,0 +1,26 @@
+import { pull } from "./pull";
+/**
+ * Creates an array excluding all specified values.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to exclude.
+ * @returns The mutated array.
+ * @deprecated Use {@link difference} from Arkhe instead.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @see {@link difference}
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 2];
+ * pullAll(numbers, [2, 3]);
+ * console.log(numbers); // [1, 4]
+ * ```
+ */
+export function pullAll(array, values) {
+    return pull(array, ...values);
+}
+//# sourceMappingURL=pull-all.js.map

package/dist/taphos/array/pull-all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull-all.js","sourceRoot":"","sources":["../../../src/taphos/array/pull-all.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,OAAO,CAAI,KAAU,EAAE,MAAW;IAC9C,OAAO,IAAI,CAAC,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC;AAClC,CAAC"}

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

@@ -0,0 +1,22 @@
+/**
+ * Removes all given values from array using SameValueZero for equality comparisons.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to remove.
+ * @returns The mutated array.
+ * @deprecated Use `difference` instead.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const array = [1, 2, 3, 1, 2, 3];
+ * pull(array, 2, 3);
+ * console.log(array); // [1, 1]
+ * ```
+ */
+export declare function pull<T>(array: T[], ...values: T[]): T[];
+//# sourceMappingURL=pull.d.ts.map

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

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

package/dist/taphos/array/pull.js

@@ -0,0 +1,33 @@
+/**
+ * Removes all given values from array using SameValueZero for equality comparisons.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to remove.
+ * @returns The mutated array.
+ * @deprecated Use `difference` instead.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const array = [1, 2, 3, 1, 2, 3];
+ * pull(array, 2, 3);
+ * console.log(array); // [1, 1]
+ * ```
+ */
+export function pull(array, ...values) {
+    const excludeSet = new Set(values);
+    let w = 0;
+    for (let r = 0; r < array.length; r++) {
+        const item = array[r];
+        if (!excludeSet.has(item)) {
+            array[w++] = item;
+        }
+    }
+    array.length = w;
+    return array;
+}
+//# sourceMappingURL=pull.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pull.js","sourceRoot":"","sources":["../../../src/taphos/array/pull.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,IAAI,CAAI,KAAU,EAAE,GAAG,MAAW;IAChD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;QACpB,CAAC;IACH,CAAC;IACD,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IACjB,OAAO,KAAK,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,31 @@
+/**
+ * Removes all given values from array using an iteratee for equality comparisons.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to remove.
+ * @param iteratee - A function or property key to compute the comparison value.
+ * @returns The mutated array.
+ * @deprecated Use `differenceBy` instead for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @see differenceBy
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * pullAllBy(array, [{ x: 1 }, { x: 3 }], 'x');
+ * console.log(array); // [{ x: 2 }]
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const result = differenceBy(array, [{ x: 1 }, { x: 3 }], 'x');
+ * console.log(result); // [{ x: 2 }]
+ * console.log(array);  // [{ x: 1 }, { x: 2 }, { x: 3 }] (unchanged)
+ * ```
+ */
+export declare function pullAllBy<T>(array: T[], values: readonly T[], iteratee: ((item: T) => unknown) | keyof T): T[];
+//# sourceMappingURL=pullAllBy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pullAllBy.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/pullAllBy.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,CAAC,EAAE,EACV,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,GACzC,CAAC,EAAE,CAOL"}

package/dist/taphos/array/pullAllBy.js

@@ -0,0 +1,37 @@
+import { differenceBy } from "../../arkhe/array/difference-by";
+/**
+ * Removes all given values from array using an iteratee for equality comparisons.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to remove.
+ * @param iteratee - A function or property key to compute the comparison value.
+ * @returns The mutated array.
+ * @deprecated Use `differenceBy` instead for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @see differenceBy
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * pullAllBy(array, [{ x: 1 }, { x: 3 }], 'x');
+ * console.log(array); // [{ x: 2 }]
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const result = differenceBy(array, [{ x: 1 }, { x: 3 }], 'x');
+ * console.log(result); // [{ x: 2 }]
+ * console.log(array);  // [{ x: 1 }, { x: 2 }, { x: 3 }] (unchanged)
+ * ```
+ */
+export function pullAllBy(array, values, iteratee) {
+    const kept = differenceBy(array, values, iteratee);
+    array.length = 0;
+    array.push(...kept);
+    return array;
+}
+//# sourceMappingURL=pullAllBy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pullAllBy.js","sourceRoot":"","sources":["../../../src/taphos/array/pullAllBy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,SAAS,CACvB,KAAU,EACV,MAAoB,EACpB,QAA0C;IAE1C,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAEnD,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IACjB,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;IAEpB,OAAO,KAAK,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,31 @@
+/**
+ * Removes all given values from array using a comparator function for equality.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to remove.
+ * @param comparator - The function invoked to compare elements.
+ * @returns The mutated array.
+ * @deprecated Use `differenceWith` instead for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @see differenceWith
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * pullAllWith(array, [{ x: 3, y: 4 }], (a, b) => a.x === b.x && a.y === b.y);
+ * console.log(array); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const result = differenceWith(array, [{ x: 3, y: 4 }], (a, b) => a.x === b.x && a.y === b.y);
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ * console.log(array);  // unchanged
+ * ```
+ */
+export declare function pullAllWith<T>(array: T[], values: readonly T[], comparator: (a: T, b: T) => boolean): T[];
+//# sourceMappingURL=pullAllWith.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pullAllWith.d.ts","sourceRoot":"","sources":["../../../src/taphos/array/pullAllWith.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,EAAE,EACV,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAClC,CAAC,EAAE,CAOL"}

package/dist/taphos/array/pullAllWith.js

@@ -0,0 +1,37 @@
+import { differenceWith } from "../../arkhe/array/difference-with";
+/**
+ * Removes all given values from array using a comparator function for equality.
+ *
+ * @note **Mutates** the array in place.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to modify.
+ * @param values - The values to remove.
+ * @param comparator - The function invoked to compare elements.
+ * @returns The mutated array.
+ * @deprecated Use `differenceWith` instead for immutable operations.
+ * Reason: Pithos design philosophy always favors immutability.
+ * @see differenceWith
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // ❌ Deprecated approach (mutates array)
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * pullAllWith(array, [{ x: 3, y: 4 }], (a, b) => a.x === b.x && a.y === b.y);
+ * console.log(array); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ *
+ * // ✅ Recommended approach (immutable)
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const result = differenceWith(array, [{ x: 3, y: 4 }], (a, b) => a.x === b.x && a.y === b.y);
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ * console.log(array);  // unchanged
+ * ```
+ */
+export function pullAllWith(array, values, comparator) {
+    const kept = differenceWith(array, values, comparator);
+    array.length = 0;
+    array.push(...kept);
+    return array;
+}
+//# sourceMappingURL=pullAllWith.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pullAllWith.js","sourceRoot":"","sources":["../../../src/taphos/array/pullAllWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,WAAW,CACzB,KAAU,EACV,MAAoB,EACpB,UAAmC;IAEnC,MAAM,IAAI,GAAG,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;IAEvD,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IACjB,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;IAEpB,OAAO,KAAK,CAAC;AACf,CAAC"}