@fedify/fedify 1.6.0-dev.809 → 1.6.0-dev.811

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/toMerged.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Merges the properties of the source object into a deep clone of the target object.
+ * Unlike `merge`, This function does not modify the original target object.
+ *
+ * This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+ *
+ * - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+ * - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+ *
+ * Note that this function does not mutate the target object.
+ *
+ * @param {T} target - The target object to be cloned and merged into. This object is not modified directly.
+ * @param {S} source - The source object whose properties will be merged into the cloned target object.
+ * @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object.
+ *
+ * @template T - Type of the target object.
+ * @template S - Type of the source object.
+ *
+ * @example
+ * const target = { a: 1, b: { x: 1, y: 2 } };
+ * const source = { b: { y: 3, z: 4 }, c: 5 };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+ *
+ * @example
+ * const target = { a: [1, 2], b: { x: 1 } };
+ * const source = { a: [3], b: { y: 2 } };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+ *
+ * @example
+ * const target = { a: null };
+ * const source = { a: [1, 2, 3] };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [1, 2, 3] }
+ */
+export declare function toMerged<T extends Record<PropertyKey, any>, S extends Record<PropertyKey, any>>(target: T, source: S): T & S;
+//# sourceMappingURL=toMerged.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/toMerged.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMerged.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/toMerged.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAC7F,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,CAAC,GACR,CAAC,GAAG,CAAC,CAEP"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/toSnakeCaseKeys.d.ts

@@ -0,0 +1,53 @@
+type SnakeCase<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
+export type ToSnakeCaseKeys<T> = T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? {
+    [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]>;
+} : T;
+/**
+ * Creates a new object composed of the properties with keys converted to snake_case.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to snake_case format.
+ *
+ * @template T - The type of object.
+ * @param {T} obj - The object to convert keys from.
+ * @returns {ToSnakeCaseKeys<T>} A new object with all keys converted to snake_case.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toSnakeCaseKeys(obj);
+ * // result will be { user_id: 1, first_name: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toSnakeCaseKeys(arr);
+ * // arrResult will be [{ user_id: 1, first_name: 'John' }, { user_id: 2, first_name: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toSnakeCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   user_data: {
+ * //     user_id: 1,
+ * //     user_address: {
+ * //       street_name: 'Main St',
+ * //       zip_code: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+export declare function toSnakeCaseKeys<T>(obj: T): ToSnakeCaseKeys<T>;
+export {};
+//# sourceMappingURL=toSnakeCaseKeys.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/toSnakeCaseKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeCaseKeys.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/toSnakeCaseKeys.ts"],"names":[],"mappings":"AAIA,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,GACjE,EAAE,SAAS,YAAY,CAAC,EAAE,CAAC,GACzB,GAAG,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE,GAClC,GAAG,SAAS,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,GACnD,SAAS,CAAC,CAAC,CAAC,CAAC;AAEjB,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,EAAE,GAC5C,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC3B;KAAG,CAAC,IAAI,MAAM,CAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GAClE,CAAC,CAAC;AAER;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAqB7D"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/index.d.ts

@@ -0,0 +1,31 @@
+export { isArrayBuffer } from './isArrayBuffer.js';
+export { isBlob } from './isBlob.js';
+export { isBoolean } from './isBoolean.js';
+export { isBrowser } from './isBrowser.js';
+export { isBuffer } from './isBuffer.js';
+export { isDate } from './isDate.js';
+export { isEqual } from './isEqual.js';
+export { isEqualWith } from './isEqualWith.js';
+export { isError } from './isError.js';
+export { isFile } from './isFile.js';
+export { isFunction } from './isFunction.js';
+export { isJSON } from './isJSON.js';
+export { isJSONArray, isJSONObject, isJSONValue } from './isJSONValue.js';
+export { isLength } from './isLength.js';
+export { isMap } from './isMap.js';
+export { isNil } from './isNil.js';
+export { isNode } from './isNode.js';
+export { isNotNil } from './isNotNil.js';
+export { isNull } from './isNull.js';
+export { isPlainObject } from './isPlainObject.js';
+export { isPrimitive } from './isPrimitive.js';
+export { isPromise } from './isPromise.js';
+export { isRegExp } from './isRegExp.js';
+export { isSet } from './isSet.js';
+export { isString } from './isString.js';
+export { isSymbol } from './isSymbol.js';
+export { isTypedArray } from './isTypedArray.js';
+export { isUndefined } from './isUndefined.js';
+export { isWeakMap } from './isWeakMap.js';
+export { isWeakSet } from './isWeakSet.js';
+//# sourceMappingURL=index.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isArrayBuffer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if a given value is `ArrayBuffer`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `ArrayBuffer`.
+ *
+ * @param {unknown} value The value to check if it is a `ArrayBuffer`.
+ * @returns {value is ArrayBuffer} Returns `true` if `value` is a `ArrayBuffer`, else `false`.
+ *
+ * @example
+ * const value1 = new ArrayBuffer();
+ * const value2 = new Array();
+ * const value3 = new Map();
+ *
+ * console.log(isArrayBuffer(value1)); // true
+ * console.log(isArrayBuffer(value2)); // false
+ * console.log(isArrayBuffer(value3)); // false
+ */
+export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
+//# sourceMappingURL=isArrayBuffer.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isArrayBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArrayBuffer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isArrayBuffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBlob.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if the given value is a Blob.
+ *
+ * This function tests whether the provided value is an instance of `Blob`.
+ * It returns `true` if the value is an instance of `Blob`, and `false` otherwise.
+ *
+ * @param {unknown} x - The value to test if it is a Blob.
+ * @returns {x is Blob} True if the value is a Blob, false otherwise.
+ *
+ * @example
+ * const value1 = new Blob();
+ * const value2 = {};
+ *
+ * console.log(isBlob(value1)); // true
+ * console.log(isBlob(value2)); // false
+ */
+export declare function isBlob(x: unknown): x is Blob;
+//# sourceMappingURL=isBlob.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBlob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBlob.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBlob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,IAAI,CAO5C"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBoolean.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Checks if the given value is boolean.
+ *
+ * This function tests whether the provided value is strictly `boolean`.
+ * It returns `true` if the value is `boolean`, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `boolean`.
+ *
+ * @param {unknown} x - The Value to test if it is boolean.
+ * @returns {x is boolean} True if the value is boolean, false otherwise.
+ *
+ * @example
+ *
+ * const value1 = true;
+ * const value2 = 0;
+ * const value3 = 'abc';
+ *
+ * console.log(isBoolean(value1)); // true
+ * console.log(isBoolean(value2)); // false
+ * console.log(isBoolean(value3)); // false
+ *
+ */
+export declare function isBoolean(x: unknown): x is boolean;
+//# sourceMappingURL=isBoolean.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBoolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBoolean.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBoolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,OAAO,CAElD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBrowser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if the current environment is a browser.
+ *
+ * This function checks for the existence of the `window.document` property,
+ * which only exists in browser environments.
+ *
+ * @returns {boolean} `true` if the current environment is a browser, otherwise `false`.
+ *
+ * @example
+ * if (isBrowser()) {
+ *   console.log("This is running in a browser");
+ *   document.getElementById('app').innerHTML = 'Hello World';
+ * }
+ */
+export declare function isBrowser(): boolean;
+//# sourceMappingURL=isBrowser.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBrowser.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBrowser.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAEnC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBuffer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if the given value is a Buffer instance.
+ *
+ * This function tests whether the provided value is an instance of Buffer.
+ * It returns `true` if the value is a Buffer, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
+ *
+ * @param {unknown} x - The value to check if it is a Buffer.
+ * @returns {boolean} Returns `true` if `x` is a Buffer, else `false`.
+ *
+ * @example
+ * const buffer = Buffer.from("test");
+ * console.log(isBuffer(buffer)); // true
+ *
+ * const notBuffer = "not a buffer";
+ * console.log(isBuffer(notBuffer)); // false
+ */
+export declare function isBuffer(x: unknown): boolean;
+//# sourceMappingURL=isBuffer.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBuffer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isBuffer.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAI5C"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isDate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare function isDate(value: unknown): value is Date;
+//# sourceMappingURL=isDate.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDate.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isDate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isEqual.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare function isEqual(a: any, b: any): boolean;
+//# sourceMappingURL=isEqual.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqual.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isEqual.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAE/C"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isEqualWith.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 declare function isEqualWith(a: any, b: any, areValuesEqual: (x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map<any, any>) => boolean | void): boolean;
+//# sourceMappingURL=isEqualWith.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isEqualWith.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqualWith.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isEqualWith.ts"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,GAAG,EACN,CAAC,EAAE,GAAG,EACN,cAAc,EAAE,CACd,CAAC,EAAE,GAAG,EACN,CAAC,EAAE,GAAG,EACN,QAAQ,CAAC,EAAE,WAAW,EACtB,OAAO,CAAC,EAAE,GAAG,EACb,OAAO,CAAC,EAAE,GAAG,EACb,KAAK,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,KAClB,OAAO,GAAG,IAAI,GAClB,OAAO,CAET"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare function isError(value: unknown): value is Error;
+//# sourceMappingURL=isError.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isError.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAEtD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isFile.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 declare function isFile(x: unknown): x is File;
+//# sourceMappingURL=isFile.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFile.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isFile.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,IAAI,CAO5C"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isFunction.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+//# sourceMappingURL=isFunction.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFunction.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isFunction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAEnF"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isJSON.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 declare function isJSON(value: unknown): value is string;
+//# sourceMappingURL=isJSON.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isJSON.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isJSON.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isJSON.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAWtD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isJSONValue.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 declare function isJSONValue(value: unknown): value is Record<string, any> | any[] | string | number | boolean | null;
+/**
+ * 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 declare function isJSONArray(value: unknown): value is any[];
+/**
+ * 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 declare function isJSONObject(obj: unknown): obj is Record<string, any>;
+//# sourceMappingURL=isJSONValue.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isJSONValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isJSONValue.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isJSONValue.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAcnH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,EAAE,CAM1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAqBrE"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isLength.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 declare function isLength(value: unknown): value is number;
+//# sourceMappingURL=isLength.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isLength.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isLength.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isLength.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isMap.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 declare function isMap(value: unknown): value is Map<any, any>;
+//# sourceMappingURL=isMap.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMap.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isMap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAE5D"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNil.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 declare function isNil(x: unknown): x is null | undefined;
+//# sourceMappingURL=isNil.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNil.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,IAAI,GAAG,SAAS,CAEvD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare function isNode(): boolean;
+//# sourceMappingURL=isNode.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNode.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNode.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,IAAI,OAAO,CAEhC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/predicate/isNotNil.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 declare function isNotNil<T>(x: T | null | undefined): x is T;
+//# sourceMappingURL=isNotNil.d.ts.map