@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/predicate/isSet.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * 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, '\\$&');
+}

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

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

@@ -0,0 +1,19 @@
+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('-');
+}