@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/string/index.js

@@ -1,21 +0,0 @@
-export { camelCase } from './camelCase.js';
-export { capitalize } from './capitalize.js';
-export { constantCase } from './constantCase.js';
-export { deburr } from './deburr.js';
-export { escape } from './escape.js';
-export { escapeRegExp } from './escapeRegExp.js';
-export { kebabCase } from './kebabCase.js';
-export { lowerCase } from './lowerCase.js';
-export { lowerFirst } from './lowerFirst.js';
-export { pad } from './pad.js';
-export { pascalCase } from './pascalCase.js';
-export { reverseString } from './reverseString.js';
-export { snakeCase } from './snakeCase.js';
-export { startCase } from './startCase.js';
-export { trim } from './trim.js';
-export { trimEnd } from './trimEnd.js';
-export { trimStart } from './trimStart.js';
-export { unescape } from './unescape.js';
-export { upperCase } from './upperCase.js';
-export { upperFirst } from './upperFirst.js';
-export { words } from './words.js';

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

@@ -1,19 +0,0 @@
-import { words as getWords } from './words.js';
-/**
- * Converts a string to kebab case.
- *
- * Kebab case is the naming convention in which each word is written in lowercase and separated by a dash (-) character.
- *
- * @param {string} str - The string that is to be changed to kebab case.
- * @returns {string} - The converted string to kebab case.
- *
- * @example
- * const convertedStr1 = kebabCase('camelCase') // returns 'camel-case'
- * const convertedStr2 = kebabCase('some whitespace') // returns 'some-whitespace'
- * const convertedStr3 = kebabCase('hyphen-text') // returns 'hyphen-text'
- * const convertedStr4 = kebabCase('HTTPRequest') // returns 'http-request'
- */
-export function kebabCase(str) {
-    const words = getWords(str);
-    return words.map(word => word.toLowerCase()).join('-');
-}

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

@@ -1,19 +0,0 @@
-import { words as getWords } from './words.js';
-/**
- * Converts a string to lower case.
- *
- * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character.
- *
- * @param {string} str - The string that is to be changed to lower case.
- * @returns {string} - The converted string to lower case.
- *
- * @example
- * const convertedStr1 = lowerCase('camelCase') // returns 'camel case'
- * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace'
- * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text'
- * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request'
- */
-export function lowerCase(str) {
-    const words = getWords(str);
-    return words.map(word => word.toLowerCase()).join(' ');
-}

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

@@ -1,14 +0,0 @@
-/**
- * Converts the first character of string to lower case.
- *
- * @param {string} str - The string that is to be changed
- * @returns {string} - The converted string.
- *
- * @example
- * const convertedStr1 = lowerCase('fred') // returns 'fred'
- * const convertedStr2 = lowerCase('Fred') // returns 'fred'
- * const convertedStr3 = lowerCase('FRED') // returns 'fRED'
- */
-export function lowerFirst(str) {
-    return str.substring(0, 1).toLowerCase() + str.substring(1);
-}

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

@@ -1,19 +0,0 @@
-/**
- * Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length.
- * If the length is less than or equal to the original string's length, or if the padding character is an empty string, the original string is returned unchanged.
- *
- * @param {string} str - The string to pad.
- * @param {number} [length] - The length of the resulting string once padded.
- * @param {string} [chars] - The character(s) to use for padding.
- * @returns {string} - The padded string, or the original string if padding is not required.
- *
- * @example
- * const result1 = pad('abc', 8);         // result will be '  abc   '
- * const result2 = pad('abc', 8, '_-');   // result will be '_-abc_-_'
- * const result3 = pad('abc', 3);         // result will be 'abc'
- * const result4 = pad('abc', 2);         // result will be 'abc'
- *
- */
-export function pad(str, length, chars = ' ') {
-    return str.padStart(Math.floor((length - str.length) / 2) + str.length, chars).padEnd(length, chars);
-}

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

@@ -1,20 +0,0 @@
-import { capitalize } from './capitalize.js';
-import { words as getWords } from './words.js';
-/**
- * Converts a string to Pascal case.
- *
- * Pascal case is the naming convention in which each word is capitalized and concatenated without any separator characters.
- *
- * @param {string} str - The string that is to be changed to pascal case.
- * @returns {string} - The converted string to Pascal case.
- *
- * @example
- * const convertedStr1 = pascalCase('pascalCase') // returns 'PascalCase'
- * const convertedStr2 = pascalCase('some whitespace') // returns 'SomeWhitespace'
- * const convertedStr3 = pascalCase('hyphen-text') // returns 'HyphenText'
- * const convertedStr4 = pascalCase('HTTPRequest') // returns 'HttpRequest'
- */
-export function pascalCase(str) {
-    const words = getWords(str);
-    return words.map(word => capitalize(word)).join('');
-}

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

@@ -1,16 +0,0 @@
-/**
- * Reverses a given string.
- *
- * This function takes a string as input and returns a new string that is the reverse of the input.
- *
- * @param {string} value - The string that is to be reversed.
- * @returns {string} - The reversed string.
- *
- * @example
- * const reversedStr1 = reverseString('hello') // returns 'olleh'
- * const reversedStr2 = reverseString('PascalCase') // returns 'esaClacsaP'
- * const reversedStr3 = reverseString('foo 😄 bar') // returns 'rab 😄 oof'
- */
-export function reverseString(value) {
-    return [...value].reverse().join('');
-}

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

@@ -1,19 +0,0 @@
-import { words as getWords } from './words.js';
-/**
- * Converts a string to snake case.
- *
- * Snake case is the naming convention in which each word is written in lowercase and separated by an underscore (_) character.
- *
- * @param {string} str - The string that is to be changed to snake case.
- * @returns {string} - The converted string to snake case.
- *
- * @example
- * const convertedStr1 = snakeCase('camelCase') // returns 'camel_case'
- * const convertedStr2 = snakeCase('some whitespace') // returns 'some_whitespace'
- * const convertedStr3 = snakeCase('hyphen-text') // returns 'hyphen_text'
- * const convertedStr4 = snakeCase('HTTPRequest') // returns 'http_request'
- */
-export function snakeCase(str) {
-    const words = getWords(str);
-    return words.map(word => word.toLowerCase()).join('_');
-}

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

@@ -1,26 +0,0 @@
-import { words as getWords } from './words.js';
-/**
- * Converts the first character of each word in a string to uppercase and the remaining characters to lowercase.
- *
- * Start case is the naming convention in which each word is written with an initial capital letter.
- * @param {string} str - The string to convert.
- * @returns {string} The converted string.
- *
- * @example
- * const result1 = startCase('hello world');  // result will be 'Hello World'
- * const result2 = startCase('HELLO WORLD');  // result will be 'Hello World'
- * const result3 = startCase('hello-world');  // result will be 'Hello World'
- * const result4 = startCase('hello_world');  // result will be 'Hello World'
- */
-export function startCase(str) {
-    const words = getWords(str.trim());
-    let result = '';
-    for (let i = 0; i < words.length; i++) {
-        const word = words[i];
-        if (result) {
-            result += ' ';
-        }
-        result += word[0].toUpperCase() + word.slice(1).toLowerCase();
-    }
-    return result;
-}

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

@@ -1,20 +0,0 @@
-import { trimEnd } from './trimEnd.js';
-import { trimStart } from './trimStart.js';
-/**
- * Removes leading and trailing whitespace or specified characters from a string.
- *
- * @param {string} str - The string from which characters will be trimmed.
- * @param {string | string[]} chars - The character(s) to remove from the string. Can be a single character or an array of characters.
- * @returns {string} - The resulting string after the specified characters have been removed.
- *
- * @example
- * trim("  hello  "); // "hello"
- * trim("--hello--", "-"); // "hello"
- * trim("##hello##", ["#", "o"]); // "hell"
- */
-export function trim(str, chars) {
-    if (chars === undefined) {
-        return str.trim();
-    }
-    return trimStart(trimEnd(str, chars), chars);
-}

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

@@ -1,39 +0,0 @@
-/**
- * Removes trailing whitespace or specified characters from a string.
- *
- * If `chars` is a string, it should be a single character. To trim a string with multiple characters,
- * provide an array instead.
- *
- * @param {string} str - The string from which trailing characters will be trimmed.
- * @param {string | string[]} chars - The character(s) to remove from the end of the string.
- * @returns {string} - The resulting string after the specified trailing character has been removed.
- *
- * @example
- * const trimmedStr1 = trimEnd('hello---', '-') // returns 'hello'
- * const trimmedStr2 = trimEnd('123000', '0') // returns '123'
- * const trimmedStr3 = trimEnd('abcabcabc', 'c') // returns 'abcabcab'
- * const trimmedStr4 = trimEnd('trimmedxxx', 'x') // returns 'trimmed'
- */
-export function trimEnd(str, chars) {
-    if (chars === undefined) {
-        return str.trimEnd();
-    }
-    let endIndex = str.length;
-    switch (typeof chars) {
-        case 'string': {
-            if (chars.length !== 1) {
-                throw new Error(`The 'chars' parameter should be a single character string.`);
-            }
-            while (endIndex > 0 && str[endIndex - 1] === chars) {
-                endIndex--;
-            }
-            break;
-        }
-        case 'object': {
-            while (endIndex > 0 && chars.includes(str[endIndex - 1])) {
-                endIndex--;
-            }
-        }
-    }
-    return str.substring(0, endIndex);
-}

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

