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

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

@@ -1,16 +0,0 @@
-/**
- * Checks if `value` is a Date object.
- *
- * @param {unknown} value The value to check.
- * @returns {value is Date} Returns `true` if `value` is a Date object, `false` otherwise.
- *
- * @example
- * const value1 = new Date();
- * const value2 = '2024-01-01';
- *
- * console.log(isDate(value1)); // true
- * console.log(isDate(value2)); // false
- */
-export function isDate(value) {
-    return value instanceof Date;
-}

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

@@ -1,19 +0,0 @@
-import { isEqualWith } from './isEqualWith.js';
-import { noop } from '../function/noop.js';
-/**
- * Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.
- *
- * @param {unknown} a - The first value to compare.
- * @param {unknown} b - The second value to compare.
- * @returns {boolean} `true` if the values are equal, otherwise `false`.
- *
- * @example
- * isEqual(1, 1); // true
- * isEqual({ a: 1 }, { a: 1 }); // true
- * isEqual(/abc/g, /abc/g); // true
- * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
- * isEqual([1, 2, 3], [1, 2, 3]); // true
- */
-export function isEqual(a, b) {
-    return isEqualWith(a, b, noop);
-}

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

@@ -1,218 +0,0 @@
-import { isPlainObject } from './isPlainObject.js';
-import { getSymbols } from '../compat/_internal/getSymbols.js';
-import { getTag } from '../compat/_internal/getTag.js';
-import { argumentsTag, arrayBufferTag, arrayTag, bigInt64ArrayTag, bigUint64ArrayTag, booleanTag, dataViewTag, dateTag, errorTag, float32ArrayTag, float64ArrayTag, functionTag, int8ArrayTag, int16ArrayTag, int32ArrayTag, mapTag, numberTag, objectTag, regexpTag, setTag, stringTag, symbolTag, uint8ArrayTag, uint8ClampedArrayTag, uint16ArrayTag, uint32ArrayTag, } from '../compat/_internal/tags.js';
-import { eq } from '../compat/util/eq.js';
-/**
- * Compares two values for equality using a custom comparison function.
- *
- * The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.
- *
- * This function also uses the custom equality function to compare values inside objects,
- * arrays, maps, sets, and other complex structures, ensuring a deep comparison.
- *
- * This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.
- *
- * The custom comparison function can take up to six parameters:
- * - `x`: The value from the first object `a`.
- * - `y`: The value from the second object `b`.
- * - `property`: The property key used to get `x` and `y`.
- * - `xParent`: The parent of the first value `x`.
- * - `yParent`: The parent of the second value `y`.
- * - `stack`: An internal stack (Map) to handle circular references.
- *
- * @param {unknown} a - The first value to compare.
- * @param {unknown} b - The second value to compare.
- * @param {(x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map<any, any>) => boolean | void} areValuesEqual - A function to customize the comparison.
- *   If it returns a boolean, that result will be used. If it returns undefined,
- *   the default equality comparison will be used.
- * @returns {boolean} `true` if the values are equal according to the customizer, otherwise `false`.
- *
- * @example
- * const customizer = (a, b) => {
- *   if (typeof a === 'string' && typeof b === 'string') {
- *     return a.toLowerCase() === b.toLowerCase();
- *   }
- * };
- * isEqualWith('Hello', 'hello', customizer); // true
- * isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true
- * isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true
- */
-export function isEqualWith(a, b, areValuesEqual) {
-    return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
-}
-function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
-    const result = areValuesEqual(a, b, property, aParent, bParent, stack);
-    if (result !== undefined) {
-        return result;
-    }
-    if (typeof a === typeof b) {
-        switch (typeof a) {
-            case 'bigint':
-            case 'string':
-            case 'boolean':
-            case 'symbol':
-            case 'undefined': {
-                return a === b;
-            }
-            case 'number': {
-                return a === b || Object.is(a, b);
-            }
-            case 'function': {
-                return a === b;
-            }
-            case 'object': {
-                return areObjectsEqual(a, b, stack, areValuesEqual);
-            }
-        }
-    }
-    return areObjectsEqual(a, b, stack, areValuesEqual);
-}
-function areObjectsEqual(a, b, stack, areValuesEqual) {
-    if (Object.is(a, b)) {
-        return true;
-    }
-    let aTag = getTag(a);
-    let bTag = getTag(b);
-    if (aTag === argumentsTag) {
-        aTag = objectTag;
-    }
-    if (bTag === argumentsTag) {
-        bTag = objectTag;
-    }
-    if (aTag !== bTag) {
-        return false;
-    }
-    switch (aTag) {
-        case stringTag:
-            return a.toString() === b.toString();
-        case numberTag: {
-            const x = a.valueOf();
-            const y = b.valueOf();
-            return eq(x, y);
-        }
-        case booleanTag:
-        case dateTag:
-        case symbolTag:
-            return Object.is(a.valueOf(), b.valueOf());
-        case regexpTag: {
-            return a.source === b.source && a.flags === b.flags;
-        }
-        case functionTag: {
-            return a === b;
-        }
-    }
-    stack = stack ?? new Map();
-    const aStack = stack.get(a);
-    const bStack = stack.get(b);
-    if (aStack != null && bStack != null) {
-        return aStack === b;
-    }
-    stack.set(a, b);
-    stack.set(b, a);
-    try {
-        switch (aTag) {
-            case mapTag: {
-                if (a.size !== b.size) {
-                    return false;
-                }
-                for (const [key, value] of a.entries()) {
-                    if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            case setTag: {
-                if (a.size !== b.size) {
-                    return false;
-                }
-                const aValues = Array.from(a.values());
-                const bValues = Array.from(b.values());
-                for (let i = 0; i < aValues.length; i++) {
-                    const aValue = aValues[i];
-                    const index = bValues.findIndex(bValue => {
-                        return isEqualWithImpl(aValue, bValue, undefined, a, b, stack, areValuesEqual);
-                    });
-                    if (index === -1) {
-                        return false;
-                    }
-                    bValues.splice(index, 1);
-                }
-                return true;
-            }
-            case arrayTag:
-            case uint8ArrayTag:
-            case uint8ClampedArrayTag:
-            case uint16ArrayTag:
-            case uint32ArrayTag:
-            case bigUint64ArrayTag:
-            case int8ArrayTag:
-            case int16ArrayTag:
-            case int32ArrayTag:
-            case bigInt64ArrayTag:
-            case float32ArrayTag:
-            case float64ArrayTag: {
-                // Buffers are also treated as [object Uint8Array]s.
-                if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
-                    return false;
-                }
-                if (a.length !== b.length) {
-                    return false;
-                }
-                for (let i = 0; i < a.length; i++) {
-                    if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            case arrayBufferTag: {
-                if (a.byteLength !== b.byteLength) {
-                    return false;
-                }
-                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-            }
-            case dataViewTag: {
-                if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
-                    return false;
-                }
-                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-            }
-            case errorTag: {
-                return a.name === b.name && a.message === b.message;
-            }
-            case objectTag: {
-                const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) ||
-                    (isPlainObject(a) && isPlainObject(b));
-                if (!areEqualInstances) {
-                    return false;
-                }
-                const aKeys = [...Object.keys(a), ...getSymbols(a)];
-                const bKeys = [...Object.keys(b), ...getSymbols(b)];
-                if (aKeys.length !== bKeys.length) {
-                    return false;
-                }
-                for (let i = 0; i < aKeys.length; i++) {
-                    const propKey = aKeys[i];
-                    const aProp = a[propKey];
-                    if (!Object.hasOwn(b, propKey)) {
-                        return false;
-                    }
-                    const bProp = b[propKey];
-                    if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            default: {
-                return false;
-            }
-        }
-    }
-    finally {
-        stack.delete(a);
-        stack.delete(b);
-    }
-}

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

@@ -1,16 +0,0 @@
-/**
- * Checks if `value` is an Error object.
- *
- * @param {unknown} value The value to check.
- * @returns {value is Error} Returns `true` if `value` is an Error object, `false` otherwise.
- *
- * @example
- * ```typescript
- * console.log(isError(new Error())); // true
- * console.log(isError('Error')); // false
- * console.log(isError({ name: 'Error', message: '' })); // false
- * ```
- */
-export function isError(value) {
-    return value instanceof Error;
-}

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

@@ -1,26 +0,0 @@
-import { isBlob } from './isBlob.js';
-/**
- * Checks if the given value is a File.
- *
- * This function tests whether the provided value is an instance of `File`.
- * It returns `true` if the value is an instance of `File`, and `false` otherwise.
- *
- * @param {unknown} x - The value to test if it is a File.
- * @returns {x is File} True if the value is a File, false otherwise.
- *
- * @example
- * const value1 = new File(["content"], "example.txt");
- * const value2 = {};
- * const value3 = new Blob(["content"], { type: "text/plain" });
- *
- * console.log(isFile(value1)); // true
- * console.log(isFile(value2)); // false
- * console.log(isFile(value3)); // false
- */
-export function isFile(x) {
-    // Return false if File is not supported in the environment
-    if (typeof File === 'undefined') {
-        return false;
-    }
-    return isBlob(x) && x instanceof File;
-}

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

@@ -1,16 +0,0 @@
-/**
- * Checks if `value` is a function.
- *
- * @param {unknown} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a function, else `false`.
- *
- * @example
- * isFunction(Array.prototype.slice); // true
- * isFunction(async function () {}); // true
- * isFunction(function* () {}); // true
- * isFunction(Proxy); // true
- * isFunction(Int8Array); // true
- */
-export function isFunction(value) {
-    return typeof value === 'function';
-}

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

@@ -1,40 +0,0 @@
-/**
- * Checks if a given value is a valid JSON string.
- *
- * A valid JSON string is one that can be successfully parsed using `JSON.parse()`. According to JSON
- * specifications, valid JSON can represent:
- * - Objects (with string keys and valid JSON values)
- * - Arrays (containing valid JSON values)
- * - Strings
- * - Numbers
- * - Booleans
- * - null
- *
- * String values like `"null"`, `"true"`, `"false"`, and numeric strings (e.g., `"42"`) are considered
- * valid JSON and will return true.
- *
- * This function serves as a type guard in TypeScript, narrowing the type of the argument to `string`.
- *
- * @param {unknown} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a valid JSON string, else `false`.
- *
- * @example
- * isJSON('{"name":"John","age":30}'); // true
- * isJSON('[1,2,3]'); // true
- * isJSON('true'); // true
- * isJSON('invalid json'); // false
- * isJSON({ name: 'John' }); // false (not a string)
- * isJSON(null); // false (not a string)
- */
-export function isJSON(value) {
-    if (typeof value !== 'string') {
-        return false;
-    }
-    try {
-        JSON.parse(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -1,94 +0,0 @@
-/**
- * The functions isJSONValue, isJSONArray, and isJSONObject are grouped in this file
- * to prevent any circular dependency issues.
- */
-import { isPlainObject } from './isPlainObject.js';
-/**
- * Checks if a given value is a valid JSON value.
- *
- * A valid JSON value can be:
- * - null
- * - a JSON object (an object with string keys and valid JSON values)
- * - a JSON array (an array of valid JSON values)
- * - a string
- * - a number
- * - a boolean
- *
- * @param {unknown} value - The value to check.
- * @returns {boolean} - True if the value is a valid JSON value, otherwise false.
- *
- * @example
- * console.log(isJSONValue(null)); // true
- * console.log(isJSONValue({ key: "value" })); // true
- * console.log(isJSONValue([1, 2, 3])); // true
- * console.log(isJSONValue("Hello")); // true
- * console.log(isJSONValue(42)); // true
- * console.log(isJSONValue(true)); // true
- * console.log(isJSONValue(undefined)); // false
- * console.log(isJSONValue(() => {})); // false
- */
-export function isJSONValue(value) {
-    switch (typeof value) {
-        case 'object': {
-            return value === null || isJSONArray(value) || isJSONObject(value);
-        }
-        case 'string':
-        case 'number':
-        case 'boolean': {
-            return true;
-        }
-        default: {
-            return false;
-        }
-    }
-}
-/**
- * Checks if a given value is a valid JSON array.
- *
- * A valid JSON array is defined as an array where all items are valid JSON values.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is any[]} - True if the value is a valid JSON array, otherwise false.
- *
- * @example
- * console.log(isJSONArray([1, 2, 3])); // true
- * console.log(isJSONArray(["string", null, true])); // true
- * console.log(isJSONArray([1, 2, () => {}])); // false
- * console.log(isJSONArray("not an array")); // false
- */
-export function isJSONArray(value) {
-    if (!Array.isArray(value)) {
-        return false;
-    }
-    return value.every(item => isJSONValue(item));
-}
-/**
- * Checks if a value is a JSON object.
- *
- * A valid JSON object is defined as an object with string keys and valid JSON values.
- *
- * @param {unknown} obj The value to check.
- * @returns {obj is Record<string, any>} True if `obj` is a JSON object, false otherwise.
- *
- * @example
- * isJSONObject({ nested: { boolean: true, array: [1, 2, 3], string: 'test', null: null } }); // true
- * isJSONObject({ regexp: /test/ }); // false
- * isJSONObject(123); // false
- */
-export function isJSONObject(obj) {
-    if (!isPlainObject(obj)) {
-        return false;
-    }
-    const keys = Reflect.ownKeys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        if (typeof key !== 'string') {
-            return false;
-        }
-        if (!isJSONValue(value)) {
-            return false;
-        }
-    }
-    return true;
-}

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

@@ -1,24 +0,0 @@
-/**
- * Checks if a given value is a valid length.
- *
- * A valid length is of type `number`, is a non-negative integer, and is less than or equal to
- * JavaScript's maximum safe integer (`Number.MAX_SAFE_INTEGER`).
- * It returns `true` if the value is a valid length, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the
- * argument to a valid length (`number`).
- *
- * @param {unknown} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
- *
- * @example
- * isLength(0); // true
- * isLength(42); // true
- * isLength(-1); // false
- * isLength(1.5); // false
- * isLength(Number.MAX_SAFE_INTEGER); // true
- * isLength(Number.MAX_SAFE_INTEGER + 1); // false
- */
-export function isLength(value) {
-    return Number.isSafeInteger(value) && value >= 0;
-}

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

@@ -1,20 +0,0 @@
-/**
- * Checks if a given value is `Map`.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Map`.
- *
- * @param {unknown} value The value to check if it is a `Map`.
- * @returns {value is Map<any, any>} Returns `true` if `value` is a `Map`, else `false`.
- *
- * @example
- * const value1 = new Map();
- * const value2 = new Set();
- * const value3 = new WeakMap();
- *
- * console.log(isMap(value1)); // true
- * console.log(isMap(value2)); // false
- * console.log(isMap(value3)); // false
- */
-export function isMap(value) {
-    return value instanceof Map;
-}

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

@@ -1,22 +0,0 @@
-/**
- * Checks if a given value is null or undefined.
- *
- * This function tests whether the provided value is either `null` or `undefined`.
- * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
- *
- * @param {unknown} x - The value to test for null or undefined.
- * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.
- *
- * @example
- * const value1 = null;
- * const value2 = undefined;
- * const value3 = 42;
- * const result1 = isNil(value1); // true
- * const result2 = isNil(value2); // true
- * const result3 = isNil(value3); // false
- */
-export function isNil(x) {
-    return x == null;
-}

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

@@ -1,17 +0,0 @@
-/**
- * Checks if the current environment is Node.js.
- *
- * This function checks for the existence of the `process.versions.node` property,
- * which only exists in Node.js environments.
- *
- * @returns {boolean} `true` if the current environment is Node.js, otherwise `false`.
- *
- * @example
- * if (isNode()) {
- *   console.log('This is running in Node.js');
- *   const fs = import('node:fs');
- * }
- */
-export function isNode() {
-    return typeof process !== 'undefined' && process?.versions?.node != null;
-}

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

@@ -1,19 +0,0 @@
-/**
- * Checks if the given value is not null nor undefined.
- *
- * The main use of this function is to be used with TypeScript as a type predicate.
- *
- * @template T - The type of value.
- * @param {T | null | undefined} x - The value to test if it is not null nor undefined.
- * @returns {x is T} True if the value is not null nor undefined, false otherwise.
- *
- * @example
- * // Here the type of `arr` is (number | undefined)[]
- * const arr = [1, undefined, 3];
- * // Here the type of `result` is number[]
- * const result = arr.filter(isNotNil);
- * // result will be [1, 3]
- */
-export function isNotNil(x) {
-    return x != null;
-}

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

@@ -1,23 +0,0 @@
-/**
- * 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 function isNull(x) {
-    return x === null;
-}

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

@@ -1,56 +0,0 @@
-/**
- * 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 function isPlainObject(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const proto = Object.getPrototypeOf(value);
-    const hasObjectPrototype = proto === null ||
-        proto === Object.prototype ||
-        // Required to support node:vm.runInNewContext({})
-        Object.getPrototypeOf(proto) === null;
-    if (!hasObjectPrototype) {
-        return false;
-    }
-    return Object.prototype.toString.call(value) === '[object Object]';
-}

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

@@ -1,31 +0,0 @@
-/**
- * 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 function isPrimitive(value) {
-    return value == null || (typeof value !== 'object' && typeof value !== 'function');
-}