@stryke/helpers 0.10.9 → 0.10.11

package/dist/debounce.mjs

@@ -1,63 +0,0 @@
-//#region src/debounce.ts
-/**
-* Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
-* have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
-* method to cancel any pending execution.
-*
-* @example
-* ```typescript
-* const debouncedFunction = debounce(() => {
-*   console.log('Function executed');
-* }, 1000);
-*
-* // Will log 'Function executed' after 1 second if not called again in that time
-* debouncedFunction();
-*
-* // Will not log anything as the previous call is canceled
-* debouncedFunction.cancel();
-*
-* // With AbortSignal
-* const controller = new AbortController();
-* const signal = controller.signal;
-* const debouncedWithSignal = debounce(() => {
-*  console.log('Function executed');
-* }, 1000, { signal });
-*
-* debouncedWithSignal();
-*
-* // Will cancel the debounced function call
-* controller.abort();
-* ```
-*
-* @param func - The function to debounce
-* @param debounceMs - The number of milliseconds to delay
-* @param options - Optional configuration for the debounced function, including an AbortSignal to cancel the debounce
-* @returns A new debounced function with a `cancel` method.
-*/
-function debounce(func, debounceMs, options = {}) {
-	let timeoutId = null;
-	const { signal } = options;
-	const debounced = ((...args) => {
-		if (timeoutId !== null) clearTimeout(timeoutId);
-		if (signal?.aborted) return;
-		timeoutId = setTimeout(() => {
-			func(...args);
-			timeoutId = null;
-		}, debounceMs);
-	});
-	const onAbort = () => {
-		debounced.cancel();
-	};
-	debounced.cancel = () => {
-		if (timeoutId !== null) {
-			clearTimeout(timeoutId);
-			timeoutId = null;
-		}
-	};
-	signal?.addEventListener("abort", onAbort, { once: true });
-	return debounced;
-}
-
-//#endregion
-export { debounce };
-//# sourceMappingURL=debounce.mjs.map

package/dist/debounce.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.mjs","names":["timeoutId: ReturnType<typeof setTimeout> | null"],"sources":["../src/debounce.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nexport interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @example\n * ```typescript\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n * ```\n *\n * @param func - The function to debounce\n * @param debounceMs - The number of milliseconds to delay\n * @param options - Optional configuration for the debounced function, including an AbortSignal to cancel the debounce\n * @returns A new debounced function with a `cancel` method.\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  options: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n  const { signal } = options;\n\n  const debounced = ((...args: Parameters<F>) => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs);\n  }) as F & { cancel: () => void };\n\n  const onAbort = () => {\n    debounced.cancel();\n  };\n\n  debounced.cancel = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener(\"abort\", onAbort, { once: true });\n\n  return debounced;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,SACd,MACA,YACA,UAA2B,EAAE,EACD;CAC5B,IAAIA,YAAkD;CACtD,MAAM,EAAE,WAAW;CAEnB,MAAM,cAAc,GAAG,SAAwB;AAC7C,MAAI,cAAc,KAChB,cAAa,UAAU;AAGzB,MAAI,QAAQ,QACV;AAGF,cAAY,iBAAiB;AAC3B,QAAK,GAAG,KAAK;AACb,eAAY;KACX,WAAW;;CAGhB,MAAM,gBAAgB;AACpB,YAAU,QAAQ;;AAGpB,WAAU,eAAe;AACvB,MAAI,cAAc,MAAM;AACtB,gBAAa,UAAU;AACvB,eAAY;;;AAIhB,SAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,MAAM,CAAC;AAE1D,QAAO"}

package/dist/delay.cjs

