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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * 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;
+}

package/esm/federation/mod.js

@@ -3,6 +3,7 @@
  *
  * @module
  */
+import "../_dnt.polyfills.js";
 export { createFederationBuilder } from "./builder.js";
 export * from "./callback.js";
 export * from "./collection.js";

package/esm/mod.js

@@ -42,6 +42,7 @@
  *
  * @module
  */
+import "./_dnt.polyfills.js";
 export * from "./compat/mod.js";
 export * from "./federation/mod.js";
 export * from "./nodeinfo/mod.js";

package/esm/nodeinfo/mod.js

@@ -5,6 +5,7 @@
  * @module
  * @since 0.2.0
  */
+import "../_dnt.polyfills.js";
 export { format as formatSemVer, parse as parseSemVer, } from "../deps/jsr.io/@std/semver/1.0.5/mod.js";
 export { getNodeInfo, parseNodeInfo, } from "./client.js";
 export * from "./types.js";

package/esm/runtime/mod.js

@@ -4,6 +4,7 @@
  *
  * @module
  */
+import "../_dnt.polyfills.js";
 export * from "./docloader.js";
 export * from "./key.js";
 export * from "./langstr.js";

package/esm/sig/mod.js

@@ -3,6 +3,7 @@
  *
  * @module
  */
+import "../_dnt.polyfills.js";
 export { signRequest, verifyRequest, } from "./http.js";
 export { exportJwk, fetchKey, generateCryptoKeyPair, importJwk, } from "./key.js";
 export { attachSignature, createSignature, detachSignature, signJsonLd, verifyJsonLd, verifySignature, } from "./ld.js";

package/esm/vocab/lookup.js

@@ -1,7 +1,7 @@
 import * as dntShim from "../_dnt.shims.js";
+import { delay } from "../deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/index.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
-import { delay } from "../deps/jsr.io/@std/async/1.0.13/delay.js";
 import metadata from "../deno.js";
 import { getDocumentLoader, } from "../runtime/docloader.js";
 import { lookupWebFinger } from "../webfinger/lookup.js";

package/esm/vocab/mod.js

@@ -49,6 +49,7 @@
  *
  * @module
  */
+import "../_dnt.polyfills.js";
 export * from "./actor.js";
 export * from "./constants.js";
 export * from "./lookup.js";