@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNotNil.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isNotNil.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNotNil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,IAAI,CAAC,CAE3D"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNull.d.ts

@@ -1,22 +0,0 @@
-/**
- * Checks if the given value is null.
- *
- * This function tests whether the provided value is strictly equal to `null`.
- * It returns `true` if the value is `null`, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`.
- *
- * @param {unknown} x - The value to test if it is null.
- * @returns {x is null} True if the value is null, false otherwise.
- *
- * @example
- * const value1 = null;
- * const value2 = undefined;
- * const value3 = 42;
- *
- * console.log(isNull(value1)); // true
- * console.log(isNull(value2)); // false
- * console.log(isNull(value3)); // false
- */
-export declare function isNull(x: unknown): x is null;
-//# sourceMappingURL=isNull.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isNull.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNull.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,IAAI,CAE5C"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPlainObject.d.ts

@@ -1,44 +0,0 @@
-/**
- * Checks if a given value is a plain object.
- *
- * @param {object} value - The value to check.
- * @returns {value is Record<PropertyKey, any>} - True if the value is a plain object, otherwise false.
- *
- * @example
- * ```typescript
- * // ✅👇 True
- *
- * isPlainObject({ });                       // ✅
- * isPlainObject({ key: 'value' });          // ✅
- * isPlainObject({ key: new Date() });       // ✅
- * isPlainObject(new Object());              // ✅
- * isPlainObject(Object.create(null));       // ✅
- * isPlainObject({ nested: { key: true} });  // ✅
- * isPlainObject(new Proxy({}, {}));         // ✅
- * isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
- *
- * // ✅👇 (cross-realms, node context, workers, ...)
- * const runInNewContext = await import('node:vm').then(
- *     (mod) => mod.runInNewContext
- * );
- * isPlainObject(runInNewContext('({})'));   // ✅
- *
- * // ❌👇 False
- *
- * class Test { };
- * isPlainObject(new Test())           // ❌
- * isPlainObject(10);                  // ❌
- * isPlainObject(null);                // ❌
- * isPlainObject('hello');             // ❌
- * isPlainObject([]);                  // ❌
- * isPlainObject(new Date());          // ❌
- * isPlainObject(new Uint8Array([1])); // ❌
- * isPlainObject(Buffer.from('ABC'));  // ❌
- * isPlainObject(Promise.resolve({})); // ❌
- * isPlainObject(Object.create({}));   // ❌
- * isPlainObject(new (class Cls {}));  // ❌
- * isPlainObject(globalThis);          // ❌,
- * ```
- */
-export declare function isPlainObject(value: unknown): value is Record<PropertyKey, any>;
-//# sourceMappingURL=isPlainObject.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPlainObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPlainObject.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPlainObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,CAkB/E"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPrimitive.d.ts

@@ -1,30 +0,0 @@
-/**
- * Checks whether a value is a JavaScript primitive.
- * JavaScript primitives include null, undefined, strings, numbers, booleans, symbols, and bigints.
- *
- * @param {unknown} value The value to check.
- * @returns {value is
- *     null
- *   | undefined
- *   | string
- *   | number
- *   | boolean
- *   | symbol
- *   | bigint} Returns true if `value` is a primitive, false otherwise.
- *
- * @example
- * isPrimitive(null); // true
- * isPrimitive(undefined); // true
- * isPrimitive('123'); // true
- * isPrimitive(false); // true
- * isPrimitive(true); // true
- * isPrimitive(Symbol('a')); // true
- * isPrimitive(123n); // true
- * isPrimitive({}); // false
- * isPrimitive(new Date()); // false
- * isPrimitive(new Map()); // false
- * isPrimitive(new Set()); // false
- * isPrimitive([1, 2, 3]); // false
- */
-export declare function isPrimitive(value: unknown): value is null | undefined | string | number | boolean | symbol | bigint;
-//# sourceMappingURL=isPrimitive.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPrimitive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPrimitive.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPrimitive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAEnH"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPromise.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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
- */
-export declare function isPromise(value: unknown): value is Promise<any>;
-//# sourceMappingURL=isPromise.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPromise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPromise.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPromise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,CAE/D"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isRegExp.d.ts

@@ -1,15 +0,0 @@
-/**
- * Checks if `value` is a RegExp.
- *
- * @param {unknown} value The value to check.
- * @returns {value is RegExp} Returns `true` if `value` is a RegExp, `false` otherwise.
- *
- * @example
- * const value1 = /abc/;
- * const value2 = '/abc/';
- *
- * console.log(isRegExp(value1)); // true
- * console.log(isRegExp(value2)); // false
- */
-export declare function isRegExp(value: unknown): value is RegExp;
-//# sourceMappingURL=isRegExp.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isRegExp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isRegExp.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isRegExp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSet.d.ts

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isSet.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,CAEvD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isString.d.ts