@@ -1,91 +0,0 @@
-const require_errors = require('./errors.cjs');
-
-//#region src/delay.ts
-/**
-* Delays the execution of code for a specified number of milliseconds.
-*
-* This function returns a Promise that resolves after the specified delay, allowing you to use it
-* with async/await to pause execution.
-*
-* @example
-* ```typescript
-* async function foo() {
-*   console.log('Start');
-*   await delay(1000); // Delays execution for 1 second
-*   console.log('End');
-* }
-*
-* foo();
-*
-* // With AbortSignal
-* const controller = new AbortController();
-* const { signal } = controller;
-*
-* setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
-* try {
-*   await delay(100, { signal });
-*  } catch (error) {
-*   console.error(error); // Will log 'AbortError'
-*  }
-* }
-* ```
-*
-* @param ms - The number of milliseconds to delay.
-* @param options - The options object.
-* @returns A Promise that resolves after the specified delay.
-*/
-async function delay(ms, options = {}) {
-	const { signal } = options;
-	return new Promise((resolve, reject) => {
-		const abortError = () => {
-			reject(new require_errors.AbortError());
-		};
-		const abortHandler = () => {
-			clearTimeout(timeoutId);
-			abortError();
-		};
-		if (signal?.aborted) return abortError();
-		const timeoutId = setTimeout(resolve, ms);
-		signal?.addEventListener("abort", abortHandler, { once: true });
-	});
-}
-/**
-* Delays the execution of code for a specified number of milliseconds.
-*
-* This function returns a Promise that resolves after the specified delay, allowing you to use it
-* with async/await to pause execution.
-*
-* @example
-* ```typescript
-* async function foo() {
-*   console.log('Start');
-*   await sleep(1000); // Delays execution for 1 second
-*   console.log('End');
-* }
-*
-* foo();
-*
-* // With AbortSignal
-* const controller = new AbortController();
-* const { signal } = controller;
-*
-* setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
-* try {
-*   await sleep(100, { signal });
-*  } catch (error) {
-*   console.error(error); // Will log 'AbortError'
-*  }
-* }
-* ```
-*
-* @param ms - The number of milliseconds to sleep.
-* @param options - The options object.
-* @returns A Promise that resolves after the specified sleep.
-*/
-async function sleep(ms, options) {
-	return delay(ms, options);
-}
-
-//#endregion
-exports.delay = delay;
-exports.sleep = sleep;

package/dist/delay.d.cts

@@ -1,75 +0,0 @@
-//#region src/delay.d.ts
-interface DelayOptions {
-  signal?: AbortSignal;
-}
-/**
- * Delays the execution of code for a specified number of milliseconds.
- *
- * This function returns a Promise that resolves after the specified delay, allowing you to use it
- * with async/await to pause execution.
- *
- * @example
- * ```typescript
- * async function foo() {
- *   console.log('Start');
- *   await delay(1000); // Delays execution for 1 second
- *   console.log('End');
- * }
- *
- * foo();
- *
- * // With AbortSignal
- * const controller = new AbortController();
- * const { signal } = controller;
- *
- * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
- * try {
- *   await delay(100, { signal });
- *  } catch (error) {
- *   console.error(error); // Will log 'AbortError'
- *  }
- * }
- * ```
- *
- * @param ms - The number of milliseconds to delay.
- * @param options - The options object.
- * @returns A Promise that resolves after the specified delay.
- */
-declare function delay(ms: number, options?: DelayOptions): Promise<void>;
-/**
- * Delays the execution of code for a specified number of milliseconds.
- *
- * This function returns a Promise that resolves after the specified delay, allowing you to use it
- * with async/await to pause execution.
- *
- * @example
- * ```typescript
- * async function foo() {
- *   console.log('Start');
- *   await sleep(1000); // Delays execution for 1 second
- *   console.log('End');
- * }
- *
- * foo();
- *
- * // With AbortSignal
- * const controller = new AbortController();
- * const { signal } = controller;
- *
- * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
- * try {
- *   await sleep(100, { signal });
- *  } catch (error) {
- *   console.error(error); // Will log 'AbortError'
- *  }
- * }
- * ```
- *
- * @param ms - The number of milliseconds to sleep.
- * @param options - The options object.
- * @returns A Promise that resolves after the specified sleep.
- */
-declare function sleep(ms: number, options?: DelayOptions): Promise<void>;
-//#endregion
-export { delay, sleep };
-//# sourceMappingURL=delay.d.cts.map

package/dist/delay.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delay.d.cts","names":[],"sources":["../src/delay.ts"],"sourcesContent":[],"mappings":";UAoBU,YAAA;EAAA,MAAA,CAAA,EACC,WADW;AAqCtB;AA6DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA7DsB,KAAA,uBAEX,eACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DmB,KAAA,uBAA4B,eAAe"}

package/dist/delay.d.mts

