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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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