@@ -1,19 +0,0 @@
-/**
- * Checks if a given value is string.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`.
- *
- * @param {unknown} value The value to check if it is string.
- * @returns {value is string} Returns `true` if `value` is a string, else `false`.
- *
- * @example
- * const value1 = 'abc';
- * const value2 = 123;
- * const value3 = true;
- *
- * console.log(isString(value1)); // true
- * console.log(isString(value2)); // false
- * console.log(isString(value3)); // false
- */
-export declare function isString(value: unknown): value is string;
-//# sourceMappingURL=isString.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isString.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isString.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSymbol.d.ts

@@ -1,25 +0,0 @@
-/**
- * Check whether a value is a symbol.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
- *
- * @param {unknown} value The value to check.
- * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
- *
- * @example
- * import { isSymbol } from 'es-toolkit/predicate';
- *
- * isSymbol(Symbol('a')); // true
- * isSymbol(Symbol.for('a')); // true
- * isSymbol(Symbol.iterator); // true
- *
- * isSymbol(null); // false
- * isSymbol(undefined); // false
- * isSymbol('123'); // false
- * isSymbol(false); // false
- * isSymbol(123n); // false
- * isSymbol({}); // false
- * isSymbol([1, 2, 3]); // false
- */
-export declare function isSymbol(value: unknown): value is symbol;
-//# sourceMappingURL=isSymbol.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSymbol.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isSymbol.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSymbol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isTypedArray.d.ts

@@ -1,28 +0,0 @@
-/**
- * Checks if a value is a TypedArray.
- * @param {unknown} x The value to check.
- * @returns {x is
- *     Uint8Array
- *   | Uint8ClampedArray
- *   | Uint16Array
- *   | Uint32Array
- *   | BigUint64Array
- *   | Int8Array
- *   | Int16Array
- *   | Int32Array
- *   | BigInt64Array
- *   | Float32Array
- *   | Float64Array} Returns true if `x` is a TypedArray, false otherwise.
- *
- * @example
- * const arr = new Uint8Array([1, 2, 3]);
- * isTypedArray(arr); // true
- *
- * const regularArray = [1, 2, 3];
- * isTypedArray(regularArray); // false
- *
- * const buffer = new ArrayBuffer(16);
- * isTypedArray(buffer); // false
- */
-export declare function isTypedArray(x: unknown): x is Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array;
-//# sourceMappingURL=isTypedArray.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isTypedArray.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isTypedArray.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isTypedArray.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,OAAO,GACT,CAAC,IACA,UAAU,GACV,iBAAiB,GACjB,WAAW,GACX,WAAW,GACX,cAAc,GACd,SAAS,GACT,UAAU,GACV,UAAU,GACV,aAAa,GACb,YAAY,GACZ,YAAY,CAEf"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isUndefined.d.ts

@@ -1,22 +0,0 @@
-/**
- * Checks if the given value is undefined.
- *
- * This function tests whether the provided value is strictly equal to `undefined`.
- * It returns `true` if the value is `undefined`, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `undefined`.
- *
- * @param {unknown} x - The value to test if it is undefined.
- * @returns {x is undefined} true if the value is undefined, false otherwise.
- *
- * @example
- * const value1 = undefined;
- * const value2 = null;
- * const value3 = 42;
- *
- * console.log(isUndefined(value1)); // true
- * console.log(isUndefined(value2)); // false
- * console.log(isUndefined(value3)); // false
- */
-export declare function isUndefined(x: unknown): x is undefined;
-//# sourceMappingURL=isUndefined.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isUndefined.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isUndefined.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isUndefined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAEtD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakMap.d.ts

@@ -1,22 +0,0 @@
-/**
- * Checks if the given value is a `WeakMap`.
- *
- * This function tests whether the provided value is an instance of `WeakMap`.
- * It returns `true` if the value is a `WeakMap`, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `WeakMap`.
- *
- * @param {unknown} value - The value to test if it is a `WeakMap`.
- * @returns {value is WeakMap<WeakKey, any>} true if the value is a `WeakMap`, false otherwise.
- *
- * @example
- * const value1 = new WeakMap();
- * const value2 = new Map();
- * const value3 = new Set();
- *
- * console.log(isWeakMap(value1)); // true
- * console.log(isWeakMap(value2)); // false
- * console.log(isWeakMap(value3)); // false
- */
-export declare function isWeakMap(value: unknown): value is WeakMap<WeakKey, any>;
-//# sourceMappingURL=isWeakMap.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakMap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isWeakMap.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakMap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAExE"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakSet.d.ts

@@ -1,22 +0,0 @@
-/**
- * Checks if the given value is a `WeakSet`.
- *
- * This function tests whether the provided value is an instance of `WeakSet`.
- * It returns `true` if the value is a `WeakSet`, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `WeakSet`.
- *
- * @param {unknown} value - The value to test if it is a `WeakSet`.
- * @returns {value is WeakSet<WeakKey>} true if the value is a `WeakSet`, false otherwise.
- *
- * @example
- * const value1 = new WeakSet();
- * const value2 = new Map();
- * const value3 = new Set();
- *
- * console.log(isWeakSet(value1)); // true
- * console.log(isWeakSet(value2)); // false
- * console.log(isWeakSet(value3)); // false
- */
-export declare function isWeakSet(value: unknown): value is WeakSet<WeakKey>;
-//# sourceMappingURL=isWeakSet.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakSet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isWeakSet.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakSet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAEnE"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/delay.d.ts

