es-toolkit 1.50.0 → 1.51.0-dev.2069

package/CHANGELOG.md

@@ -1,5 +1,87 @@
 # es-toolkit Changelog
 
+## Version v1.51.0
+
+Released on August 17th, 2026.
+
+- Added the `es-toolkit/bigint` entrypoint: `bigint` counterparts of the math
+  functions (`sum`, `sumBy`, `max`, `min`, `maxBy`, `minBy`, `clamp`, `inRange`,
+  `median`, `medianBy`, `percentile`, `range`, `rangeRight`), kept separate so
+  the `number` implementations stay unchanged. ([#1966])
+- Added `dedent`, which removes common leading whitespace from template strings. ([#1679])
+- Added `deepFreeze` for recursively freezing objects. ([#1680])
+- Added `mapValuesAsync` and `mapKeysAsync`. ([#1544])
+- Added `toPascalCaseKeys`, `toKebabCaseKeys`, and `toConstantCaseKeys`,
+  completing the object key casing family. ([#1984])
+- Exported the `ToCamelCaseKeys`, `ToPascalCaseKeys`, `ToSnakeCaseKeys`,
+  `ToKebabCaseKeys`, and `ToConstantCaseKeys` types. ([#1651])
+- Added a `preserveArrays` option to `flattenObject`. ([#974])
+
+- Fixed `retry` to pass the last error to the `delay` callback ([#1759]) and to
+  throw the last attempt's error without applying a final delay ([#1901]).
+- Fixed `mergeWith` and `toMerged` to handle mixed array/object types
+  consistently with `merge`. ([#2026])
+- Fixed `pullAt` to remove the correct elements with negative indices. ([#1613])
+- Fixed `at`, `pullAt`, `orderBy`, and `sortBy` to accept readonly arrays. ([#2016])
+- Moved `limitAsync` from the array to the promise category. ([#2022])
+- Included the NOTICE file in the published npm and JSR packages. ([#2020])
+
+The following bring `es-toolkit/compat` closer to Lodash. Behavior for the affected
+edge cases now matches Lodash, so results may differ if you relied on the previous output.
+
+- Added `entries` and `entriesIn`. ([#1874])
+- Fixed `compat/isMatch` and `compat/isMatchWith` to handle object source
+  patterns against primitive and non-plain-object targets like Lodash. ([#1432])
+- Fixed `compat/set` to block `constructor.prototype` paths, preventing
+  prototype pollution. ([#1904])
+- Fixed `compat/find` to respect array-like `length` ([#1958]) and to convert
+  `fromIndex` to an integer ([#1961]), and `compat/indexOf` to convert
+  `fromIndex` to an integer when searching for `NaN` ([#1951]).
+- Fixed `compat/orderBy` to resolve unresolved deep paths and nullish elements
+  to `undefined` ([#2010]), to exclude the `length` property from array-like
+  values ([#2002]), and to read the criterion property from primitive values ([#1903]).
+- Fixed `compat/toPath` to split unquoted dotted keys inside brackets. ([#1899])
+- Fixed `compat/omit` to treat a key array as a single deep path. ([#1902])
+- Fixed `compat/map` to make the iteratee optional with an identity default. ([#1928])
+- Fixed `compat/size` to count combined Unicode symbols as single characters. ([#1900])
+- Fixed `compat/intersectionBy` to support number, object, and nullish iteratee
+  shorthands ([#1993]), and `compat/intersectionWith` to apply the comparator
+  when deduplicating the first array ([#1953]).
+- Fixed `compat/difference`, `compat/differenceBy`, `compat/uniqBy`, and
+  `compat/unionBy` to normalize `-0` to `0`. ([#2007])
+- Fixed `compat/maxBy` and `compat/minBy` to skip nullish iteratee values ([#1927]),
+  and `compat/meanBy` to skip `undefined` values when averaging ([#1978]).
+- Fixed `compat/some`, `compat/template` ([#2009]), and `compat/fill` ([#1952])
+  to gate guard handling with `isIterateeCall`.
+- Fixed `compat/iteratee` to treat a boolean as a property shorthand. ([#1941])
+- Fixed `compat/reverse` to support array-like objects and `arguments`. ([#2008])
+- Fixed `compat/toArray` to convert non-array-like iterables. ([#1999])
+- Fixed `compat/toString` to render nested nullish values like Lodash. ([#1992])
+- Fixed `compat/zipObject` to treat `null` keys and values as empty arrays. ([#2005])
+- Fixed `compat/sampleSize` to clamp the default size to the collection length. ([#2003])
+- Fixed `compat/takeWhile`, `compat/takeRightWhile`, and `compat/uniqBy` to
+  support string inputs. ([#2004])
+- Fixed `compat/chunk` to return an empty array for an empty collection with an
+  `Infinity` size. ([#1995])
+- Fixed `compat/lastIndexOf` to read holes in sparse arrays as `undefined`. ([#1977])
+- Fixed `compat/last` to return `undefined` for empty array-like inputs. ([#1954])
+- Fixed `compat/pullAll` to return the array as-is when `values` is nullish. ([#1962])
+
+- Added a browser compatibility test suite. ([#2012])
+- Improved documentation, JSDoc accuracy, tests, and internal refactoring across
+  `compat` and the docs site. ([#1622], [#1789], [#1824], [#1844], [#1849],
+  [#1854], [#1855], [#1859], [#1860], [#1868], [#1871], [#1887], [#1898],
+  [#1933], [#1939], [#1947], [#1950], [#1955], [#1956], [#1957], [#1960],
+  [#1963], [#1964], [#1968], [#1969], [#1970], [#1972], [#1979], [#1985],
+  [#2000], [#2001], [#2021], [#2025], [#2027])
+
+We sincerely thank @Antoliny0919, @D-Sketon, @kojesung, @chuenchen309,
+@mariazuheros, @DongEun02, @raon0211, @sukvvon, @racgoo, @dayongkr, @Kropiunig,
+@ssi02014, @sarathfrancis90, @mym0404, @mlnwns, @kdelay, @gwagjiug, @dohwi,
+@blro0319, @benedictleejh, @amir-rezaei, @ianzone, @sen2y, @rossyman,
+@eunwoo-levi, @ramong26, @Gdm0714, and everyone else who contributed.
+We appreciate your great efforts!
+
 ## Version v1.50.0
 
 Released on July 24th, 2026.

package/NOTICE

@@ -0,0 +1,39 @@
+es-toolkit
+
+Parts of the test suite and compatibility layer in es-toolkit/compat are
+derived from Lodash (https://github.com/lodash/lodash).
+
+Lodash copyright notice and MIT permission notice:
+
+Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+
+Based on Underscore.js, copyright Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+This software consists of voluntary contributions made by many
+individuals. For exact contribution history, see the revision history
+available at https://github.com/lodash/lodash
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -9,7 +9,7 @@ es-toolkit is a state-of-the-art, high-performance JavaScript utility library wi
 - es-toolkit offers a variety of everyday utility functions with modern implementations, such as [debounce](https://es-toolkit.dev/reference/function/debounce.html), [delay](https://es-toolkit.dev/reference/promise/delay.html), [chunk](https://es-toolkit.dev/reference/array/chunk.html), [sum](https://es-toolkit.dev/reference/math/sum.html), and [pick](https://es-toolkit.dev/reference/object/pick.html).
 - Designed with performance in mind, es-toolkit achieves [2-3× better performance](https://es-toolkit.dev/performance.html) in modern JavaScript environments.
 - es-toolkit supports tree shaking out of the box, and [reduces JavaScript code by up to 97%](https://es-toolkit.dev/bundle-size.html) compared to other libraries.
-- es-toolkit offers a complete compatibility layer to seamlessly replace lodash, available as [es-toolkit/compat](https://es-toolkit.dev/compatibility.html).
+- es-toolkit offers a complete compatibility layer to seamlessly replace Lodash, available as [es-toolkit/compat](https://es-toolkit.dev/compatibility.html).
 - es-toolkit includes built-in TypeScript support, with straightforward yet robust types. It also provides useful type guards such as [isNotNil](https://es-toolkit.dev/reference/predicate/isNotNil.html).
 - es-toolkit is trusted and used by popular open-source projects like [Storybook](https://github.com/storybookjs/storybook/blob/9d862798d666678cc4822e857c00bbd744169ced/code/core/package.json#L358), [Recharts](https://github.com/recharts/recharts/blob/0fa4cc325da403b6fa1c6be0f820896ed92f806a/package.json#L94), [ink](https://github.com/vadimdemedes/ink/blob/2090ad9779be59dea71d173eb49785b7bd4495d0/package.json#L55), and [CKEditor](https://github.com/ckeditor/ckeditor5/blob/60d5fac804643cb4d359767ee2f94e3d92d1fcc5/packages/ckeditor5-core/package.json#L53).
 - es-toolkit is battle-tested with 100% test coverage, ensuring reliability and robustness.
@@ -53,7 +53,7 @@ For more details, see the [AI Integration guide](https://es-toolkit.dev/ai-integ
 
 ## Contributing
 
-We welcome contribution from everyone in the community. Read below for detailed contribution guide.
+We welcome contributions from everyone in the community. Read below for a detailed contribution guide.
 
 [CONTRIBUTING](https://github.com/toss/es-toolkit/blob/main/.github/CONTRIBUTING.md)
 

package/bigint.d.ts

@@ -0,0 +1 @@
+export * from './dist/bigint';

package/bigint.js

@@ -0,0 +1 @@
+module.exports = require('./dist/bigint');

package/dist/_internal/NonPlainObject.d.mts

@@ -0,0 +1,8 @@
+//#region src/_internal/NonPlainObject.d.ts
+/**
+ * Built-in object types that key-conversion types like `ToCamelCaseKeys`
+ * leave unchanged instead of mapping over their properties.
+ */
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+//#endregion
+export { NonPlainObject };

package/dist/_internal/NonPlainObject.d.ts

@@ -0,0 +1,8 @@
+//#region src/_internal/NonPlainObject.d.ts
+/**
+ * Built-in object types that key-conversion types like `ToCamelCaseKeys`
+ * leave unchanged instead of mapping over their properties.
+ */
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+//#endregion
+export { NonPlainObject };

package/dist/_internal/bigIntRangeLength.js

@@ -0,0 +1,19 @@
+//#region src/_internal/bigIntRangeLength.ts
+/**
+* Calculates how many elements a bigint range from `start` (inclusive) to `end` (exclusive) contains.
+*
+* This mirrors `Math.ceil((end - start) / step)` from the `number` implementations, but performs the
+* ceiling division with bigint arithmetic. Returns `0` when `step` points away from `end`.
+*
+* @param start - The start of the range.
+* @param end - The end of the range.
+* @param step - A non-zero step value.
+* @returns The number of elements in the range.
+*/
+function bigIntRangeLength(start, end, step) {
+	const difference = end - start;
+	if (step > 0n) return difference <= 0n ? 0 : Number((difference + step - 1n) / step);
+	return difference >= 0n ? 0 : Number((difference + step + 1n) / step);
+}
+//#endregion
+exports.bigIntRangeLength = bigIntRangeLength;

package/dist/_internal/bigIntRangeLength.mjs

@@ -0,0 +1,19 @@
+//#region src/_internal/bigIntRangeLength.ts
+/**
+* Calculates how many elements a bigint range from `start` (inclusive) to `end` (exclusive) contains.
+*
+* This mirrors `Math.ceil((end - start) / step)` from the `number` implementations, but performs the
+* ceiling division with bigint arithmetic. Returns `0` when `step` points away from `end`.
+*
+* @param start - The start of the range.
+* @param end - The end of the range.
+* @param step - A non-zero step value.
+* @returns The number of elements in the range.
+*/
+function bigIntRangeLength(start, end, step) {
+	const difference = end - start;
+	if (step > 0n) return difference <= 0n ? 0 : Number((difference + step - 1n) / step);
+	return difference >= 0n ? 0 : Number((difference + step + 1n) / step);
+}
+//#endregion
+export { bigIntRangeLength };

package/dist/_internal/isMergeableValue.js

@@ -0,0 +1,17 @@
+const require_isPlainObject = require("../predicate/isPlainObject.js");
+//#region src/_internal/isMergeableValue.ts
+/**
+* Checks if a value can be deeply merged into, i.e. it is a plain object or an array.
+*
+* This function is used in `merge`, `mergeWith`, and `toMerged` to decide whether
+* the source value should be merged into the existing target value recursively,
+* preserving the target's structure, instead of replacing it.
+*
+* @param value - The value to check.
+* @returns `true` if the value is a plain object or an array, otherwise `false`.
+*/
+function isMergeableValue(value) {
+	return require_isPlainObject.isPlainObject(value) || Array.isArray(value);
+}
+//#endregion
+exports.isMergeableValue = isMergeableValue;

package/dist/_internal/isMergeableValue.mjs

@@ -0,0 +1,17 @@
+import { isPlainObject } from "../predicate/isPlainObject.mjs";
+//#region src/_internal/isMergeableValue.ts
+/**
+* Checks if a value can be deeply merged into, i.e. it is a plain object or an array.
+*
+* This function is used in `merge`, `mergeWith`, and `toMerged` to decide whether
+* the source value should be merged into the existing target value recursively,
+* preserving the target's structure, instead of replacing it.
+*
+* @param value - The value to check.
+* @returns `true` if the value is a plain object or an array, otherwise `false`.
+*/
+function isMergeableValue(value) {
+	return isPlainObject(value) || Array.isArray(value);
+}
+//#endregion
+export { isMergeableValue };

package/dist/_internal/isUnsafeProperty.js

@@ -1,12 +1,15 @@
 //#region src/_internal/isUnsafeProperty.ts
 /**
-* Checks if a property key is unsafe to modify directly.
+* Checks if a property key is unsafe to access or copy directly.
 *
-* This function is used in functions like `merge` to prevent prototype pollution attacks
-* by identifying property keys that could modify the object's prototype chain or constructor.
+* This function is used in functions like `get`, `unset`, and `merge` to prevent
+* prototype pollution attacks by identifying `__proto__`, which modifies the object's
+* prototype chain. `constructor` and `prototype` stay accessible here because lodash
+* keeps reads of them unrestricted; write paths use `isUnsafeToWriteProperty` instead,
+* which also blocks those keys.
 *
 * @param key - The property key to check
-* @returns `true` if the property is unsafe to modify directly, `false` otherwise
+* @returns `true` if the property is unsafe to access directly, `false` otherwise
 * @internal
 */
 function isUnsafeProperty(key) {

package/dist/_internal/isUnsafeProperty.mjs

@@ -1,12 +1,15 @@
 //#region src/_internal/isUnsafeProperty.ts
 /**
-* Checks if a property key is unsafe to modify directly.
+* Checks if a property key is unsafe to access or copy directly.
 *
-* This function is used in functions like `merge` to prevent prototype pollution attacks
-* by identifying property keys that could modify the object's prototype chain or constructor.
+* This function is used in functions like `get`, `unset`, and `merge` to prevent
+* prototype pollution attacks by identifying `__proto__`, which modifies the object's
+* prototype chain. `constructor` and `prototype` stay accessible here because lodash
+* keeps reads of them unrestricted; write paths use `isUnsafeToWriteProperty` instead,
+* which also blocks those keys.
 *
 * @param key - The property key to check
-* @returns `true` if the property is unsafe to modify directly, `false` otherwise
+* @returns `true` if the property is unsafe to access directly, `false` otherwise
 * @internal
 */
 function isUnsafeProperty(key) {

package/dist/_internal/isUnsafeToWriteProperty.js

@@ -0,0 +1,22 @@
+//#region src/_internal/isUnsafeToWriteProperty.ts
+/**
+* Checks if a property key is unsafe to write to.
+*
+* Writing through `__proto__`, `constructor`, or `prototype` can reach
+* `Object.prototype` and pollute every object, so write paths like `set`,
+* `update`, and `zipObjectDeep` abort when a path segment matches one of
+* these keys, matching lodash's behavior.
+*
+* Read paths like `get` and `unset` use `isUnsafeProperty` instead, which
+* only blocks `__proto__`; lodash keeps reads of `constructor` and
+* `prototype` unrestricted.
+*
+* @param key - The property key to check
+* @returns `true` if the property is unsafe to write to, `false` otherwise
+* @internal
+*/
+function isUnsafeToWriteProperty(key) {
+	return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+//#endregion
+exports.isUnsafeToWriteProperty = isUnsafeToWriteProperty;

package/dist/_internal/isUnsafeToWriteProperty.mjs

@@ -0,0 +1,22 @@
+//#region src/_internal/isUnsafeToWriteProperty.ts
+/**
+* Checks if a property key is unsafe to write to.
+*
+* Writing through `__proto__`, `constructor`, or `prototype` can reach
+* `Object.prototype` and pollute every object, so write paths like `set`,
+* `update`, and `zipObjectDeep` abort when a path segment matches one of
+* these keys, matching lodash's behavior.
+*
+* Read paths like `get` and `unset` use `isUnsafeProperty` instead, which
+* only blocks `__proto__`; lodash keeps reads of `constructor` and
+* `prototype` unrestricted.
+*
+* @param key - The property key to check
+* @returns `true` if the property is unsafe to write to, `false` otherwise
+* @internal
+*/
+function isUnsafeToWriteProperty(key) {
+	return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+//#endregion
+export { isUnsafeToWriteProperty };

package/dist/array/at.d.mts

@@ -14,6 +14,6 @@
  * const result = at(numbers, [1, 3, 4]);
  * console.log(result); // [20, 40, 50]
  */
-declare function at<T>(arr: readonly T[], indices: number[]): T[];
+declare function at<T>(arr: readonly T[], indices: readonly number[]): T[];
 //#endregion
 export { at };

package/dist/array/at.d.ts

@@ -14,6 +14,6 @@
  * const result = at(numbers, [1, 3, 4]);
  * console.log(result); // [20, 40, 50]
  */
-declare function at<T>(arr: readonly T[], indices: number[]): T[];
+declare function at<T>(arr: readonly T[], indices: readonly number[]): T[];
 //#endregion
 export { at };

package/dist/array/filterAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 //#region src/array/filterAsync.ts
 /**
 * Filters an array asynchronously using an async predicate function.

package/dist/array/filterAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 //#region src/array/filterAsync.ts
 /**
 * Filters an array asynchronously using an async predicate function.

package/dist/array/flatMapAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 const require_flatten = require("./flatten.js");
 //#region src/array/flatMapAsync.ts
 /**

package/dist/array/flatMapAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 import { flatten } from "./flatten.mjs";
 //#region src/array/flatMapAsync.ts
 /**

package/dist/array/forEachAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 //#region src/array/forEachAsync.ts
 /**
 * Executes an async callback function for each element in an array.

package/dist/array/forEachAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 //#region src/array/forEachAsync.ts
 /**
 * Executes an async callback function for each element in an array.

package/dist/array/index.js

@@ -14,7 +14,6 @@ const require_dropRight = require("./dropRight.js");
 const require_dropRightWhile = require("./dropRightWhile.js");
 const require_dropWhile = require("./dropWhile.js");
 const require_fill = require("./fill.js");
-const require_limitAsync = require("./limitAsync.js");
 const require_filterAsync = require("./filterAsync.js");
 const require_flatten = require("./flatten.js");
 const require_flatMap = require("./flatMap.js");
@@ -33,6 +32,7 @@ const require_isSubset = require("./isSubset.js");
 const require_isSubsetWith = require("./isSubsetWith.js");
 const require_keyBy = require("./keyBy.js");
 const require_last = require("./last.js");
+const require_limitAsync = require("./limitAsync.js");
 const require_mapAsync = require("./mapAsync.js");
 const require_maxBy = require("./maxBy.js");
 const require_minBy = require("./minBy.js");

package/dist/array/index.mjs

@@ -13,7 +13,6 @@ import { dropRight } from "./dropRight.mjs";
 import { dropRightWhile } from "./dropRightWhile.mjs";
 import { dropWhile } from "./dropWhile.mjs";
 import { fill } from "./fill.mjs";
-import { limitAsync } from "./limitAsync.mjs";
 import { filterAsync } from "./filterAsync.mjs";
 import { flatten } from "./flatten.mjs";
 import { flatMap } from "./flatMap.mjs";
@@ -32,6 +31,7 @@ import { isSubset } from "./isSubset.mjs";
 import { isSubsetWith } from "./isSubsetWith.mjs";
 import { keyBy } from "./keyBy.mjs";
 import { last } from "./last.mjs";
+import { limitAsync } from "./limitAsync.mjs";
 import { mapAsync } from "./mapAsync.mjs";
 import { maxBy } from "./maxBy.mjs";
 import { minBy } from "./minBy.mjs";

package/dist/array/limitAsync.d.mts

@@ -1,35 +1,11 @@
+import { limitAsync as limitAsync$1 } from "../promise/limitAsync.mjs";
+
 //#region src/array/limitAsync.d.ts
 /**
  * Wraps an async function to limit the number of concurrent executions.
  *
- * This function creates a wrapper around an async callback that ensures at most
- * `concurrency` number of executions can run simultaneously. Additional calls will
- * wait until a slot becomes available.
- *
- * @template F - The type of the async function to wrap.
- * @param callback The async function to wrap with concurrency control.
- * @param concurrency Maximum number of concurrent executions allowed.
- * @returns A wrapped version of the callback with concurrency limiting.
- * @example
- * const limitedFetch = limitAsync(async (url) => {
- *   return await fetch(url);
- * }, 3);
- *
- * // Only 3 fetches will run concurrently
- * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
- * await Promise.all(urls.map(url => limitedFetch(url)));
- *
- * @example
- * const processItem = async (item) => {
- *   // Expensive async operation
- *   return await heavyComputation(item);
- * };
- *
- * const limitedProcess = limitAsync(processItem, 2);
- * const items = [1, 2, 3, 4, 5];
- * // At most 2 items will be processed concurrently
- * await Promise.all(items.map(item => limitedProcess(item)));
+ * @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
  */
-declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+declare const limitAsync: typeof limitAsync$1;
 //#endregion
 export { limitAsync };

package/dist/array/limitAsync.d.ts

@@ -1,35 +1,11 @@
+import { limitAsync as limitAsync$1 } from "../promise/limitAsync.js";
+
 //#region src/array/limitAsync.d.ts
 /**
  * Wraps an async function to limit the number of concurrent executions.
  *
- * This function creates a wrapper around an async callback that ensures at most
- * `concurrency` number of executions can run simultaneously. Additional calls will
- * wait until a slot becomes available.
- *
- * @template F - The type of the async function to wrap.
- * @param callback The async function to wrap with concurrency control.
- * @param concurrency Maximum number of concurrent executions allowed.
- * @returns A wrapped version of the callback with concurrency limiting.
- * @example
- * const limitedFetch = limitAsync(async (url) => {
- *   return await fetch(url);
- * }, 3);
- *
- * // Only 3 fetches will run concurrently
- * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
- * await Promise.all(urls.map(url => limitedFetch(url)));
- *
- * @example
- * const processItem = async (item) => {
- *   // Expensive async operation
- *   return await heavyComputation(item);
- * };
- *
- * const limitedProcess = limitAsync(processItem, 2);
- * const items = [1, 2, 3, 4, 5];
- * // At most 2 items will be processed concurrently
- * await Promise.all(items.map(item => limitedProcess(item)));
+ * @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
  */
-declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+declare const limitAsync: typeof limitAsync$1;
 //#endregion
 export { limitAsync };

package/dist/array/limitAsync.js

@@ -1,46 +1,9 @@
-const require_semaphore = require("../promise/semaphore.js");
 //#region src/array/limitAsync.ts
 /**
 * Wraps an async function to limit the number of concurrent executions.
 *
-* This function creates a wrapper around an async callback that ensures at most
-* `concurrency` number of executions can run simultaneously. Additional calls will
-* wait until a slot becomes available.
-*
-* @template F - The type of the async function to wrap.
-* @param callback The async function to wrap with concurrency control.
-* @param concurrency Maximum number of concurrent executions allowed.
-* @returns A wrapped version of the callback with concurrency limiting.
-* @example
-* const limitedFetch = limitAsync(async (url) => {
-*   return await fetch(url);
-* }, 3);
-*
-* // Only 3 fetches will run concurrently
-* const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
-* await Promise.all(urls.map(url => limitedFetch(url)));
-*
-* @example
-* const processItem = async (item) => {
-*   // Expensive async operation
-*   return await heavyComputation(item);
-* };
-*
-* const limitedProcess = limitAsync(processItem, 2);
-* const items = [1, 2, 3, 4, 5];
-* // At most 2 items will be processed concurrently
-* await Promise.all(items.map(item => limitedProcess(item)));
+* @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
 */
-function limitAsync(callback, concurrency) {
-	const semaphore = new require_semaphore.Semaphore(concurrency);
-	return async function(...args) {
-		try {
-			await semaphore.acquire();
-			return await callback.apply(this, args);
-		} finally {
-			semaphore.release();
-		}
-	};
-}
+const limitAsync = require("../promise/limitAsync.js").limitAsync;
 //#endregion
 exports.limitAsync = limitAsync;

package/dist/array/limitAsync.mjs

@@ -1,46 +1,10 @@
-import { Semaphore } from "../promise/semaphore.mjs";
+import { limitAsync as limitAsync$1 } from "../promise/limitAsync.mjs";
 //#region src/array/limitAsync.ts
 /**
 * Wraps an async function to limit the number of concurrent executions.
 *
-* This function creates a wrapper around an async callback that ensures at most
-* `concurrency` number of executions can run simultaneously. Additional calls will
-* wait until a slot becomes available.
-*
-* @template F - The type of the async function to wrap.
-* @param callback The async function to wrap with concurrency control.
-* @param concurrency Maximum number of concurrent executions allowed.
-* @returns A wrapped version of the callback with concurrency limiting.
-* @example
-* const limitedFetch = limitAsync(async (url) => {
-*   return await fetch(url);
-* }, 3);
-*
-* // Only 3 fetches will run concurrently
-* const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
-* await Promise.all(urls.map(url => limitedFetch(url)));
-*
-* @example
-* const processItem = async (item) => {
-*   // Expensive async operation
-*   return await heavyComputation(item);
-* };
-*
-* const limitedProcess = limitAsync(processItem, 2);
-* const items = [1, 2, 3, 4, 5];
-* // At most 2 items will be processed concurrently
-* await Promise.all(items.map(item => limitedProcess(item)));
+* @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
 */
-function limitAsync(callback, concurrency) {
-	const semaphore = new Semaphore(concurrency);
-	return async function(...args) {
-		try {
-			await semaphore.acquire();
-			return await callback.apply(this, args);
-		} finally {
-			semaphore.release();
-		}
-	};
-}
+const limitAsync = limitAsync$1;
 //#endregion
 export { limitAsync };

package/dist/array/mapAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 //#region src/array/mapAsync.ts
 /**
 * Transforms each element in an array using an async callback function and returns

package/dist/array/mapAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 //#region src/array/mapAsync.ts
 /**
 * Transforms each element in an array using an async callback function and returns

package/dist/array/orderBy.d.mts

@@ -33,6 +33,6 @@
  * //   { user: 'fred', age: 40 },
  * // ]
  */
-declare function orderBy<T extends object>(arr: readonly T[], criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): T[];
+declare function orderBy<T extends object>(arr: readonly T[], criteria: ReadonlyArray<((item: T) => unknown) | keyof T>, orders: ReadonlyArray<'asc' | 'desc'>): T[];
 //#endregion
 export { orderBy };