@fedify/fedify 1.6.0-dev.808 → 1.6.0-dev.810

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,44 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,30 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,19 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,19 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,19 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,28 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,63 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,80 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,27 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}