es-toolkit 1.35.0-dev.1174 → 1.35.0-dev.1178

package/dist/compat/array/partition.d.mts

@@ -1,121 +1,65 @@
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
  * `predicate` returns truthy for, the second of which contains elements
- * `predicate` returns falsy for.
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {(item: T, index: number, arr: readonly T[]) => unknown} doesMatch - The function invoked per iteration.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @template U
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {(value: T) => value is U} predicate - The function invoked per iteration.
+ * @returns {[U[], Array<Exclude<T, U>>]} - Returns the array of grouped elements.
  *
  * @example
- * partition([1, 2, 3], n => n % 2 === 0)
- * // => [[2], [1, 3]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
  */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the given key-value pair.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): [T[], T[]];
+declare function partition<T, U extends T>(source: ArrayLike<T> | null | undefined, predicate: (value: T) => value is U): [U[], Array<Exclude<T, U>>];
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
- * partition(arr, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the predicate function.
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch - The function invoked per iteration.
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
  * @returns {[T[], T[]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
- * partition(obj, value => value.a)
- * // => [[{ a: 1 }], [{ a: 0 }, { a: 0 }]]
- *
- * const obj = { a: 1, b: 2, c: 3 };
- * partition(obj, value => value > 2)
- * // => [[3], [1, 2]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
- * partition(obj, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
+ * // => [[2], [1, 3, 4]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): [T[], T[]];
+declare function partition<T>(source: ArrayLike<T> | null | undefined, predicate?: ((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>): [T[], T[]];
 /**
- * Creates an array of elements split into two groups based on the given key-value pair.
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
  * @param {T | null | undefined} object - The object to iterate over.
- * @param {[keyof T[keyof T], unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @param {((item: T[keyof T], key: keyof T) => unknown) | Partial<T[keyof T]> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[keyof T][], T[keyof T][]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
- * partition(obj, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): [T[], T[]];
-/**
- * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
+ * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
+ * // => [[2], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition({ a: 1, b: 2, c: 3 }, 'a');
+ * // => [[1], [2, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
- * partition(obj, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
+ * partition({ a: 1, b: 2, c: 3 }, ['a', 1]);
+ * // => [[1], [2, 3]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
+declare function partition<T extends object>(object: T | null | undefined, predicate?: ((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
 
 export { partition };

package/dist/compat/array/partition.d.ts

@@ -1,121 +1,65 @@
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
  * `predicate` returns truthy for, the second of which contains elements
- * `predicate` returns falsy for.
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {(item: T, index: number, arr: readonly T[]) => unknown} doesMatch - The function invoked per iteration.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @template U
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {(value: T) => value is U} predicate - The function invoked per iteration.
+ * @returns {[U[], Array<Exclude<T, U>>]} - Returns the array of grouped elements.
  *
  * @example
- * partition([1, 2, 3], n => n % 2 === 0)
- * // => [[2], [1, 3]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
  */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the given key-value pair.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): [T[], T[]];
+declare function partition<T, U extends T>(source: ArrayLike<T> | null | undefined, predicate: (value: T) => value is U): [U[], Array<Exclude<T, U>>];
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
- * partition(arr, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the predicate function.
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch - The function invoked per iteration.
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
  * @returns {[T[], T[]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
- * partition(obj, value => value.a)
- * // => [[{ a: 1 }], [{ a: 0 }, { a: 0 }]]
- *
- * const obj = { a: 1, b: 2, c: 3 };
- * partition(obj, value => value > 2)
- * // => [[3], [1, 2]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
- * partition(obj, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
+ * // => [[2], [1, 3, 4]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): [T[], T[]];
+declare function partition<T>(source: ArrayLike<T> | null | undefined, predicate?: ((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>): [T[], T[]];
 /**
- * Creates an array of elements split into two groups based on the given key-value pair.
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
  * @param {T | null | undefined} object - The object to iterate over.
- * @param {[keyof T[keyof T], unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @param {((item: T[keyof T], key: keyof T) => unknown) | Partial<T[keyof T]> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[keyof T][], T[keyof T][]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
- * partition(obj, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): [T[], T[]];
-/**
- * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
+ * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
+ * // => [[2], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition({ a: 1, b: 2, c: 3 }, 'a');
+ * // => [[1], [2, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
- * partition(obj, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
+ * partition({ a: 1, b: 2, c: 3 }, ['a', 1]);
+ * // => [[1], [2, 3]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
+declare function partition<T extends object>(object: T | null | undefined, predicate?: ((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
 
 export { partition };

package/dist/compat/array/partition.mjs

@@ -1,4 +1,3 @@
-import { isArray } from '../predicate/isArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { iteratee } from '../util/iteratee.mjs';
 
@@ -6,28 +5,13 @@ function partition(source, predicate) {
     if (!source) {
         return [[], []];
     }
-    const collection = isArray(source) ? source : Object.values(source);
+    const collection = isArrayLike(source) ? source : Object.values(source);
     predicate = iteratee(predicate);
     const matched = [];
     const unmatched = [];
-    if (!isArray(source)) {
-        const keys = Object.keys(source);
-        const length = isArrayLike(source) ? source.length : keys.length;
-        for (let i = 0; i < length; i++) {
-            const key = keys[i];
-            const value = source[key];
-            if (predicate(value, key, source)) {
-                matched.push(value);
-            }
-            else {
-                unmatched.push(value);
-            }
-        }
-        return [matched, unmatched];
-    }
     for (let i = 0; i < collection.length; i++) {
         const value = collection[i];
-        if (predicate(value, i, source)) {
+        if (predicate(value)) {
             matched.push(value);
         }
         else {

package/dist/compat/array/pullAllWith.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Removes elements from an array that match the given comparator function and returns the modified array.
+ *
+ * This function mutates the original array by removing elements that match the criteria defined by `comparator`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which elements will be removed.
+ * @param {T[]} values - The values to compare against, which determine which elements should be removed.
+ * @param {(a: T, b: T) => boolean} comparator - A function that compares elements in `array` with `values`. If it returns `true`, the element is removed.
+ * @returns {T[]} - The modified array after removing matching elements.
+ *
+ * @example
+ * import pullAllWith from './pullAllWith';
+ * import isEqual from '../predicate';
+ *
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ * console.log(array);  // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T>(arr: T[], values: T[], comparator: (a: T, b: T) => boolean): T[];
+
+export { pullAllWith };

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

@@ -0,0 +1,26 @@
+/**
+ * Removes elements from an array that match the given comparator function and returns the modified array.
+ *
+ * This function mutates the original array by removing elements that match the criteria defined by `comparator`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which elements will be removed.
+ * @param {T[]} values - The values to compare against, which determine which elements should be removed.
+ * @param {(a: T, b: T) => boolean} comparator - A function that compares elements in `array` with `values`. If it returns `true`, the element is removed.
+ * @returns {T[]} - The modified array after removing matching elements.
+ *
+ * @example
+ * import pullAllWith from './pullAllWith';
+ * import isEqual from '../predicate';
+ *
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ * console.log(array);  // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T>(arr: T[], values: T[], comparator: (a: T, b: T) => boolean): T[];
+
+export { pullAllWith };

package/dist/compat/array/pullAllWith.mjs

@@ -0,0 +1,19 @@
+function pullAllWith(arr, values, comparator) {
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        if (!(i in arr)) {
+            if (!values.includes(undefined)) {
+                delete arr[resultIndex++];
+            }
+            continue;
+        }
+        const shouldRemove = values.some(value => comparator(arr[i], value));
+        if (!shouldRemove) {
+            arr[resultIndex++] = arr[i];
+        }
+    }
+    arr.length = resultIndex;
+    return arr;
+}
+
+export { pullAllWith };

package/dist/compat/index.d.mts

@@ -100,6 +100,7 @@ export { partition } from './array/partition.mjs';
 export { pull } from './array/pull.mjs';
 export { pullAll } from './array/pullAll.mjs';
 export { pullAllBy } from './array/pullAllBy.mjs';
+export { pullAllWith } from './array/pullAllWith.mjs';
 export { reduce } from './array/reduce.mjs';
 export { reduceRight } from './array/reduceRight.mjs';
 export { reject } from './array/reject.mjs';

package/dist/compat/index.d.ts

@@ -100,6 +100,7 @@ export { partition } from './array/partition.js';
 export { pull } from './array/pull.js';
 export { pullAll } from './array/pullAll.js';
 export { pullAllBy } from './array/pullAllBy.js';
+export { pullAllWith } from './array/pullAllWith.js';
 export { reduce } from './array/reduce.js';
 export { reduceRight } from './array/reduceRight.js';
 export { reject } from './array/reject.js';

package/dist/compat/index.js

@@ -1220,28 +1220,13 @@ function partition(source, predicate) {
     if (!source) {
         return [[], []];
     }
-    const collection = toSnakeCaseKeys.isArray(source) ? source : Object.values(source);
+    const collection = isArrayLike(source) ? source : Object.values(source);
     predicate = iteratee(predicate);
     const matched = [];
     const unmatched = [];
-    if (!toSnakeCaseKeys.isArray(source)) {
-        const keys = Object.keys(source);
-        const length = isArrayLike(source) ? source.length : keys.length;
-        for (let i = 0; i < length; i++) {
-            const key = keys[i];
-            const value = source[key];
-            if (predicate(value, key, source)) {
-                matched.push(value);
-            }
-            else {
-                unmatched.push(value);
-            }
-        }
-        return [matched, unmatched];
-    }
     for (let i = 0; i < collection.length; i++) {
         const value = collection[i];
-        if (predicate(value, i, source)) {
+        if (predicate(value)) {
             matched.push(value);
         }
         else {
@@ -1278,6 +1263,24 @@ function pullAllBy(arr, valuesToRemove, _getValue) {
     return arr;
 }
 
+function pullAllWith(arr, values, comparator) {
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        if (!(i in arr)) {
+            if (!values.includes(undefined)) {
+                delete arr[resultIndex++];
+            }
+            continue;
+        }
+        const shouldRemove = values.some(value => comparator(arr[i], value));
+        if (!shouldRemove) {
+            arr[resultIndex++] = arr[i];
+        }
+    }
+    arr.length = resultIndex;
+    return arr;
+}
+
 function reduce(collection, iteratee = unary.identity, accumulator) {
     if (!collection) {
         return accumulator;
@@ -3821,6 +3824,7 @@ exports.propertyOf = propertyOf;
 exports.pull = pull;
 exports.pullAll = pullAll;
 exports.pullAllBy = pullAllBy;
+exports.pullAllWith = pullAllWith;
 exports.random = random;
 exports.range = range;
 exports.rangeRight = rangeRight;

package/dist/compat/index.mjs

@@ -102,6 +102,7 @@ export { partition } from './array/partition.mjs';
 export { pull } from './array/pull.mjs';
 export { pullAll } from './array/pullAll.mjs';
 export { pullAllBy } from './array/pullAllBy.mjs';
+export { pullAllWith } from './array/pullAllWith.mjs';
 export { reduce } from './array/reduce.mjs';
 export { reduceRight } from './array/reduceRight.mjs';
 export { reject } from './array/reject.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.35.0-dev.1174+b82b79e5",
+  "version": "1.35.0-dev.1178+028c36e4",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {