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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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