es-toolkit 1.31.0 → 1.32.0-dev.1003

package/dist/index.js

@@ -4,18 +4,21 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const zipWith = require('./_chunk/zipWith-Bdyzuy.js');
 const array_index = require('./array/index.js');
-const promise_index = require('./_chunk/index-BGZDR9.js');
-const unary = require('./_chunk/unary-B6qG7C.js');
+const AbortError = require('./_chunk/AbortError-Cg4ZQ1.js');
+const error_index = require('./error/index.js');
+const unary = require('./_chunk/unary-c1NFA5.js');
 const function_index = require('./function/index.js');
 const noop = require('./_chunk/noop-2IwLUk.js');
 const range = require('./_chunk/range-HnEIT7.js');
 const randomInt = require('./_chunk/randomInt-CF7bZK.js');
 const math_index = require('./math/index.js');
-const toMerged = require('./_chunk/toMerged-DGFrN7.js');
+const toMerged = require('./_chunk/toMerged-BQTfB8.js');
 const object_index = require('./object/index.js');
-const isWeakSet = require('./_chunk/isWeakSet-CvIdTA.js');
+const isWeakSet = require('./_chunk/isWeakSet-DoHqUM.js');
 const predicate_index = require('./predicate/index.js');
-const isPlainObject = require('./_chunk/isPlainObject-octpoD.js');
+const isPlainObject = require('./_chunk/isPlainObject-Xaozpc.js');
+const delay = require('./_chunk/delay-_VMfFa.js');
+const promise_index = require('./promise/index.js');
 const upperFirst = require('./_chunk/upperFirst-CorAVn.js');
 const string_index = require('./string/index.js');
 const util_index = require('./util/index.js');
@@ -82,11 +85,8 @@ exports.zipWith = zipWith.zipWith;
 exports.orderBy = array_index.orderBy;
 exports.sortBy = array_index.sortBy;
 exports.takeRightWhile = array_index.takeRightWhile;
-exports.AbortError = promise_index.AbortError;
-exports.TimeoutError = promise_index.TimeoutError;
-exports.delay = promise_index.delay;
-exports.timeout = promise_index.timeout;
-exports.withTimeout = promise_index.withTimeout;
+exports.AbortError = AbortError.AbortError;
+exports.TimeoutError = error_index.TimeoutError;
 exports.after = unary.after;
 exports.ary = unary.ary;
 exports.asyncNoop = unary.asyncNoop;
@@ -100,6 +100,7 @@ exports.once = unary.once;
 exports.partial = unary.partial;
 exports.partialRight = unary.partialRight;
 exports.rest = unary.rest;
+exports.retry = unary.retry;
 exports.unary = unary.unary;
 exports.before = function_index.before;
 exports.curry = function_index.curry;
@@ -151,18 +152,24 @@ exports.isMap = isWeakSet.isMap;
 exports.isNil = isWeakSet.isNil;
 exports.isNotNil = isWeakSet.isNotNil;
 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;
 exports.capitalize = upperFirst.capitalize;
 exports.constantCase = upperFirst.constantCase;

package/dist/index.mjs

@@ -77,6 +77,7 @@ export { once } from './function/once.mjs';
 export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
+export { retry } from './function/retry.mjs';
 export { spread } from './function/spread.mjs';
 export { throttle } from './function/throttle.mjs';
 export { unary } from './function/unary.mjs';
@@ -126,6 +127,7 @@ export { isNotNil } from './predicate/isNotNil.mjs';
 export { isNull } from './predicate/isNull.mjs';
 export { isPlainObject } from './predicate/isPlainObject.mjs';
 export { isPrimitive } from './predicate/isPrimitive.mjs';
+export { isPromise } from './predicate/isPromise.mjs';
 export { isRegExp } from './predicate/isRegExp.mjs';
 export { isSet } from './predicate/isSet.mjs';
 export { isString } from './predicate/isString.mjs';
@@ -135,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/object/cloneDeepWith.mjs