@@ -1,36 +0,0 @@
-/**
- * Removes leading whitespace or specified characters from a string.
- *
- * If `chars` is a string, it should be a single character. To trim a string with multiple characters,
- * provide an array instead.
- *
- * @param {string} str - The string from which leading characters will be trimmed.
- * @param {string | string[]} chars - The character(s) to remove from the start of the string.
- * @returns {string} - The resulting string after the specified leading character has been removed.
- *
- * @example
- * const trimmedStr1 = trimStart('---hello', '-') // returns 'hello'
- * const trimmedStr2 = trimStart('000123', '0') // returns '123'
- * const trimmedStr3 = trimStart('abcabcabc', 'a') // returns 'bcabcabc'
- * const trimmedStr4 = trimStart('xxxtrimmed', 'x') // returns 'trimmed'
- */
-export function trimStart(str, chars) {
-    if (chars === undefined) {
-        return str.trimStart();
-    }
-    let startIndex = 0;
-    switch (typeof chars) {
-        case 'string': {
-            while (startIndex < str.length && str[startIndex] === chars) {
-                startIndex++;
-            }
-            break;
-        }
-        case 'object': {
-            while (startIndex < str.length && chars.includes(str[startIndex])) {
-                startIndex++;
-            }
-        }
-    }
-    return str.substring(startIndex);
-}

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

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

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

@@ -1,26 +0,0 @@
-import { words as getWords } from './words.js';
-/**
- * Converts a string to upper case.
- *
- * Upper case is the naming convention in which each word is written in uppercase and separated by an space ( ) character.
- *
- * @param {string} str - The string that is to be changed to upper case.
- * @returns {string} - The converted string to upper case.
- *
- * @example
- * const convertedStr1 = upperCase('camelCase') // returns 'CAMEL CASE'
- * const convertedStr2 = upperCase('some whitespace') // returns 'SOME WHITESPACE'
- * const convertedStr3 = upperCase('hyphen-text') // returns 'HYPHEN TEXT'
- * const convertedStr4 = upperCase('HTTPRequest') // returns 'HTTP REQUEST'
- */
-export function upperCase(str) {
-    const words = getWords(str);
-    let result = '';
-    for (let i = 0; i < words.length; i++) {
-        result += words[i].toUpperCase();
-        if (i < words.length - 1) {
-            result += ' ';
-        }
-    }
-    return result;
-}

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

@@ -1,14 +0,0 @@
-/**
- * Converts the first character of string to upper case.
- *
- * @param {string} str - The string that is to be changed
- * @returns {string} - The converted string.
- *
- * @example
- * const convertedStr1 = upperFirst('fred') // returns 'Fred'
- * const convertedStr2 = upperFirst('Fred') // returns 'Fred'
- * const convertedStr3 = upperFirst('FRED') // returns 'FRED'
- */
-export function upperFirst(str) {
-    return str.substring(0, 1).toUpperCase() + str.substring(1);
-}

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

