es-toolkit 1.16.0 → 1.17.0-dev.504

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # es-toolkit Changelog
 
+## Version v1.17.0
+
+Released on August 31st, 2024.
+
+### New Features
+
+- Added support for new functions: [at](https://es-toolkit.slash.page/reference/array/at.html), [pullAt](https://es-toolkit.slash.page/reference/array/pullAt.html), [deburr](https://es-toolkit.slash.page/reference/string/deburr.html), [lowerFirst](https://es-toolkit.slash.page/reference/string/lowerFirst.html), [upperFirst](https://es-toolkit.slash.page/reference/string/upperFirst.html), and [isRegExp](https://es-toolkit.slash.page/reference/predicate/isRegExp.html).
+- Enhanced [orderBy](https://es-toolkit.slash.page/reference/array/orderBy.html) and [sortBy](https://es-toolkit.slash.page/reference/array/sortBy.html) to support function criteria.
+- [countBy](https://es-toolkit.slash.page/reference/array/countBy.html) now supports numeric and symbol keys.
+
+#### Bug Fixes
+
+- Updated type definitions for [throttle](https://es-toolkit.slash.page/reference/function/throttle.html) and [debounce](https://es-toolkit.slash.page/reference/function/debounce.html).
+- (`es-toolkit/compat`) Fixed [orderBy](https://es-toolkit.slash.page/reference/array/orderBy.html) to correctly handle deep keys even when object shapes differ ([#427](https://github.com/toss/es-toolkit/pull/427)).
+
 ## Version v1.16.0
 
 Released on August 15th, 2024.

package/README.md

@@ -2,7 +2,7 @@
 
 # es-toolkit · [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/es-toolkit/graph/badge.svg?token=8N5S3AR3C7)](https://codecov.io/gh/toss/es-toolkit) [![NPM badge](https://img.shields.io/npm/v/es-toolkit?logo=npm)](https://www.npmjs.com/package/es-toolkit) [![JSR badge](https://jsr.io/badges/@es-toolkit/es-toolkit)](https://jsr.io/@es-toolkit/es-toolkit)
 
-English | [한국어](https://github.com/toss/es-toolkit/blob/main/README-ko_kr.md) | [简体中文](https://github.com/toss/es-toolkit/blob/main/README-zh_hans.md)
+English | [한국어](https://github.com/toss/es-toolkit/blob/main/README-ko_kr.md) | [简体中文](https://github.com/toss/es-toolkit/blob/main/README-zh_hans.md) | [日本語](https://github.com/toss/es-toolkit/blob/main/README-ja_jp.md)
 
 es-toolkit is a state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.
 

package/dist/_chunk/{index-CwRt_M.js → index-CoqN5B.js}

@@ -43,4 +43,5 @@ async function withTimeout(run, ms) {
 exports.AbortError = AbortError;
 exports.TimeoutError = TimeoutError;
 exports.delay = delay;
+exports.timeout = timeout;
 exports.withTimeout = withTimeout;

package/dist/_chunk/{initial-y0QrPY.js → initial-Ci2bn_.js}

@@ -2,6 +2,15 @@
 
 const randomInt = require('./randomInt-CF7bZK.js');
 
+function at(arr, indices) {
+    const result = [];
+    for (let i = 0; i < indices.length; i++) {
+        const index = indices[i];
+        result.push(arr.at(index));
+    }
+    return result;
+}
+
 function chunk(arr, size) {
     if (!Number.isInteger(size) || size <= 0) {
         throw new Error('Size must be an integer greater than zero.');
@@ -200,6 +209,24 @@ function compareValues(a, b, order) {
     return 0;
 }
 
+function orderBy(arr, criteria, orders) {
+    return arr.slice().sort((a, b) => {
+        const ordersLength = orders.length;
+        for (let i = 0; i < criteria.length; i++) {
+            const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
+            const criterion = criteria[i];
+            const criterionIsFunction = typeof criterion === 'function';
+            const valueA = criterionIsFunction ? criterion(a) : a[criterion];
+            const valueB = criterionIsFunction ? criterion(b) : b[criterion];
+            const result = compareValues(valueA, valueB, order);
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    });
+}
+
 function partition(arr, isInTruthy) {
     const truthy = [];
     const falsy = [];
@@ -214,20 +241,17 @@ function partition(arr, isInTruthy) {
     return [truthy, falsy];
 }
 
+function pullAt(arr, indicesToRemove) {
+    const removed = at(arr, indicesToRemove);
+    const indices = new Set(indicesToRemove.slice().sort((x, y) => y - x));
+    for (const index of indices) {
+        arr.splice(index, 1);
+    }
+    return removed;
+}
+
 function sortBy(arr, criteria) {
-    return arr.slice().sort((a, b) => {
-        for (let i = 0; i < criteria.length; i++) {
-            const iteratee = criteria[i];
-            const iterateeIsFunction = typeof iteratee === 'function';
-            const valueA = iterateeIsFunction ? iteratee(a) : a[iteratee];
-            const valueB = iterateeIsFunction ? iteratee(b) : b[iteratee];
-            const result = compareValues(valueA, valueB, 'asc');
-            if (result !== 0) {
-                return result;
-            }
-        }
-        return 0;
-    });
+    return orderBy(arr, criteria, ['asc']);
 }
 
 function sample(arr) {
@@ -430,15 +454,7 @@ function isSubset(superset, subset) {
 }
 
 function tail(arr) {
-    const len = arr.length;
-    if (len <= 1) {
-        return [];
-    }
-    const result = new Array(len - 1);
-    for (let i = 1; i < len; i++) {
-        result[i - 1] = arr[i];
-    }
-    return result;
+    return arr.slice(1);
 }
 
 function toFilled(arr, value, start = 0, end = arr.length) {
@@ -457,15 +473,12 @@ function last(arr) {
 }
 
 function initial(arr) {
-    if (arr.length <= 1) {
-        return [];
-    }
     return arr.slice(0, -1);
 }
 
+exports.at = at;
 exports.chunk = chunk;
 exports.compact = compact;
-exports.compareValues = compareValues;
 exports.countBy = countBy;
 exports.difference = difference;
 exports.differenceBy = differenceBy;
@@ -489,7 +502,9 @@ exports.keyBy = keyBy;
 exports.last = last;
 exports.maxBy = maxBy;
 exports.minBy = minBy;
+exports.orderBy = orderBy;
 exports.partition = partition;
+exports.pullAt = pullAt;
 exports.sample = sample;
 exports.sampleSize = sampleSize;
 exports.shuffle = shuffle;

package/dist/array/at.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Retrieves elements from an array at the specified indices.
+ *
+ * This function supports negative indices, which count from the end of the array.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to retrieve elements from.
+ * @param {number[]} indices - An array of indices specifying the positions of elements to retrieve.
+ * @returns {Array<T | undefined>} A new array containing the elements at the specified indices.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const result = at(numbers, [1, 3, 4]);
+ * console.log(result); // [20, 40, 50]
+ */
+declare function at<T>(arr: readonly T[], indices: number[]): Array<T | undefined>;
+
+export { at };

package/dist/array/at.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Retrieves elements from an array at the specified indices.
+ *
+ * This function supports negative indices, which count from the end of the array.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to retrieve elements from.
+ * @param {number[]} indices - An array of indices specifying the positions of elements to retrieve.
+ * @returns {Array<T | undefined>} A new array containing the elements at the specified indices.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const result = at(numbers, [1, 3, 4]);
+ * console.log(result); // [20, 40, 50]
+ */
+declare function at<T>(arr: readonly T[], indices: number[]): Array<T | undefined>;
+
+export { at };

package/dist/array/at.mjs

@@ -0,0 +1,10 @@
+function at(arr, indices) {
+    const result = [];
+    for (let i = 0; i < indices.length; i++) {
+        const index = indices[i];
+        result.push(arr.at(index));
+    }
+    return result;
+}
+
+export { at };

package/dist/array/countBy.d.mts

@@ -3,18 +3,18 @@
  * based on a transformation function.
  *
  * This function takes an array and a transformation function
- * that converts each item in the array to a string. It then
+ * that converts each item in the array to a key. It then
  * counts the occurrences of each transformed item and returns
  * an object with the transformed items as keys and the counts
  * as values.
  *
  * @template T - The type of the items in the input array.
- *
+ * @template K - The type of keys.
  * @param {T[]} arr - The input array to count occurrences.
- * @param {(item: T) => string} mapper - The transformation function that maps each item to a string key.
- * @returns {Record<string, number>} An object containing the transformed items as keys and the
+ * @param {(item: T) => K} mapper - The transformation function that maps each item to a key.
+ * @returns {Record<K, number>} An object containing the transformed items as keys and the
  * counts as values.
  */
-declare function countBy<T>(arr: T[], mapper: (item: T) => string): Record<string, number>;
+declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T) => K): Record<K, number>;
 
 export { countBy };

package/dist/array/countBy.d.ts

@@ -3,18 +3,18 @@
  * based on a transformation function.
  *
  * This function takes an array and a transformation function
- * that converts each item in the array to a string. It then
+ * that converts each item in the array to a key. It then
  * counts the occurrences of each transformed item and returns
  * an object with the transformed items as keys and the counts
  * as values.
  *
  * @template T - The type of the items in the input array.
- *
+ * @template K - The type of keys.
  * @param {T[]} arr - The input array to count occurrences.
- * @param {(item: T) => string} mapper - The transformation function that maps each item to a string key.
- * @returns {Record<string, number>} An object containing the transformed items as keys and the
+ * @param {(item: T) => K} mapper - The transformation function that maps each item to a key.
+ * @returns {Record<K, number>} An object containing the transformed items as keys and the
  * counts as values.
  */
-declare function countBy<T>(arr: T[], mapper: (item: T) => string): Record<string, number>;
+declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T) => K): Record<K, number>;
 
 export { countBy };

package/dist/array/index.d.mts

@@ -1,3 +1,4 @@
+export { at } from './at.mjs';
 export { chunk } from './chunk.mjs';
 export { compact } from './compact.mjs';
 export { countBy } from './countBy.mjs';
@@ -22,6 +23,7 @@ export { maxBy } from './maxBy.mjs';
 export { minBy } from './minBy.mjs';
 export { orderBy } from './orderBy.mjs';
 export { partition } from './partition.mjs';
+export { pullAt } from './pullAt.mjs';
 export { sortBy } from './sortBy.mjs';
 export { sample } from './sample.mjs';
 export { sampleSize } from './sampleSize.mjs';

package/dist/array/index.d.ts

@@ -1,3 +1,4 @@
+export { at } from './at.js';
 export { chunk } from './chunk.js';
 export { compact } from './compact.js';
 export { countBy } from './countBy.js';
@@ -22,6 +23,7 @@ export { maxBy } from './maxBy.js';
 export { minBy } from './minBy.js';
 export { orderBy } from './orderBy.js';
 export { partition } from './partition.js';
+export { pullAt } from './pullAt.js';
 export { sortBy } from './sortBy.js';
 export { sample } from './sample.js';
 export { sampleSize } from './sampleSize.js';

package/dist/array/index.js

@@ -2,27 +2,13 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const initial = require('../_chunk/initial-y0QrPY.js');
+const initial = require('../_chunk/initial-Ci2bn_.js');
 
 function flattenDeep(arr) {
     return initial.flatten(arr, Infinity);
 }
 
-function orderBy(collection, keys, orders) {
-    const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
-    return collection.slice().sort((a, b) => {
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const order = effectiveOrders[i];
-            const result = initial.compareValues(a[key], b[key], order);
-            if (result !== 0) {
-                return result;
-            }
-        }
-        return 0;
-    });
-}
-
+exports.at = initial.at;
 exports.chunk = initial.chunk;
 exports.compact = initial.compact;
 exports.countBy = initial.countBy;
@@ -48,7 +34,9 @@ exports.keyBy = initial.keyBy;
 exports.last = initial.last;
 exports.maxBy = initial.maxBy;
 exports.minBy = initial.minBy;
+exports.orderBy = initial.orderBy;
 exports.partition = initial.partition;
+exports.pullAt = initial.pullAt;
 exports.sample = initial.sample;
 exports.sampleSize = initial.sampleSize;
 exports.shuffle = initial.shuffle;
@@ -75,4 +63,3 @@ exports.zip = initial.zip;
 exports.zipObject = initial.zipObject;
 exports.zipWith = initial.zipWith;
 exports.flattenDeep = flattenDeep;
-exports.orderBy = orderBy;

package/dist/array/index.mjs

@@ -1,3 +1,4 @@
+export { at } from './at.mjs';
 export { chunk } from './chunk.mjs';
 export { compact } from './compact.mjs';
 export { countBy } from './countBy.mjs';
@@ -22,6 +23,7 @@ export { maxBy } from './maxBy.mjs';
 export { minBy } from './minBy.mjs';
 export { orderBy } from './orderBy.mjs';
 export { partition } from './partition.mjs';
+export { pullAt } from './pullAt.mjs';
 export { sortBy } from './sortBy.mjs';
 export { sample } from './sample.mjs';
 export { sampleSize } from './sampleSize.mjs';

package/dist/array/initial.d.mts

@@ -21,6 +21,6 @@
  * const newSingleElementArr = initial(singleElementArr);
  * // newSingleElementArr will be []
  */
-declare function initial<T>(arr: T[]): T[];
+declare function initial<T>(arr: readonly T[]): T[];
 
 export { initial };

package/dist/array/initial.d.ts

@@ -21,6 +21,6 @@
  * const newSingleElementArr = initial(singleElementArr);
  * // newSingleElementArr will be []
  */
-declare function initial<T>(arr: T[]): T[];
+declare function initial<T>(arr: readonly T[]): T[];
 
 export { initial };

package/dist/array/initial.mjs

@@ -1,7 +1,4 @@
 function initial(arr) {
-    if (arr.length <= 1) {
-        return [];
-    }
     return arr.slice(0, -1);
 }
 

package/dist/array/maxBy.d.mts

@@ -5,11 +5,12 @@
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
- * @returns {T} The element with the maximum value as determined by the `getValue` function.
+ * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function.
  * @example
  * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
  * maxBy([], x => x.a); // Returns: undefined
  */
-declare function maxBy<T>(items: T[], getValue: (element: T) => number): T;
+declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function maxBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
 
 export { maxBy };

package/dist/array/maxBy.d.ts

@@ -5,11 +5,12 @@
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
- * @returns {T} The element with the maximum value as determined by the `getValue` function.
+ * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function.
  * @example
  * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
  * maxBy([], x => x.a); // Returns: undefined
  */
-declare function maxBy<T>(items: T[], getValue: (element: T) => number): T;
+declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function maxBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
 
 export { maxBy };

package/dist/array/minBy.d.mts

@@ -5,11 +5,12 @@
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
- * @returns {T} The element with the minimum value as determined by the `getValue` function.
+ * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function.
  * @example
  * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
  * minBy([], x => x.a); // Returns: undefined
  */
-declare function minBy<T>(items: T[], getValue: (element: T) => number): T;
+declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function minBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
 
 export { minBy };

package/dist/array/minBy.d.ts

@@ -5,11 +5,12 @@
  * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
- * @returns {T} The element with the minimum value as determined by the `getValue` function.
+ * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function.
  * @example
  * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
  * minBy([], x => x.a); // Returns: undefined
  */
-declare function minBy<T>(items: T[], getValue: (element: T) => number): T;
+declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+declare function minBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
 
 export { minBy };

package/dist/array/orderBy.d.mts

@@ -1,16 +1,17 @@
-type Order = 'asc' | 'desc';
 /**
- * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ * Sorts an array of objects based on the given `criteria` and their corresponding order directions.
  *
- * This function takes an array of objects, an array of keys to sort by, and an array of order directions.
- * It returns the sorted array, ordering by each key according to its corresponding direction
- * ('asc' for ascending or 'desc' for descending). If values for a key are equal,
- * it moves to the next key to determine the order.
+ * - If you provide keys, it sorts the objects by the values of those keys.
+ * - If you provide functions, it sorts based on the values returned by those functions.
+ *
+ * The function returns the array of objects sorted in corresponding order directions.
+ * If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
+ * If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} collection - The array of objects to be sorted.
- * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.
- * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
+ * @param {T[]} arr - The array of objects to be sorted.
+ * @param {Array<((item: T) => unknown) | keyof T>} criteria  - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
+ * @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
  * @returns {T[]} - The sorted array.
  *
  * @example
@@ -21,7 +22,8 @@ type Order = 'asc' | 'desc';
  *   { user: 'fred', age: 40 },
  *   { user: 'barney', age: 36 },
  * ];
- * const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ *
+ * const result = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']);
  * // result will be:
  * // [
  * //   { user: 'barney', age: 36 },
@@ -30,6 +32,6 @@ type Order = 'asc' | 'desc';
  * //   { user: 'fred', age: 40 },
  * // ]
  */
-declare function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[];
+declare function orderBy<T extends object>(arr: T[], criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): T[];
 
 export { orderBy };

package/dist/array/orderBy.d.ts

@@ -1,16 +1,17 @@
-type Order = 'asc' | 'desc';
 /**
- * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ * Sorts an array of objects based on the given `criteria` and their corresponding order directions.
  *
- * This function takes an array of objects, an array of keys to sort by, and an array of order directions.
- * It returns the sorted array, ordering by each key according to its corresponding direction
- * ('asc' for ascending or 'desc' for descending). If values for a key are equal,
- * it moves to the next key to determine the order.
+ * - If you provide keys, it sorts the objects by the values of those keys.
+ * - If you provide functions, it sorts based on the values returned by those functions.
+ *
+ * The function returns the array of objects sorted in corresponding order directions.
+ * If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
+ * If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} collection - The array of objects to be sorted.
- * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.
- * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
+ * @param {T[]} arr - The array of objects to be sorted.
+ * @param {Array<((item: T) => unknown) | keyof T>} criteria  - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
+ * @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
  * @returns {T[]} - The sorted array.
  *
  * @example
@@ -21,7 +22,8 @@ type Order = 'asc' | 'desc';
  *   { user: 'fred', age: 40 },
  *   { user: 'barney', age: 36 },
  * ];
- * const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ *
+ * const result = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']);
  * // result will be:
  * // [
  * //   { user: 'barney', age: 36 },
@@ -30,6 +32,6 @@ type Order = 'asc' | 'desc';
  * //   { user: 'fred', age: 40 },
  * // ]
  */
-declare function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[];
+declare function orderBy<T extends object>(arr: T[], criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): T[];
 
 export { orderBy };

package/dist/array/orderBy.mjs

@@ -1,12 +1,15 @@
 import { compareValues } from '../_internal/compareValues.mjs';
 
-function orderBy(collection, keys, orders) {
-    const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
-    return collection.slice().sort((a, b) => {
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const order = effectiveOrders[i];
-            const result = compareValues(a[key], b[key], order);
+function orderBy(arr, criteria, orders) {
+    return arr.slice().sort((a, b) => {
+        const ordersLength = orders.length;
+        for (let i = 0; i < criteria.length; i++) {
+            const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
+            const criterion = criteria[i];
+            const criterionIsFunction = typeof criterion === 'function';
+            const valueA = criterionIsFunction ? criterion(a) : a[criterion];
+            const valueB = criterionIsFunction ? criterion(b) : b[criterion];
+            const result = compareValues(valueA, valueB, order);
             if (result !== 0) {
                 return result;
             }

package/dist/array/pullAt.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Removes elements from an array at specified indices and returns the removed elements.
+ *
+ * This function supports negative indices, which count from the end of the array.
+ *
+ * @template T
+ * @param {T[]} arr - The array from which elements will be removed.
+ * @param {number[]} indicesToRemove - An array of indices specifying the positions of elements to remove.
+ * @returns {Array<T | undefined>} An array containing the elements that were removed from the original array.
+ *
+ * @example
+ * import { pullAt } from './pullAt';
+ *
+ * const numbers = [10, 20, 30, 40, 50];
+ * const removed = pullAt(numbers, [1, 3, 4]);
+ * console.log(removed); // [20, 40, 50]
+ * console.log(numbers); // [10, 30]
+ */
+declare function pullAt<T>(arr: T[], indicesToRemove: number[]): Array<T | undefined>;
+
+export { pullAt };

package/dist/array/pullAt.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Removes elements from an array at specified indices and returns the removed elements.
+ *
+ * This function supports negative indices, which count from the end of the array.
+ *
+ * @template T
+ * @param {T[]} arr - The array from which elements will be removed.
+ * @param {number[]} indicesToRemove - An array of indices specifying the positions of elements to remove.
+ * @returns {Array<T | undefined>} An array containing the elements that were removed from the original array.
+ *
+ * @example
+ * import { pullAt } from './pullAt';
+ *
+ * const numbers = [10, 20, 30, 40, 50];
+ * const removed = pullAt(numbers, [1, 3, 4]);
+ * console.log(removed); // [20, 40, 50]
+ * console.log(numbers); // [10, 30]
+ */
+declare function pullAt<T>(arr: T[], indicesToRemove: number[]): Array<T | undefined>;
+
+export { pullAt };

package/dist/array/pullAt.mjs

@@ -0,0 +1,12 @@
+import { at } from './at.mjs';
+
+function pullAt(arr, indicesToRemove) {
+    const removed = at(arr, indicesToRemove);
+    const indices = new Set(indicesToRemove.slice().sort((x, y) => y - x));
+    for (const index of indices) {
+        arr.splice(index, 1);
+    }
+    return removed;
+}
+
+export { pullAt };

package/dist/array/sampleSize.d.mts

@@ -3,7 +3,7 @@
  *
  * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
  *
- * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algoritm}
+ * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm}
  *
  * @template T - The type of elements in the array.
  * @param {T[]} array - The array to sample from.

package/dist/array/sampleSize.d.ts

@@ -3,7 +3,7 @@
  *
  * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
  *
- * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algoritm}
+ * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm}
  *
  * @template T - The type of elements in the array.
  * @param {T[]} array - The array to sample from.