@@ -1,75 +0,0 @@
-//#region src/delay.d.ts
-interface DelayOptions {
-  signal?: AbortSignal;
-}
-/**
- * Delays the execution of code for a specified number of milliseconds.
- *
- * This function returns a Promise that resolves after the specified delay, allowing you to use it
- * with async/await to pause execution.
- *
- * @example
- * ```typescript
- * async function foo() {
- *   console.log('Start');
- *   await delay(1000); // Delays execution for 1 second
- *   console.log('End');
- * }
- *
- * foo();
- *
- * // With AbortSignal
- * const controller = new AbortController();
- * const { signal } = controller;
- *
- * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
- * try {
- *   await delay(100, { signal });
- *  } catch (error) {
- *   console.error(error); // Will log 'AbortError'
- *  }
- * }
- * ```
- *
- * @param ms - The number of milliseconds to delay.
- * @param options - The options object.
- * @returns A Promise that resolves after the specified delay.
- */
-declare function delay(ms: number, options?: DelayOptions): Promise<void>;
-/**
- * Delays the execution of code for a specified number of milliseconds.
- *
- * This function returns a Promise that resolves after the specified delay, allowing you to use it
- * with async/await to pause execution.
- *
- * @example
- * ```typescript
- * async function foo() {
- *   console.log('Start');
- *   await sleep(1000); // Delays execution for 1 second
- *   console.log('End');
- * }
- *
- * foo();
- *
- * // With AbortSignal
- * const controller = new AbortController();
- * const { signal } = controller;
- *
- * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
- * try {
- *   await sleep(100, { signal });
- *  } catch (error) {
- *   console.error(error); // Will log 'AbortError'
- *  }
- * }
- * ```
- *
- * @param ms - The number of milliseconds to sleep.
- * @param options - The options object.
- * @returns A Promise that resolves after the specified sleep.
- */
-declare function sleep(ms: number, options?: DelayOptions): Promise<void>;
-//#endregion
-export { delay, sleep };
-//# sourceMappingURL=delay.d.mts.map

package/dist/delay.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delay.d.mts","names":[],"sources":["../src/delay.ts"],"sourcesContent":[],"mappings":";UAoBU,YAAA;EAAA,MAAA,CAAA,EACC,WADW;AAqCtB;AA6DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA7DsB,KAAA,uBAEX,eACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DmB,KAAA,uBAA4B,eAAe"}

package/dist/delay.mjs

@@ -1,91 +0,0 @@
-import { AbortError } from "./errors.mjs";
-
-//#region src/delay.ts
-/**
-* Delays the execution of code for a specified number of milliseconds.
-*
-* This function returns a Promise that resolves after the specified delay, allowing you to use it
-* with async/await to pause execution.
-*
-* @example
-* ```typescript
-* async function foo() {
-*   console.log('Start');
-*   await delay(1000); // Delays execution for 1 second
-*   console.log('End');
-* }
-*
-* foo();
-*
-* // With AbortSignal
-* const controller = new AbortController();
-* const { signal } = controller;
-*
-* setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
-* try {
-*   await delay(100, { signal });
-*  } catch (error) {
-*   console.error(error); // Will log 'AbortError'
-*  }
-* }
-* ```
-*
-* @param ms - The number of milliseconds to delay.
-* @param options - The options object.
-* @returns A Promise that resolves after the specified delay.
-*/
-async function delay(ms, options = {}) {
-	const { signal } = options;
-	return new Promise((resolve, reject) => {
-		const abortError = () => {
-			reject(new AbortError());
-		};
-		const abortHandler = () => {
-			clearTimeout(timeoutId);
-			abortError();
-		};
-		if (signal?.aborted) return abortError();
-		const timeoutId = setTimeout(resolve, ms);
-		signal?.addEventListener("abort", abortHandler, { once: true });
-	});
-}
-/**
-* Delays the execution of code for a specified number of milliseconds.
-*
-* This function returns a Promise that resolves after the specified delay, allowing you to use it
-* with async/await to pause execution.
-*
-* @example
-* ```typescript
-* async function foo() {
-*   console.log('Start');
-*   await sleep(1000); // Delays execution for 1 second
-*   console.log('End');
-* }
-*
-* foo();
-*
-* // With AbortSignal
-* const controller = new AbortController();
-* const { signal } = controller;
-*
-* setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
-* try {
-*   await sleep(100, { signal });
-*  } catch (error) {
-*   console.error(error); // Will log 'AbortError'
-*  }
-* }
-* ```
-*
-* @param ms - The number of milliseconds to sleep.
-* @param options - The options object.
-* @returns A Promise that resolves after the specified sleep.
-*/
-async function sleep(ms, options) {
-	return delay(ms, options);
-}
-
-//#endregion
-export { delay, sleep };
-//# sourceMappingURL=delay.mjs.map

