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

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isPromise.js

@@ -1,20 +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 function isPromise(value) {
-    return value instanceof Promise;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isRegExp.js

@@ -1,16 +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 function isRegExp(value) {
-    return value instanceof RegExp;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSet.js

@@ -1,20 +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 function isSet(value) {
-    return value instanceof Set;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isString.js

@@ -1,20 +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 function isString(value) {
-    return typeof value === 'string';
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isSymbol.js

@@ -1,26 +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 function isSymbol(value) {
-    return typeof value === 'symbol';
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isTypedArray.js

@@ -1,29 +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 function isTypedArray(x) {
-    return ArrayBuffer.isView(x) && !(x instanceof DataView);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isUndefined.js

@@ -1,23 +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 function isUndefined(x) {
-    return x === undefined;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakMap.js

@@ -1,23 +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 function isWeakMap(value) {
-    return value instanceof WeakMap;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isWeakSet.js

@@ -1,23 +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 function isWeakSet(value) {
-    return value instanceof WeakSet;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/delay.js

@@ -1,52 +0,0 @@
-import { AbortError } from '../error/AbortError.js';
-/**
- * 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 function delay(ms, { signal } = {}) {
-    return new Promise((resolve, reject) => {
-        const abortError = () => {
-            reject(new AbortError());
-        };
-        const abortHandler = () => {
-            clearTimeout(timeoutId);
-            abortError();
-        };
-        if (signal?.aborted) {
-            return abortError();
-        }
-        const timeoutId = setTimeout(() => {
-            signal?.removeEventListener('abort', abortHandler);
-            resolve();
-        }, ms);
-        signal?.addEventListener('abort', abortHandler, { once: true });
-    });
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/index.js

@@ -1,5 +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';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/mutex.js

@@ -1,69 +0,0 @@
-import { Semaphore } from './semaphore.js';
-/**
- * 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 class Mutex {
-    semaphore = new Semaphore(1);
-    /**
-     * 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() {
-        return this.semaphore.available === 0;
-    }
-    /**
-     * 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();
-     * }
-     */
-    async acquire() {
-        return this.semaphore.acquire();
-    }
-    /**
-     * 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() {
-        this.semaphore.release();
-    }
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/semaphore.js

@@ -1,99 +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 class Semaphore {
-    /**
-     * The maximum number of concurrent operations allowed.
-     * @type {number}
-     */
-    capacity;
-    /**
-     * The number of available permits.
-     * @type {number}
-     */
-    available;
-    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) {
-        this.capacity = capacity;
-        this.available = capacity;
-    }
-    /**
-     * 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();
-     *   }
-     * }
-     */
-    async acquire() {
-        if (this.available > 0) {
-            this.available--;
-            return;
-        }
-        return new Promise(resolve => {
-            this.deferredTasks.push(resolve);
-        });
-    }
-    /**
-     * 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() {
-        const deferredTask = this.deferredTasks.shift();
-        if (deferredTask != null) {
-            deferredTask();
-            return;
-        }
-        if (this.available < this.capacity) {
-            this.available++;
-        }
-    }
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/timeout.js

@@ -1,20 +0,0 @@
-import { delay } from './delay.js';
-import { TimeoutError } from '../error/TimeoutError.js';
-/**
- * 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 async function timeout(ms) {
-    await delay(ms);
-    throw new TimeoutError();
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/promise/withTimeout.js

@@ -1,29 +0,0 @@
-import { timeout } from './timeout.js';
-/**
- * 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 async function withTimeout(run, ms) {
-    return Promise.race([run(), timeout(ms)]);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/camelCase.js

@@ -1,26 +0,0 @@
-import { capitalize } from './capitalize.js';
-import { words as getWords } from './words.js';
-/**
- * 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 function camelCase(str) {
-    const words = getWords(str);
-    if (words.length === 0) {
-        return '';
-    }
-    const [first, ...rest] = words;
-    return `${first.toLowerCase()}${rest.map(word => capitalize(word)).join('')}`;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/capitalize.js

@@ -1,14 +0,0 @@
-/**
- * Converts the first character of string to upper case and the remaining to lower case.
- *
- * @template T - Literal type of the string.
- * @param {T} str - The string to be converted to uppercase.
- * @returns {Capitalize<T>} - The capitalized string.
- *
- * @example
- * const result = capitalize('fred') // returns 'Fred'
- * const result2 = capitalize('FRED') // returns 'Fred'
- */
-export function capitalize(str) {
-    return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase());
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/constantCase.js

@@ -1,19 +0,0 @@
-import { words as getWords } from './words.js';
-/**
- * Converts a string to constant case.
- *
- * Constant case is a naming convention where each word is written in uppercase letters and separated by an underscore (`_`). For example, `CONSTANT_CASE`.
- *
- * @param {string} str - The string that is to be changed to constant case.
- * @returns {string} - The converted string to constant case.
- *
- * @example
- * const convertedStr1 = constantCase('camelCase') // returns 'CAMEL_CASE'
- * const convertedStr2 = constantCase('some whitespace') // returns 'SOME_WHITESPACE'
- * const convertedStr3 = constantCase('hyphen-text') // returns 'HYPHEN_TEXT'
- * const convertedStr4 = constantCase('HTTPRequest') // returns 'HTTP_REQUEST'
- */
-export function constantCase(str) {
-    const words = getWords(str);
-    return words.map(word => word.toUpperCase()).join('_');
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/deburr.js

@@ -1,64 +0,0 @@
-const deburrMap = new Map(
-// eslint-disable-next-line no-restricted-syntax
-Object.entries({
-    Æ: 'Ae',
-    Ð: 'D',
-    Ø: 'O',
-    Þ: 'Th',
-    ß: 'ss',
-    æ: 'ae',
-    ð: 'd',
-    ø: 'o',
-    þ: 'th',
-    Đ: 'D',
-    đ: 'd',
-    Ħ: 'H',
-    ħ: 'h',
-    ı: 'i',
-    IJ: 'IJ',
-    ij: 'ij',
-    ĸ: 'k',
-    Ŀ: 'L',
-    ŀ: 'l',
-    Ł: 'L',
-    ł: 'l',
-    ʼn: "'n",
-    Ŋ: 'N',
-    ŋ: 'n',
-    Œ: 'Oe',
-    œ: 'oe',
-    Ŧ: 'T',
-    ŧ: 't',
-    ſ: 's',
-}));
-/**
- * Converts a string by replacing special characters and diacritical marks with their ASCII equivalents.
- * For example, "Crème brûlée" becomes "Creme brulee".
- *
- * @param {string} str - The input string to be deburred.
- * @returns {string} - The deburred string with special characters replaced by their ASCII equivalents.
- *
- * @example
- * // Basic usage:
- * deburr('Æthelred') // returns 'Aethelred'
- *
- * @example
- * // Handling diacritical marks:
- * deburr('München') // returns 'Munchen'
- *
- * @example
- * // Special characters:
- * deburr('Crème brûlée') // returns 'Creme brulee'
- */
-export function deburr(str) {
-    str = str.normalize('NFD');
-    let result = '';
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        if ((char >= '\u0300' && char <= '\u036f') || (char >= '\ufe20' && char <= '\ufe23')) {
-            continue;
-        }
-        result += deburrMap.get(char) ?? char;
-    }
-    return result;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/escape.js

@@ -1,23 +0,0 @@
-const htmlEscapes = {
-    '&': '&',
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    "'": '&#39;',
-};
-/**
- * Converts the characters "&", "<", ">", '"', and "'" in `str` to their corresponding HTML entities.
- * For example, "<" becomes "&lt;".
- *
- * @param {string} str  The string to escape.
- * @returns {string} Returns the escaped string.
- *
- * @example
- * escape('This is a <div> element.'); // returns 'This is a &lt;div&gt; element.'
- * escape('This is a "quote"'); // returns 'This is a &quot;quote&quot;'
- * escape("This is a 'quote'"); // returns 'This is a &#39;quote&#39;'
- * escape('This is a & symbol'); // returns 'This is a &amp; symbol'
- */
-export function escape(str) {
-    return str.replace(/[&<>"']/g, match => htmlEscapes[match]);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/string/escapeRegExp.js

@@ -1,14 +0,0 @@
-/**
- * Escapes the RegExp special characters "^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", and "|" in `str`.
- *
- * @param {string} str The string to escape.
- * @returns {string} Returns the escaped string.
- *
- * @example
- * import { escapeRegExp } from 'es-toolkit/string';
- *
- * escapeRegExp('[es-toolkit](https://es-toolkit.slash.page/)'); // returns '\[es-toolkit\]\(https://es-toolkit\.slash\.page/\)'
- */
-export function escapeRegExp(str) {
-    return str.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
-}