@@ -1,4 +1,6 @@
 import { getSymbols } from '../compat/_internal/getSymbols.mjs';
+import { getTag } from '../compat/_internal/getTag.mjs';
+import { uint32ArrayTag, uint16ArrayTag, uint8ClampedArrayTag, uint8ArrayTag, symbolTag, stringTag, setTag, regexpTag, objectTag, numberTag, mapTag, int32ArrayTag, int16ArrayTag, int8ArrayTag, float64ArrayTag, float32ArrayTag, dateTag, booleanTag, dataViewTag, arrayBufferTag, arrayTag, argumentsTag } from '../compat/_internal/tags.mjs';
 import { isPrimitive } from '../predicate/isPrimitive.mjs';
 import { isTypedArray } from '../predicate/isTypedArray.mjs';
 
@@ -99,7 +101,7 @@ function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new
         copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
         return result;
     }
-    if (typeof valueToClone === 'object' && valueToClone !== null) {
+    if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) {
         const result = Object.create(Object.getPrototypeOf(valueToClone));
         stack.set(valueToClone, result);
         copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
@@ -117,5 +119,36 @@ function copyProperties(target, source, objectToClone = target, stack, cloneValu
         }
     }
 }
+function isCloneableObject(object) {
+    switch (getTag(object)) {
+        case argumentsTag:
+        case arrayTag:
+        case arrayBufferTag:
+        case dataViewTag:
+        case booleanTag:
+        case dateTag:
+        case float32ArrayTag:
+        case float64ArrayTag:
+        case int8ArrayTag:
+        case int16ArrayTag:
+        case int32ArrayTag:
+        case mapTag:
+        case numberTag:
+        case objectTag:
+        case regexpTag:
+        case setTag:
+        case stringTag:
+        case symbolTag:
+        case uint8ArrayTag:
+        case uint8ClampedArrayTag:
+        case uint16ArrayTag:
+        case uint32ArrayTag: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
 
 export { cloneDeepWith, cloneDeepWithImpl, copyProperties };

package/dist/object/flattenObject.d.mts

@@ -1,7 +1,15 @@
+interface FlattenObjectOptions {
+    /**
+     * The delimiter to use between nested keys.
+     * @default '.''
+     */
+    delimiter?: string;
+}
 /**
- * Flattens a nested object into a single level object with dot-separated keys.
+ * Flattens a nested object into a single level object with delimiter-separated keys.
  *
  * @param {object} object - The object to flatten.
+ * @param {string} [options.delimiter='.'] - The delimiter to use between nested keys.
  * @returns {Record<string, any>} - The flattened object.
  *
  * @example
@@ -23,6 +31,6 @@
  * //   'd.1': 3
  * // }
  */
-declare function flattenObject(object: object): Record<string, any>;
+declare function flattenObject(object: object, { delimiter }?: FlattenObjectOptions): Record<string, any>;
 
 export { flattenObject };

package/dist/object/flattenObject.d.ts

@@ -1,7 +1,15 @@
+interface FlattenObjectOptions {
+    /**
+     * The delimiter to use between nested keys.
+     * @default '.''
+     */
+    delimiter?: string;
+}
 /**
- * Flattens a nested object into a single level object with dot-separated keys.
+ * Flattens a nested object into a single level object with delimiter-separated keys.
  *
  * @param {object} object - The object to flatten.
+ * @param {string} [options.delimiter='.'] - The delimiter to use between nested keys.
  * @returns {Record<string, any>} - The flattened object.
  *
  * @example
@@ -23,6 +31,6 @@
  * //   'd.1': 3
  * // }
  */
-declare function flattenObject(object: object): Record<string, any>;
+declare function flattenObject(object: object, { delimiter }?: FlattenObjectOptions): Record<string, any>;
 
 export { flattenObject };

package/dist/object/flattenObject.mjs

@@ -1,21 +1,21 @@
 import { isPlainObject } from '../predicate/isPlainObject.mjs';
 
-function flattenObject(object) {
-    return flattenObjectImpl(object);
+function flattenObject(object, { delimiter = '.' } = {}) {
+    return flattenObjectImpl(object, '', delimiter);
 }
-function flattenObjectImpl(object, prefix = '') {
+function flattenObjectImpl(object, prefix = '', delimiter = '.') {
     const result = {};
     const keys = Object.keys(object);
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
         const value = object[key];
-        const prefixedKey = prefix ? `${prefix}.${key}` : key;
+        const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
         if (isPlainObject(value) && Object.keys(value).length > 0) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
             continue;
         }
         if (Array.isArray(value)) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
             continue;
         }
         result[prefixedKey] = value;

package/dist/object/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const toMerged = require('../_chunk/toMerged-DGFrN7.js');
+const toMerged = require('../_chunk/toMerged-BQTfB8.js');
 
 function mergeWith(target, source, merge) {
     const sourceKeys = Object.keys(source);

package/dist/predicate/index.d.mts

@@ -16,6 +16,7 @@ export { isNotNil } from './isNotNil.mjs';
 export { isNull } from './isNull.mjs';
 export { isPlainObject } from './isPlainObject.mjs';
 export { isPrimitive } from './isPrimitive.mjs';
+export { isPromise } from './isPromise.mjs';
 export { isRegExp } from './isRegExp.mjs';
 export { isSet } from './isSet.mjs';
 export { isString } from './isString.mjs';

package/dist/predicate/index.d.ts

@@ -16,6 +16,7 @@ export { isNotNil } from './isNotNil.js';
 export { isNull } from './isNull.js';
 export { isPlainObject } from './isPlainObject.js';
 export { isPrimitive } from './isPrimitive.js';
+export { isPromise } from './isPromise.js';
 export { isRegExp } from './isRegExp.js';
 export { isSet } from './isSet.js';
 export { isString } from './isString.js';

package/dist/predicate/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const isWeakSet = require('../_chunk/isWeakSet-CvIdTA.js');
-const isPlainObject = require('../_chunk/isPlainObject-octpoD.js');
+const isWeakSet = require('../_chunk/isWeakSet-DoHqUM.js');
+const isPlainObject = require('../_chunk/isPlainObject-Xaozpc.js');
 
 function isBoolean(x) {
     return typeof x === 'boolean';
@@ -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;
@@ -37,8 +33,10 @@ exports.isMap = isWeakSet.isMap;
 exports.isNil = isWeakSet.isNil;
 exports.isNotNil = isWeakSet.isNotNil;
 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;
@@ -48,4 +46,3 @@ exports.isTypedArray = isPlainObject.isTypedArray;
 exports.isBoolean = isBoolean;
 exports.isError = isError;
 exports.isString = isString;
-exports.isSymbol = isSymbol;

package/dist/predicate/index.mjs

@@ -16,6 +16,7 @@ export { isNotNil } from './isNotNil.mjs';
 export { isNull } from './isNull.mjs';
 export { isPlainObject } from './isPlainObject.mjs';
 export { isPrimitive } from './isPrimitive.mjs';
+export { isPromise } from './isPromise.mjs';
 export { isRegExp } from './isRegExp.mjs';
 export { isSet } from './isSet.mjs';
 export { isString } from './isString.mjs';

package/dist/predicate/isPromise.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `Promise`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Promise`.
+ *
+ * @param {unknown} value The value to check if it is a `Promise`.
+ * @returns {value is Promise<any>} Returns `true` if `value` is a `Promise`, else `false`.
+ *
+ * @example
+ * const value1 = new Promise((resolve) => resolve());
+ * const value2 = {};
+ * const value3 = 123;
+ *
+ * console.log(isPromise(value1)); // true
+ * console.log(isPromise(value2)); // false
+ * console.log(isPromise(value3)); // false
+ */
+declare function isPromise(value: unknown): value is Promise<any>;
+
+export { isPromise };

package/dist/predicate/isPromise.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `Promise`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Promise`.
+ *
+ * @param {unknown} value The value to check if it is a `Promise`.
+ * @returns {value is Promise<any>} Returns `true` if `value` is a `Promise`, else `false`.
+ *
+ * @example
+ * const value1 = new Promise((resolve) => resolve());
+ * const value2 = {};
+ * const value3 = 123;
+ *
+ * console.log(isPromise(value1)); // true
+ * console.log(isPromise(value2)); // false
+ * console.log(isPromise(value3)); // false
+ */
+declare function isPromise(value: unknown): value is Promise<any>;
+
+export { isPromise };

package/dist/predicate/isPromise.mjs

@@ -0,0 +1,5 @@
+function isPromise(value) {
+    return value instanceof Promise;
+}
+
+export { isPromise };

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

@@ -2,10 +2,62 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const promise_index = require('../_chunk/index-BGZDR9.js');
+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();
+    }
+}
 
-exports.delay = promise_index.delay;
-exports.timeout = promise_index.timeout;
-exports.withTimeout = promise_index.withTimeout;
+async function timeout(ms) {
+    await delay.delay(ms);
+    throw new error_index.TimeoutError();
+}
+
+async function withTimeout(run, ms) {
+    return Promise.race([run(), timeout(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 };

package/dist/promise/mutex.mjs

@@ -0,0 +1,16 @@
+import { Semaphore } from './semaphore.mjs';
+
+class Mutex {
+    semaphore = new Semaphore(1);
+    get isLocked() {
+        return this.semaphore.available === 0;
+    }
+    async acquire() {
+        return this.semaphore.acquire();
+    }
+    release() {
+        this.semaphore.release();
+    }
+}
+
+export { Mutex };

package/dist/promise/semaphore.d.mts

@@ -0,0 +1,81 @@
+/**
+ * A counting semaphore for async functions that manages available permits.
+ * Semaphores are mainly used to limit the number of concurrent async tasks.
+ *
+ * Each `acquire` operation takes a permit or waits until one is available.
+ * Each `release` operation adds a permit, potentially allowing a waiting task to proceed.
+ *
+ * The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers.
+ *
+ * @example
+ * const sema = new Semaphore(2);
+ *
+ * async function task() {
+ *   await sema.acquire();
+ *   try {
+ *     // This code can only be executed by two tasks at the same time
+ *   } finally {
+ *     sema.release();
+ *   }
+ * }
+ *
+ * task();
+ * task();
+ * task(); // This task will wait until one of the previous tasks releases the semaphore.
+ */
+declare class Semaphore {
+    /**
+     * The maximum number of concurrent operations allowed.
+     * @type {number}
+     */
+    capacity: number;
+    /**
+     * The number of available permits.
+     * @type {number}
+     */
+    available: number;
+    private deferredTasks;
+    /**
+     * Creates an instance of Semaphore.
+     * @param {number} capacity - The maximum number of concurrent operations allowed.
+     *
+     * @example
+     * const sema = new Semaphore(3); // Allows up to 3 concurrent operations.
+     */
+    constructor(capacity: number);
+    /**
+     * Acquires a semaphore, blocking if necessary until one is available.
+     * @returns {Promise<void>} A promise that resolves when the semaphore is acquired.
+     *
+     * @example
+     * const sema = new Semaphore(1);
+     *
+     * async function criticalSection() {
+     *   await sema.acquire();
+     *   try {
+     *     // This code section cannot be executed simultaneously
+     *   } finally {
+     *     sema.release();
+     *   }
+     * }
+     */
+    acquire(): Promise<void>;
+    /**
+     * Releases a semaphore, allowing one more operation to proceed.
+     *
+     * @example
+     * const sema = new Semaphore(1);
+     *
+     * async function task() {
+     *   await sema.acquire();
+     *   try {
+     *     // This code can only be executed by two tasks at the same time
+     *   } finally {
+     *     sema.release(); // Allows another waiting task to proceed.
+     *   }
+     * }
+     */
+    release(): void;
+}
+
+export { Semaphore };