package/dist/delay.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"delay.mjs","names":[],"sources":["../src/delay.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { AbortError } from \"./errors\";\n\ninterface DelayOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Delays the execution of code for a specified number of milliseconds.\n *\n * This function returns a Promise that resolves after the specified delay, allowing you to use it\n * with async/await to pause execution.\n *\n * @example\n * ```typescript\n * async function foo() {\n *   console.log('Start');\n *   await delay(1000); // Delays execution for 1 second\n *   console.log('End');\n * }\n *\n * foo();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const { signal } = controller;\n *\n * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms\n * try {\n *   await delay(100, { signal });\n *  } catch (error) {\n *   console.error(error); // Will log 'AbortError'\n *  }\n * }\n * ```\n *\n * @param ms - The number of milliseconds to delay.\n * @param options - The options object.\n * @returns A Promise that resolves after the specified delay.\n */\nexport async function delay(\n  ms: number,\n  options: DelayOptions = {}\n): Promise<void> {\n  const { signal } = options;\n\n  return new Promise((resolve, reject) => {\n    const abortError = () => {\n      reject(new AbortError());\n    };\n\n    const abortHandler = () => {\n      // eslint-disable-next-line ts/no-use-before-define\n      clearTimeout(timeoutId);\n      abortError();\n    };\n\n    if (signal?.aborted) {\n      // eslint-disable-next-line no-promise-executor-return\n      return abortError();\n    }\n\n    const timeoutId = setTimeout(resolve, ms);\n\n    signal?.addEventListener(\"abort\", abortHandler, { once: true });\n  });\n}\n\n/**\n * Delays the execution of code for a specified number of milliseconds.\n *\n * This function returns a Promise that resolves after the specified delay, allowing you to use it\n * with async/await to pause execution.\n *\n * @example\n * ```typescript\n * async function foo() {\n *   console.log('Start');\n *   await sleep(1000); // Delays execution for 1 second\n *   console.log('End');\n * }\n *\n * foo();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const { signal } = controller;\n *\n * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms\n * try {\n *   await sleep(100, { signal });\n *  } catch (error) {\n *   console.error(error); // Will log 'AbortError'\n *  }\n * }\n * ```\n *\n * @param ms - The number of milliseconds to sleep.\n * @param options - The options object.\n * @returns A Promise that resolves after the specified sleep.\n */\nexport async function sleep(ms: number, options?: DelayOptions): Promise<void> {\n  return delay(ms, options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,eAAsB,MACpB,IACA,UAAwB,EAAE,EACX;CACf,MAAM,EAAE,WAAW;AAEnB,QAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,mBAAmB;AACvB,UAAO,IAAI,YAAY,CAAC;;EAG1B,MAAM,qBAAqB;AAEzB,gBAAa,UAAU;AACvB,eAAY;;AAGd,MAAI,QAAQ,QAEV,QAAO,YAAY;EAGrB,MAAM,YAAY,WAAW,SAAS,GAAG;AAEzC,UAAQ,iBAAiB,SAAS,cAAc,EAAE,MAAM,MAAM,CAAC;GAC/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCJ,eAAsB,MAAM,IAAY,SAAuC;AAC7E,QAAO,MAAM,IAAI,QAAQ"}

package/dist/errors.cjs

@@ -1,24 +0,0 @@
-
-//#region src/errors.ts
-/**
-* An error class representing an aborted operation.
-*/
-var AbortError = class extends Error {
-	constructor(message = "The operation was aborted") {
-		super(message);
-		this.name = "AbortError";
-	}
-};
-/**
-* An error class representing an timeout operation.
-*/
-var TimeoutError = class extends Error {
-	constructor(message = "The operation was timed out") {
-		super(message);
-		this.name = "TimeoutError";
-	}
-};
-
-//#endregion
-exports.AbortError = AbortError;
-exports.TimeoutError = TimeoutError;

package/dist/errors.d.cts

@@ -1,16 +0,0 @@
-//#region src/errors.d.ts
-/**
- * An error class representing an aborted operation.
- */
-declare class AbortError extends Error {
-  constructor(message?: string);
-}
-/**
- * An error class representing an timeout operation.
- */
-declare class TimeoutError extends Error {
-  constructor(message?: string);
-}
-//#endregion
-export { AbortError, TimeoutError };
-//# sourceMappingURL=errors.d.cts.map