@@ -1,38 +0,0 @@
-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.
- *
- * @param {number} ms - The number of milliseconds to delay.
- * @param {DelayOptions} options - The options object.
- * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the delay.
- * @returns {Promise<void>} A Promise that resolves after the specified delay.
- *
- * @example
- * 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'
- *  }
- * }
- */
-export declare function delay(ms: number, { signal }?: DelayOptions): Promise<void>;
-export {};
-//# sourceMappingURL=delay.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/delay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/delay.ts"],"names":[],"mappings":"AAEA,UAAU,YAAY;IACpB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsB9E"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/index.d.ts

@@ -1,6 +0,0 @@
-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';
-//# sourceMappingURL=index.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/mutex.d.ts

@@ -1,63 +0,0 @@
-/**
- * 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.
- */
-export 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;
-}
-//# sourceMappingURL=mutex.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/mutex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutex.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/mutex.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,SAAS,CAAoB;IAErC;;;;;;;;;;;OAWG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;;;;;;;;;;OAYG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;;;;;;;;;;OAWG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/semaphore.d.ts

@@ -1,80 +0,0 @@
-/**
- * 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.
- */
-export 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;
-}
-//# sourceMappingURL=semaphore.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/semaphore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"semaphore.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/semaphore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,SAAS;IACpB;;;OAGG;IACI,QAAQ,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACI,SAAS,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,aAAa,CAAyB;IAE9C;;;;;;OAMG;gBACS,QAAQ,EAAE,MAAM;IAK5B;;;;;;;;;;;;;;;OAeG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAW9B;;;;;;;;;;;;;;OAcG;IACH,OAAO,IAAI,IAAI;CAYhB"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/timeout.d.ts

@@ -1,16 +0,0 @@
-/**
- * Returns a promise that rejects with a `TimeoutError` after a specified delay.
- *
- * @param {number} ms - The delay duration in milliseconds.
- * @returns {Promise<never>} A promise that rejects with a `TimeoutError` after the specified delay.
- * @throws {TimeoutError} Throws a `TimeoutError` after the specified delay.
- *
- * @example
- * try {
- *   await timeout(1000); // Timeout exception after 1 second
- * } catch (error) {
- *   console.error(error); // Will log 'The operation was timed out'
- * }
- */
-export declare function timeout(ms: number): Promise<never>;
-//# sourceMappingURL=timeout.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/timeout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/timeout.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAGxD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/withTimeout.d.ts

@@ -1,27 +0,0 @@
-/**
- * Executes an async function and enforces a timeout.
- *
- * If the promise does not resolve within the specified time,
- * the timeout will trigger and the returned promise will be rejected.
- *
- *
- * @template T
- * @param {() => Promise<T>} run - A function that returns a promise to be executed.
- * @param {number} ms - The timeout duration in milliseconds.
- * @returns {Promise<T>} A promise that resolves with the result of the `run` function or rejects if the timeout is reached.
- *
- * @example
- * async function fetchData() {
- *   const response = await fetch('https://example.com/data');
- *   return response.json();
- * }
- *
- * try {
- *   const data = await withTimeout(fetchData, 1000);
- *   console.log(data); // Logs the fetched data if `fetchData` is resolved within 1 second.
- * } catch (error) {
- *   console.error(error); // Will log 'TimeoutError' if `fetchData` is not resolved within 1 second.
- * }
- */
-export declare function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T>;
-//# sourceMappingURL=withTimeout.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/withTimeout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withTimeout.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/withTimeout.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAElF"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/camelCase.d.ts

@@ -1,18 +0,0 @@
-/**
- * Converts a string to camel case.
- *
- * Camel case is the naming convention in which the first word is written in lowercase and
- * each subsequent word begins with a capital letter, concatenated without any separator characters.
- *
- * @param {string} str - The string that is to be changed to camel case.
- * @returns {string} - The converted string to camel case.
- *
- * @example
- * const convertedStr1 = camelCase('camelCase') // returns 'camelCase'
- * const convertedStr2 = camelCase('some whitespace') // returns 'someWhitespace'
- * const convertedStr3 = camelCase('hyphen-text') // returns 'hyphenText'
- * const convertedStr4 = camelCase('HTTPRequest') // returns 'httpRequest'
- * const convertedStr5 = camelCase('Keep unicode 😅') // returns 'keepUnicode😅'
- */
-export declare function camelCase(str: string): string;
-//# sourceMappingURL=camelCase.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/camelCase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"camelCase.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/camelCase.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU7C"}