es-toolkit 1.31.0-dev.999 → 1.32.0-dev.1003

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

@@ -0,0 +1,16 @@
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndex };

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

@@ -0,0 +1,16 @@
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndex };

package/dist/compat/array/sortedIndex.mjs

@@ -0,0 +1,30 @@
+import { sortedIndexBy } from './sortedIndexBy.mjs';
+import { isNil } from '../../predicate/isNil.mjs';
+import { isNull } from '../../predicate/isNull.mjs';
+import { isSymbol } from '../../predicate/isSymbol.mjs';
+import { isNumber } from '../predicate/isNumber.mjs';
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+function sortedIndex(array, value) {
+    if (isNil(array)) {
+        return 0;
+    }
+    let low = 0, high = isNil(array) ? low : array.length;
+    if (isNumber(value) && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            const compute = array[mid];
+            if (!isNull(compute) && !isSymbol(compute) && compute < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return high;
+    }
+    return sortedIndexBy(array, value, value => value);
+}
+
+export { sortedIndex };

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

@@ -0,0 +1,19 @@
+type Iteratee<T, R> = (value: T) => R;
+/**
+ * This method is like `sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @param {(value: T) => R} iteratee The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * const objects = [{ 'n': 4 }, { 'n': 5 }]
+ * sortedIndexBy(objects, { 'n': 4 }, ({ n }) => n)
+ * // => 0
+ */
+declare function sortedIndexBy<T, R>(array: ArrayLike<T> | null | undefined, value: T, iteratee?: Iteratee<T, R>, retHighest?: boolean): number;
+
+export { sortedIndexBy };

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

@@ -0,0 +1,19 @@
+type Iteratee<T, R> = (value: T) => R;
+/**
+ * This method is like `sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @param {(value: T) => R} iteratee The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * const objects = [{ 'n': 4 }, { 'n': 5 }]
+ * sortedIndexBy(objects, { 'n': 4 }, ({ n }) => n)
+ * // => 0
+ */
+declare function sortedIndexBy<T, R>(array: ArrayLike<T> | null | undefined, value: T, iteratee?: Iteratee<T, R>, retHighest?: boolean): number;
+
+export { sortedIndexBy };

package/dist/compat/array/sortedIndexBy.mjs

@@ -0,0 +1,56 @@
+import { isNull } from '../../predicate/isNull.mjs';
+import { isUndefined } from '../../predicate/isUndefined.mjs';
+import { isNaN } from '../predicate/isNaN.mjs';
+import { isNil } from '../predicate/isNil.mjs';
+import { isSymbol } from '../predicate/isSymbol.mjs';
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
+function sortedIndexBy(array, value, iteratee, retHighest) {
+    let low = 0;
+    let high = array == null ? 0 : array.length;
+    if (high === 0 || isNil(array)) {
+        return 0;
+    }
+    const transformedValue = iteratee?.(value);
+    const valIsNaN = isNaN(transformedValue);
+    const valIsNull = isNull(transformedValue);
+    const valIsSymbol = isSymbol(transformedValue);
+    const valIsUndefined = isUndefined(transformedValue);
+    while (low < high) {
+        let setLow;
+        const mid = Math.floor((low + high) / 2);
+        const computed = iteratee?.(array[mid]);
+        const othIsDefined = !isUndefined(computed);
+        const othIsNull = isNull(computed);
+        const othIsReflexive = !isNaN(computed);
+        const othIsSymbol = isSymbol(computed);
+        if (valIsNaN) {
+            setLow = retHighest || othIsReflexive;
+        }
+        else if (valIsUndefined) {
+            setLow = othIsReflexive && (retHighest || othIsDefined);
+        }
+        else if (valIsNull) {
+            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+        }
+        else if (valIsSymbol) {
+            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+        }
+        else if (othIsNull || othIsSymbol) {
+            setLow = false;
+        }
+        else {
+            setLow = retHighest ? computed <= transformedValue : computed < transformedValue;
+        }
+        if (setLow) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return Math.min(high, MAX_ARRAY_INDEX);
+}
+
+export { sortedIndexBy };

package/dist/compat/index.d.mts

@@ -61,6 +61,8 @@ export { isNull } from '../predicate/isNull.mjs';
 export { isPrimitive } from '../predicate/isPrimitive.mjs';
 export { isPromise } from '../predicate/isPromise.mjs';
 export { isUndefined } from '../predicate/isUndefined.mjs';
+export { Mutex } from '../promise/mutex.mjs';
+export { Semaphore } from '../promise/semaphore.mjs';
 export { timeout } from '../promise/timeout.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { capitalize } from '../string/capitalize.mjs';
@@ -108,6 +110,8 @@ export { size } from './array/size.mjs';
 export { slice } from './array/slice.mjs';
 export { some } from './array/some.mjs';
 export { sortBy } from './array/sortBy.mjs';
+export { sortedIndex } from './array/sortedIndex.mjs';
+export { sortedIndexBy } from './array/sortedIndexBy.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';

package/dist/compat/index.d.ts

@@ -61,6 +61,8 @@ export { isNull } from '../predicate/isNull.js';
 export { isPrimitive } from '../predicate/isPrimitive.js';
 export { isPromise } from '../predicate/isPromise.js';
 export { isUndefined } from '../predicate/isUndefined.js';
+export { Mutex } from '../promise/mutex.js';
+export { Semaphore } from '../promise/semaphore.js';
 export { timeout } from '../promise/timeout.js';
 export { withTimeout } from '../promise/withTimeout.js';
 export { capitalize } from '../string/capitalize.js';
@@ -108,6 +110,8 @@ export { size } from './array/size.js';
 export { slice } from './array/slice.js';
 export { some } from './array/some.js';
 export { sortBy } from './array/sortBy.js';
+export { sortedIndex } from './array/sortedIndex.js';
+export { sortedIndexBy } from './array/sortedIndexBy.js';
 export { tail } from './array/tail.js';
 export { take } from './array/take.js';
 export { takeRight } from './array/takeRight.js';

package/dist/compat/index.js

@@ -11,7 +11,7 @@ const range$1 = require('../_chunk/range-HnEIT7.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 const toMerged = require('../_chunk/toMerged-BQTfB8.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-Xaozpc.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-BW79-8.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-DoHqUM.js');
 const promise_index = require('../promise/index.js');
 const upperFirst$1 = require('../_chunk/upperFirst-CorAVn.js');
 const util_index = require('../util/index.js');
@@ -1297,6 +1297,90 @@ function sortBy(collection, ...criteria) {
     return orderBy(collection, zipWith.flatten(criteria), ['asc']);
 }
 
+function isNaN(value) {
+    return Number.isNaN(value);
+}
+
+function isNil(x) {
+    return x == null;
+}
+
+const MAX_ARRAY_LENGTH$2 = 4294967295;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH$2 - 1;
+function sortedIndexBy(array, value, iteratee, retHighest) {
+    let low = 0;
+    let high = array == null ? 0 : array.length;
+    if (high === 0 || isNil(array)) {
+        return 0;
+    }
+    const transformedValue = iteratee?.(value);
+    const valIsNaN = isNaN(transformedValue);
+    const valIsNull = isWeakSet$1.isNull(transformedValue);
+    const valIsSymbol = isSymbol(transformedValue);
+    const valIsUndefined = isWeakSet$1.isUndefined(transformedValue);
+    while (low < high) {
+        let setLow;
+        const mid = Math.floor((low + high) / 2);
+        const computed = iteratee?.(array[mid]);
+        const othIsDefined = !isWeakSet$1.isUndefined(computed);
+        const othIsNull = isWeakSet$1.isNull(computed);
+        const othIsReflexive = !isNaN(computed);
+        const othIsSymbol = isSymbol(computed);
+        if (valIsNaN) {
+            setLow = retHighest || othIsReflexive;
+        }
+        else if (valIsUndefined) {
+            setLow = othIsReflexive && (retHighest || othIsDefined);
+        }
+        else if (valIsNull) {
+            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+        }
+        else if (valIsSymbol) {
+            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+        }
+        else if (othIsNull || othIsSymbol) {
+            setLow = false;
+        }
+        else {
+            setLow = retHighest ? computed <= transformedValue : computed < transformedValue;
+        }
+        if (setLow) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return Math.min(high, MAX_ARRAY_INDEX);
+}
+
+function isNumber(value) {
+    return typeof value === 'number' || value instanceof Number;
+}
+
+const MAX_ARRAY_LENGTH$1 = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH$1 >>> 1;
+function sortedIndex(array, value) {
+    if (isWeakSet$1.isNil(array)) {
+        return 0;
+    }
+    let low = 0, high = isWeakSet$1.isNil(array) ? low : array.length;
+    if (isNumber(value) && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            const compute = array[mid];
+            if (!isWeakSet$1.isNull(compute) && !isWeakSet$1.isSymbol(compute) && compute < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return high;
+    }
+    return sortedIndexBy(array, value, value => value);
+}
+
 function tail(arr) {
     if (!isArrayLike(arr)) {
         return [];
@@ -2452,10 +2536,6 @@ function omit(obj, ...keysArr) {
     return result;
 }
 
-function isNil(x) {
-    return x == null;
-}
-
 function pick(obj, ...keysArr) {
     if (isNil(obj)) {
         return {};
@@ -2611,14 +2691,6 @@ function isMap(value) {
     return isWeakSet$1.isMap(value);
 }
 
-function isNaN(value) {
-    return Number.isNaN(value);
-}
-
-function isNumber(value) {
-    return typeof value === 'number' || value instanceof Number;
-}
-
 function isRegExp(value) {
     return isWeakSet$1.isRegExp(value);
 }
@@ -3141,6 +3213,8 @@ exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
 exports.isPromise = isWeakSet$1.isPromise;
 exports.isUndefined = isWeakSet$1.isUndefined;
+exports.Mutex = promise_index.Mutex;
+exports.Semaphore = promise_index.Semaphore;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
 exports.capitalize = upperFirst$1.capitalize;
@@ -3300,6 +3374,8 @@ exports.slice = slice;
 exports.snakeCase = snakeCase;
 exports.some = some;
 exports.sortBy = sortBy;
+exports.sortedIndex = sortedIndex;
+exports.sortedIndexBy = sortedIndexBy;
 exports.spread = spread;
 exports.startCase = startCase;
 exports.startsWith = startsWith;

package/dist/compat/index.mjs

@@ -62,6 +62,8 @@ export { isNotNil } from '../predicate/isNotNil.mjs';
 export { isNull } from '../predicate/isNull.mjs';
 export { isPromise } from '../predicate/isPromise.mjs';
 export { isUndefined } from '../predicate/isUndefined.mjs';
+export { Mutex } from '../promise/mutex.mjs';
+export { Semaphore } from '../promise/semaphore.mjs';
 export { timeout } from '../promise/timeout.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { capitalize } from '../string/capitalize.mjs';
@@ -110,6 +112,8 @@ export { size } from './array/size.mjs';
 export { slice } from './array/slice.mjs';
 export { some } from './array/some.mjs';
 export { sortBy } from './array/sortBy.mjs';
+export { sortedIndex } from './array/sortedIndex.mjs';
+export { sortedIndexBy } from './array/sortedIndexBy.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';

package/dist/index.d.mts

@@ -137,6 +137,8 @@ export { isUndefined } from './predicate/isUndefined.mjs';
 export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';
 export { delay } from './promise/delay.mjs';
+export { Mutex } from './promise/mutex.mjs';
+export { Semaphore } from './promise/semaphore.mjs';
 export { timeout } from './promise/timeout.mjs';
 export { withTimeout } from './promise/withTimeout.mjs';
 export { camelCase } from './string/camelCase.mjs';

package/dist/index.d.ts

@@ -137,6 +137,8 @@ export { isUndefined } from './predicate/isUndefined.js';
 export { isWeakMap } from './predicate/isWeakMap.js';
 export { isWeakSet } from './predicate/isWeakSet.js';
 export { delay } from './promise/delay.js';
+export { Mutex } from './promise/mutex.js';
+export { Semaphore } from './promise/semaphore.js';
 export { timeout } from './promise/timeout.js';
 export { withTimeout } from './promise/withTimeout.js';
 export { camelCase } from './string/camelCase.js';

package/dist/index.js

@@ -14,7 +14,7 @@ const randomInt = require('./_chunk/randomInt-CF7bZK.js');
 const math_index = require('./math/index.js');
 const toMerged = require('./_chunk/toMerged-BQTfB8.js');
 const object_index = require('./object/index.js');
-const isWeakSet = require('./_chunk/isWeakSet-BW79-8.js');
+const isWeakSet = require('./_chunk/isWeakSet-DoHqUM.js');
 const predicate_index = require('./predicate/index.js');
 const isPlainObject = require('./_chunk/isPlainObject-Xaozpc.js');
 const delay = require('./_chunk/delay-_VMfFa.js');
@@ -155,17 +155,19 @@ exports.isNull = isWeakSet.isNull;
 exports.isPromise = isWeakSet.isPromise;
 exports.isRegExp = isWeakSet.isRegExp;
 exports.isSet = isWeakSet.isSet;
+exports.isSymbol = isWeakSet.isSymbol;
 exports.isUndefined = isWeakSet.isUndefined;
 exports.isWeakMap = isWeakSet.isWeakMap;
 exports.isWeakSet = isWeakSet.isWeakSet;
 exports.isBoolean = predicate_index.isBoolean;
 exports.isError = predicate_index.isError;
 exports.isString = predicate_index.isString;
-exports.isSymbol = predicate_index.isSymbol;
 exports.isPlainObject = isPlainObject.isPlainObject;
 exports.isPrimitive = isPlainObject.isPrimitive;
 exports.isTypedArray = isPlainObject.isTypedArray;
 exports.delay = delay.delay;
+exports.Mutex = promise_index.Mutex;
+exports.Semaphore = promise_index.Semaphore;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
 exports.camelCase = upperFirst.camelCase;

package/dist/index.mjs

@@ -137,6 +137,8 @@ export { isUndefined } from './predicate/isUndefined.mjs';
 export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';
 export { delay } from './promise/delay.mjs';
+export { Mutex } from './promise/mutex.mjs';
+export { Semaphore } from './promise/semaphore.mjs';
 export { timeout } from './promise/timeout.mjs';
 export { withTimeout } from './promise/withTimeout.mjs';
 export { camelCase } from './string/camelCase.mjs';

package/dist/predicate/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const isWeakSet = require('../_chunk/isWeakSet-BW79-8.js');
+const isWeakSet = require('../_chunk/isWeakSet-DoHqUM.js');
 const isPlainObject = require('../_chunk/isPlainObject-Xaozpc.js');
 
 function isBoolean(x) {
@@ -17,10 +17,6 @@ function isString(value) {
     return typeof value === 'string';
 }
 
-function isSymbol(value) {
-    return typeof value === 'symbol';
-}
-
 exports.isArrayBuffer = isWeakSet.isArrayBuffer;
 exports.isBlob = isWeakSet.isBlob;
 exports.isBuffer = isWeakSet.isBuffer;
@@ -40,6 +36,7 @@ exports.isNull = isWeakSet.isNull;
 exports.isPromise = isWeakSet.isPromise;
 exports.isRegExp = isWeakSet.isRegExp;
 exports.isSet = isWeakSet.isSet;
+exports.isSymbol = isWeakSet.isSymbol;
 exports.isUndefined = isWeakSet.isUndefined;
 exports.isWeakMap = isWeakSet.isWeakMap;
 exports.isWeakSet = isWeakSet.isWeakSet;
@@ -49,4 +46,3 @@ exports.isTypedArray = isPlainObject.isTypedArray;
 exports.isBoolean = isBoolean;
 exports.isError = isError;
 exports.isString = isString;
-exports.isSymbol = isSymbol;

package/dist/promise/index.d.mts

@@ -1,3 +1,5 @@
 export { delay } from './delay.mjs';
+export { Mutex } from './mutex.mjs';
+export { Semaphore } from './semaphore.mjs';
 export { timeout } from './timeout.mjs';
 export { withTimeout } from './withTimeout.mjs';

package/dist/promise/index.d.ts

@@ -1,3 +1,5 @@
 export { delay } from './delay.js';
+export { Mutex } from './mutex.js';
+export { Semaphore } from './semaphore.js';
 export { timeout } from './timeout.js';
 export { withTimeout } from './withTimeout.js';

package/dist/promise/index.js

@@ -5,6 +5,48 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const delay = require('../_chunk/delay-_VMfFa.js');
 const error_index = require('../error/index.js');
 
+class Semaphore {
+    capacity;
+    available;
+    deferredTasks = [];
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.available = capacity;
+    }
+    async acquire() {
+        if (this.available > 0) {
+            this.available--;
+            return;
+        }
+        return new Promise(resolve => {
+            this.deferredTasks.push(resolve);
+        });
+    }
+    release() {
+        const deferredTask = this.deferredTasks.shift();
+        if (deferredTask != null) {
+            deferredTask();
+            return;
+        }
+        if (this.available < this.capacity) {
+            this.available++;
+        }
+    }
+}
+
+class Mutex {
+    semaphore = new Semaphore(1);
+    get isLocked() {
+        return this.semaphore.available === 0;
+    }
+    async acquire() {
+        return this.semaphore.acquire();
+    }
+    release() {
+        this.semaphore.release();
+    }
+}
+
 async function timeout(ms) {
     await delay.delay(ms);
     throw new error_index.TimeoutError();
@@ -15,5 +57,7 @@ async function withTimeout(run, ms) {
 }
 
 exports.delay = delay.delay;
+exports.Mutex = Mutex;
+exports.Semaphore = Semaphore;
 exports.timeout = timeout;
 exports.withTimeout = withTimeout;

package/dist/promise/index.mjs

@@ -1,3 +1,5 @@
 export { delay } from './delay.mjs';
+export { Mutex } from './mutex.mjs';
+export { Semaphore } from './semaphore.mjs';
 export { timeout } from './timeout.mjs';
 export { withTimeout } from './withTimeout.mjs';

package/dist/promise/mutex.d.mts

@@ -0,0 +1,64 @@
+/**
+ * A Mutex (mutual exclusion lock) for async functions.
+ * It allows only one async task to access a critical section at a time.
+ *
+ * @example
+ * const mutex = new Mutex();
+ *
+ * async function criticalSection() {
+ *   await mutex.acquire();
+ *   try {
+ *     // This code section cannot be executed simultaneously
+ *   } finally {
+ *     mutex.release();
+ *   }
+ * }
+ *
+ * criticalSection();
+ * criticalSection(); // This call will wait until the first call releases the mutex.
+ */
+declare class Mutex {
+    private semaphore;
+    /**
+     * Checks if the mutex is currently locked.
+     * @returns {boolean} True if the mutex is locked, false otherwise.
+     *
+     * @example
+     * const mutex = new Mutex();
+     * console.log(mutex.isLocked); // false
+     * await mutex.acquire();
+     * console.log(mutex.isLocked); // true
+     * mutex.release();
+     * console.log(mutex.isLocked); // false
+     */
+    get isLocked(): boolean;
+    /**
+     * Acquires the mutex, blocking if necessary until it is available.
+     * @returns {Promise<void>} A promise that resolves when the mutex is acquired.
+     *
+     * @example
+     * const mutex = new Mutex();
+     * await mutex.acquire();
+     * try {
+     *   // This code section cannot be executed simultaneously
+     * } finally {
+     *   mutex.release();
+     * }
+     */
+    acquire(): Promise<void>;
+    /**
+     * Releases the mutex, allowing another waiting task to proceed.
+     *
+     * @example
+     * const mutex = new Mutex();
+     * await mutex.acquire();
+     * try {
+     *   // This code section cannot be executed simultaneously
+     * } finally {
+     *   mutex.release(); // Allows another waiting task to proceed.
+     * }
+     */
+    release(): void;
+}
+
+export { Mutex };

package/dist/promise/mutex.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A Mutex (mutual exclusion lock) for async functions.
+ * It allows only one async task to access a critical section at a time.
+ *
+ * @example
+ * const mutex = new Mutex();
+ *
+ * async function criticalSection() {
+ *   await mutex.acquire();
+ *   try {
+ *     // This code section cannot be executed simultaneously
+ *   } finally {
+ *     mutex.release();
+ *   }
+ * }
+ *
+ * criticalSection();
+ * criticalSection(); // This call will wait until the first call releases the mutex.
+ */
+declare class Mutex {
+    private semaphore;
+    /**
+     * Checks if the mutex is currently locked.
+     * @returns {boolean} True if the mutex is locked, false otherwise.
+     *
+     * @example
+     * const mutex = new Mutex();
+     * console.log(mutex.isLocked); // false
+     * await mutex.acquire();
+     * console.log(mutex.isLocked); // true
+     * mutex.release();
+     * console.log(mutex.isLocked); // false
+     */
+    get isLocked(): boolean;
+    /**
+     * Acquires the mutex, blocking if necessary until it is available.
+     * @returns {Promise<void>} A promise that resolves when the mutex is acquired.
+     *
+     * @example
+     * const mutex = new Mutex();
+     * await mutex.acquire();
+     * try {
+     *   // This code section cannot be executed simultaneously
+     * } finally {
+     *   mutex.release();
+     * }
+     */
+    acquire(): Promise<void>;
+    /**
+     * Releases the mutex, allowing another waiting task to proceed.
+     *
+     * @example
+     * const mutex = new Mutex();
+     * await mutex.acquire();
+     * try {
+     *   // This code section cannot be executed simultaneously
+     * } finally {
+     *   mutex.release(); // Allows another waiting task to proceed.
+     * }
+     */
+    release(): void;
+}
+
+export { Mutex };