package/dist/errors.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.cts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";;AAqBA;AAUA;cAVa,UAAA,SAAmB,KAAA;;;;;;cAUnB,YAAA,SAAqB,KAAA"}

package/dist/errors.d.mts

@@ -1,16 +0,0 @@
-//#region src/errors.d.ts
-/**
- * An error class representing an aborted operation.
- */
-declare class AbortError extends Error {
-  constructor(message?: string);
-}
-/**
- * An error class representing an timeout operation.
- */
-declare class TimeoutError extends Error {
-  constructor(message?: string);
-}
-//#endregion
-export { AbortError, TimeoutError };
-//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";;AAqBA;AAUA;cAVa,UAAA,SAAmB,KAAA;;;;;;cAUnB,YAAA,SAAqB,KAAA"}

package/dist/errors.mjs

@@ -1,23 +0,0 @@
-//#region src/errors.ts
-/**
-* An error class representing an aborted operation.
-*/
-var AbortError = class extends Error {
-	constructor(message = "The operation was aborted") {
-		super(message);
-		this.name = "AbortError";
-	}
-};
-/**
-* An error class representing an timeout operation.
-*/
-var TimeoutError = class extends Error {
-	constructor(message = "The operation was timed out") {
-		super(message);
-		this.name = "TimeoutError";
-	}
-};
-
-//#endregion
-export { AbortError, TimeoutError };
-//# sourceMappingURL=errors.mjs.map

package/dist/errors.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\n/**\n * An error class representing an aborted operation.\n */\nexport class AbortError extends Error {\n  constructor(message = \"The operation was aborted\") {\n    super(message);\n    this.name = \"AbortError\";\n  }\n}\n\n/**\n * An error class representing an timeout operation.\n */\nexport class TimeoutError extends Error {\n  constructor(message = \"The operation was timed out\") {\n    super(message);\n    this.name = \"TimeoutError\";\n  }\n}\n"],"mappings":";;;;AAqBA,IAAa,aAAb,cAAgC,MAAM;CACpC,YAAY,UAAU,6BAA6B;AACjD,QAAM,QAAQ;AACd,OAAK,OAAO;;;;;;AAOhB,IAAa,eAAb,cAAkC,MAAM;CACtC,YAAY,UAAU,+BAA+B;AACnD,QAAM,QAAQ;AACd,OAAK,OAAO"}

package/dist/mutex.cjs

@@ -1,80 +0,0 @@
-const require_semaphore = require('./semaphore.cjs');
-
-//#region src/mutex.ts
-/**
-* A Mutex (mutual exclusion lock) for async functions.
-* It allows only one async task to access a critical section at a time.
-*
-* @example
-* ```typescript
-* 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.
-* ```
-*/
-var Mutex = class {
-	semaphore = new require_semaphore.Semaphore(1);
-	/**
-	* Checks if the mutex is currently locked.
-	* @returns 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() {
-		return this.semaphore.available === 0;
-	}
-	/**
-	* Acquires the mutex, blocking if necessary until it is available.
-	* @returns A promise that resolves when the mutex is acquired.
-	*
-	* @example
-	* ```typescript
-	* const mutex = new Mutex();
-	* await mutex.acquire();
-	* try {
-	*   // This code section cannot be executed simultaneously
-	* } finally {
-	*   mutex.release();
-	* }
-	* ```
-	*/
-	async acquire() {
-		return this.semaphore.acquire();
-	}
-	/**
-	* Releases the mutex, allowing another waiting task to proceed.
-	*
-	* @example
-	* ```typescript
-	* 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() {
-		this.semaphore.release();
-	}
-};
-
-//#endregion
-exports.Mutex = Mutex;

package/dist/mutex.d.cts

@@ -1,72 +0,0 @@
-//#region src/mutex.d.ts
-/**
- * A Mutex (mutual exclusion lock) for async functions.
- * It allows only one async task to access a critical section at a time.
- *
- * @example
- * ```typescript
- * 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 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 A promise that resolves when the mutex is acquired.
-   *
-   * @example
-   * ```typescript
-   * 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
-   * ```typescript
-   * 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;
-}
-//#endregion
-export { Mutex };
-//# sourceMappingURL=mutex.d.cts.map

package/dist/mutex.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutex.d.cts","names":[],"sources":["../src/mutex.ts"],"sourcesContent":[],"mappings":";;AAyCA;;;;;;;;;;;;;;;;;;;;cAAa,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkCa"}