@@ -1,38 +0,0 @@
-/**
- * Regular expression pattern to split strings into words for various case conversions
- *
- * This pattern matches sequences of characters in a string, considering the following cases:
- * - Sequences of two or more uppercase letters followed by an uppercase letter and lowercase letters or digits (for acronyms)
- * - Sequences of one uppercase letter optionally followed by lowercase letters and digits
- * - Single uppercase letters
- * - Sequences of digits
- * - Emojis and other Unicode characters
- *
- * The resulting match can be used to convert camelCase, snake_case, kebab-case, and other mixed formats into
- * a consistent format like snake case. It also supports emojis and other Unicode characters.
- *
- * @example
- * const matches = 'camelCaseHTTPRequest🚀'.match(CASE_SPLIT_PATTERN);
- * // matches: ['camel', 'Case', 'HTTP', 'Request', '🚀']
- */
-export const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu;
-/**
- * Splits `string` into an array of its words, treating spaces and punctuation marks as separators.
- *
- * @param {string} str The string to inspect.
- * @param {RegExp | string} [pattern] The pattern to match words.
- * @returns {string[]} Returns the words of `string`.
- *
- * @example
- * words('fred, barney, & pebbles');
- * // => ['fred', 'barney', 'pebbles']
- *
- * words('camelCaseHTTPRequest🚀');
- * // => ['camel', 'Case', 'HTTP', 'Request', '🚀']
- *
- * words('Lunedì 18 Set')
- * // => ['Lunedì', '18', 'Set']
- */
-export function words(str) {
-    return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/util/attempt.js

@@ -1,47 +0,0 @@
-/**
- * Attempt to execute a function and return the result or error.
- * Returns a tuple where:
- * - On success: [null, Result] - First element is null, second is the result
- * - On error: [Error, null] - First element is the caught error, second is null
- *
- * @template {unknown} T - The type of the result of the function.
- * @template {unknown} E - The type of the error that can be thrown by the function.
- * @param {() => T} func - The function to execute.
- * @returns {[null, T] | [E, null]} A tuple containing either [null, result] or [error, null].
- *
- * @example
- * // Successful execution
- * const [error, result] = attempt(() => 42);
- * // [null, 42]
- *
- * // Failed execution
- * const [error, result] = attempt(() => {
- *   throw new Error('Something went wrong');
- * });
- * // [Error, null]
- *
- * // With type parameter
- * const [error, names] = attempt<string[]>(() => ['Alice', 'Bob']);
- * // [null, ['Alice', 'Bob']]
- *
- * @note
- * Important: This function is not suitable for async functions (functions that return a `Promise`).
- * When passing an async function, it will return `[null, Promise<Result>]`, but won't catch any
- * errors if the Promise is rejected later.
- *
- * For handling async functions, use the `attemptAsync` function instead:
- * ```
- * const [error, data] = await attemptAsync(async () => {
- *   const response = await fetch('https://api.example.com/data');
- *   return response.json();
- * });
- * ```
- */
-export function attempt(func) {
-    try {
-        return [null, func()];
-    }
-    catch (error) {
-        return [error, null];
-    }
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/util/attemptAsync.js

@@ -1,41 +0,0 @@
-/**
- * Attempt to execute an async function and return the result or error.
- * Returns a Promise that resolves to a tuple where:
- * - On success: [null, Result] - First element is null, second is the result
- * - On error: [Error, null] - First element is the caught error, second is null
- *
- * @template {unknown} T - The type of the result of the async function.
- * @template {unknown} E - The type of the error that can be thrown by the async function.
- * @param {() => Promise<T>} func - The async function to execute.
- * @returns {Promise<[null, T] | [E, null]>} A Promise that resolves to a tuple containing either [null, result] or [error, null].
- *
- * @example
- * // Successful execution
- * const [error, data] = await attemptAsync(async () => {
- *   const response = await fetch('https://api.example.com/data');
- *   return response.json();
- * });
- * // If successful: [null, { ... data ... }]
- *
- * // Failed execution
- * const [error, data] = await attemptAsync(async () => {
- *   throw new Error('Network error');
- * });
- * // [Error, null]
- *
- * // With type parameter
- * const [error, users] = await attemptAsync<User[]>(async () => {
- *   const response = await fetch('https://api.example.com/users');
- *   return response.json();
- * });
- * // users is typed as User[]
- */
-export async function attemptAsync(func) {
-    try {
-        const result = await func();
-        return [null, result];
-    }
-    catch (error) {
-        return [error, null];
-    }
-}

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

@@ -1,4 +0,0 @@
-export { attempt } from './attempt.js';
-export { attemptAsync } from './attemptAsync.js';
-export { invariant } from './invariant.js';
-export { invariant as assert } from './invariant.js';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/util/invariant.js

@@ -1,33 +0,0 @@
-/**
- * Asserts that a given condition is true. If the condition is false, an error is thrown with the provided message.
- *
- * @param {unknown} condition - The condition to evaluate.
- * @param {string | Error} [message] - The error message to throw if the condition is false.
- * @returns {void} Returns void if the condition is true.
- * @throws {Error} Throws an error if the condition is false.
- *
- * @example
- * // This call will succeed without any errors
- * invariant(true, 'This should not throw');
- *
- * // This call will fail and throw an error with the message 'This should throw'
- * invariant(false, 'This should throw');
- *
- * // Example of using invariant with a condition
- * invariant(condition, 'Expected condition is false');
- *
- * // Ensure that the value is neither null nor undefined
- * invariant(value !== null && value !== undefined, 'Value should not be null or undefined');
- *
- * // Example of using invariant to check if a number is positive
- * invariant(number > 0, 'Number must be positive');
- */
-export function invariant(condition, message) {
-    if (condition) {
-        return;
-    }
-    if (typeof message === 'string') {
-        throw new Error(message);
-    }
-    throw message;
-}