@mdigitalcn/utils 2.0.0

package/dist/types/object/jsonParse.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Safely parses a JSON string.
+ *
+ * Returns the parsed value if the string is valid.
+ * If the input is empty, null, undefined, or invalid JSON, it returns the fallback value.
+ *
+ * @example
+ * jsonParse('{"a": 1}')          // { a: 1 }
+ * jsonParse('not json')          // "" (fallback)
+ * jsonParse('')                  // "" (fallback)
+ * jsonParse(null)                // "" (fallback)
+ * jsonParse('true')              // true
+ * jsonParse('{"a": 1}', null)    // { a: 1 }
+ * jsonParse('bad', [])           // []
+ *
+ * @param value - The string to parse.
+ * @param fallback - Value to return if parsing fails or value is empty (default is "").
+ * @returns The parsed value or the fallback.
+ */
+export declare function jsonParse<T = any>(value: string | null | undefined, fallback?: T): T;
+//# sourceMappingURL=jsonParse.d.ts.map

package/dist/types/object/jsonParse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonParse.d.ts","sourceRoot":"","sources":["../../../src/object/jsonParse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,QAAQ,GAAE,CAAsB,GAC/B,CAAC,CAUH"}

package/dist/types/object/mapKeys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a new object with the same values but transformed keys.
+ *
+ * @example
+ * mapKeys({ a: 1, b: 2 }, key => key.toUpperCase())
+ * // { A: 1, B: 2 }
+ *
+ * @example
+ * mapKeys({ name: 'Alice', age: 30 }, (key) => `user_${key}`)
+ * // { user_name: 'Alice', user_age: 30 }
+ *
+ * @param obj - Source object
+ * @param fn - Function to transform each key (receives key and value)
+ * @returns New object with transformed keys
+ */
+export declare function mapKeys<T extends Record<string, any>>(obj: T, fn: (key: string, value: T[keyof T]) => string): Record<string, T[keyof T]>;
+//# sourceMappingURL=mapKeys.d.ts.map

package/dist/types/object/mapKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapKeys.d.ts","sourceRoot":"","sources":["../../../src/object/mapKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnD,GAAG,EAAE,CAAC,EACN,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,MAAM,GAC7C,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAQ5B"}

package/dist/types/object/mapValues.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a new object with the same keys but transformed values.
+ *
+ * @example
+ * mapValues({ a: 1, b: 2, c: 3 }, value => value * 2)
+ * // { a: 2, b: 4, c: 6 }
+ *
+ * @example
+ * mapValues({ name: 'alice', city: 'nyc' }, value => value.toUpperCase())
+ * // { name: 'ALICE', city: 'NYC' }
+ *
+ * @param obj - Source object
+ * @param fn - Function to transform each value (receives value and key)
+ * @returns New object with transformed values
+ */
+export declare function mapValues<T extends Record<string, any>, U>(obj: T, fn: (value: T[keyof T], key: string) => U): Record<keyof T, U>;
+//# sourceMappingURL=mapValues.d.ts.map

package/dist/types/object/mapValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapValues.d.ts","sourceRoot":"","sources":["../../../src/object/mapValues.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,EACxD,GAAG,EAAE,CAAC,EACN,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GACxC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAQpB"}

package/dist/types/object/mergeDeep.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Merges two objects deeply, with the second object taking precedence.
+ * Handles circular references and preserves special object types (Date, RegExp, Map, Set).
+ *
+ * @example
+ * mergeDeep({ a: { b: 1 } }, { a: { c: 2 } }) // { a: { b: 1, c: 2 } }
+ *
+ * @example
+ * // Preserves Date objects
+ * mergeDeep(
+ *   { created: new Date('2020-01-01') },
+ *   { updated: new Date('2021-01-01') }
+ * ) // { created: Date(2020-01-01), updated: Date(2021-01-01) }
+ *
+ * @param obj1 - First object
+ * @param obj2 - Second object (takes precedence)
+ * @returns New deeply merged object
+ */
+export declare function mergeDeep<T extends object, U extends object>(obj1: T, obj2: U, seen?: WeakMap<any, any>): T & U;
+//# sourceMappingURL=mergeDeep.d.ts.map

package/dist/types/object/mergeDeep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeDeep.d.ts","sourceRoot":"","sources":["../../../src/object/mergeDeep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC1D,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,CAAC,EACP,IAAI,CAAC,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,GACvB,CAAC,GAAG,CAAC,CA8CP"}

package/dist/types/object/omit.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Creates a new object without the specified keys.
+ * Optimized: Only copies keys that aren't omitted (O(n) where n = kept keys, not all keys).
+ *
+ * @example
+ * omit({ a: 1, b: 2, c: 3 }, ['b']) // { a: 1, c: 3 }
+ *
+ * @param obj - Source object
+ * @param keys - Keys to omit
+ * @returns New object without omitted keys
+ */
+export declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+//# sourceMappingURL=omit.d.ts.map

package/dist/types/object/omit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.ts","sourceRoot":"","sources":["../../../src/object/omit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACtD,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,EAAE,GACR,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAWZ"}

package/dist/types/object/omitBy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a new object composed of properties that do NOT satisfy the predicate.
+ *
+ * @example
+ * omitBy({ a: 1, b: null, c: 3 }, value => value == null)
+ * // { a: 1, c: 3 }
+ *
+ * @example
+ * omitBy({ x: 0, y: 1, z: 2 }, value => value === 0)
+ * // { y: 1, z: 2 }
+ *
+ * @param obj - Source object
+ * @param predicate - Function to test each value (receives value and key)
+ * @returns New object without properties that pass the predicate
+ */
+export declare function omitBy<T extends Record<string, any>>(obj: T, predicate: (value: T[keyof T], key: string) => boolean): Partial<T>;
+//# sourceMappingURL=omitBy.d.ts.map

package/dist/types/object/omitBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omitBy.d.ts","sourceRoot":"","sources":["../../../src/object/omitBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAClD,GAAG,EAAE,CAAC,EACN,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,GACrD,OAAO,CAAC,CAAC,CAAC,CAQZ"}

package/dist/types/object/path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Safely retrieves a value at a given path in an object.
+ *
+ * @example
+ * path({ a: { b: 1 } }, ['a', 'b']) // 1
+ * path({ a: { b: 1 } }, ['a', 'c']) // undefined
+ *
+ * @param obj - Object to retrieve from
+ * @param pathArray - Array of keys representing the path
+ * @returns Value at path or undefined
+ */
+export declare function path<T>(obj: any, pathArray: string[]): T | undefined;
+//# sourceMappingURL=path.d.ts.map

package/dist/types/object/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/object/path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CASpE"}

package/dist/types/object/pathOr.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Safely retrieves a value at a given path in an object, with a default value.
+ *
+ * @example
+ * pathOr('default', { a: { b: 1 } }, ['a', 'b']) // 1
+ * pathOr('default', { a: { b: 1 } }, ['a', 'c']) // 'default'
+ *
+ * @param defaultValue - Default value if path doesn't exist
+ * @param obj - Object to retrieve from
+ * @param pathArray - Array of keys representing the path
+ * @returns Value at path or default value
+ */
+export declare function pathOr<T>(defaultValue: T, obj: any, pathArray: string[]): T;
+//# sourceMappingURL=pathOr.d.ts.map

package/dist/types/object/pathOr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathOr.d.ts","sourceRoot":"","sources":["../../../src/object/pathOr.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,CAG3E"}

package/dist/types/object/pick.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Creates a new object with only the specified keys.
+ * Optimized: Uses hasOwnProperty check instead of 'in' operator to avoid prototype chain lookups.
+ *
+ * @example
+ * pick({ a: 1, b: 2, c: 3 }, ['a', 'c']) // { a: 1, c: 3 }
+ *
+ * @param obj - Source object
+ * @param keys - Keys to pick
+ * @returns New object with only picked keys
+ */
+export declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+//# sourceMappingURL=pick.d.ts.map

package/dist/types/object/pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../src/object/pick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACtD,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,EAAE,GACR,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAQZ"}

package/dist/types/object/pickBy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a new object composed of properties that satisfy the predicate.
+ *
+ * @example
+ * pickBy({ a: 1, b: null, c: 3, d: undefined }, value => value != null)
+ * // { a: 1, c: 3 }
+ *
+ * @example
+ * pickBy({ x: 0, y: 1, z: 2 }, value => value > 0)
+ * // { y: 1, z: 2 }
+ *
+ * @param obj - Source object
+ * @param predicate - Function to test each value (receives value and key)
+ * @returns New object with only properties that pass the predicate
+ */
+export declare function pickBy<T extends Record<string, any>>(obj: T, predicate: (value: T[keyof T], key: string) => boolean): Partial<T>;
+//# sourceMappingURL=pickBy.d.ts.map

package/dist/types/object/pickBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickBy.d.ts","sourceRoot":"","sources":["../../../src/object/pickBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAClD,GAAG,EAAE,CAAC,EACN,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,GACrD,OAAO,CAAC,CAAC,CAAC,CAQZ"}

package/dist/types/object/prop.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Returns a function that retrieves a given property from an object.
+ * Curried for composition (Ramda-style).
+ *
+ * This is one of the most commonly used functions in functional programming
+ * for safely accessing object properties in a composable way.
+ *
+ * @example
+ * const getName = prop('name')
+ * getName({ name: 'Alice', age: 30 }) // 'Alice'
+ *
+ * @example
+ * // Use in composition
+ * const users = [{ name: 'Alice' }, { name: 'Bob' }]
+ * users.map(prop('name')) // ['Alice', 'Bob']
+ *
+ * @example
+ * // With pipe
+ * pipe(
+ *   prop('user'),
+ *   prop('profile'),
+ *   prop('email')
+ * )(data) // Safely access nested properties
+ *
+ * @param key - Property key to access
+ * @param obj - Object to access (optional for currying)
+ * @returns Property value, or curried function
+ */
+export declare function prop<K extends PropertyKey>(key: K): <T extends Record<K, any>>(obj: T) => T[K];
+export declare function prop<K extends PropertyKey, T extends Record<K, any>>(key: K, obj: T): T[K];
+//# sourceMappingURL=prop.d.ts.map

package/dist/types/object/prop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop.d.ts","sourceRoot":"","sources":["../../../src/object/prop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,WAAW,EACxC,GAAG,EAAE,CAAC,GACL,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9C,wBAAgB,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAClE,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,CAAC,GACL,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/object/propOr.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Returns a function that retrieves a given property from an object,
+ * returning a default value if the property doesn't exist or is undefined.
+ * Curried for composition (Ramda-style).
+ *
+ * This is essential for safe property access with fallback values,
+ * commonly used in data transformation pipelines.
+ *
+ * @example
+ * const getNameOrUnknown = propOr('Unknown', 'name')
+ * getNameOrUnknown({ name: 'Alice' }) // 'Alice'
+ * getNameOrUnknown({}) // 'Unknown'
+ * getNameOrUnknown({ name: undefined }) // 'Unknown'
+ *
+ * @example
+ * // With default values for missing data
+ * const users = [
+ *   { name: 'Alice', age: 30 },
+ *   { name: 'Bob' }, // missing age
+ *   { age: 25 } // missing name
+ * ]
+ * users.map(propOr('Anonymous', 'name'))
+ * // ['Alice', 'Bob', 'Anonymous']
+ *
+ * @example
+ * // In composition
+ * pipe(
+ *   prop('settings'),
+ *   propOr('light', 'theme')
+ * )(data) // Get theme with 'light' as default
+ *
+ * @param defaultValue - Value to return if property is missing/undefined
+ * @param key - Property key to access
+ * @param obj - Object to access (optional for currying)
+ * @returns Property value or default value, or curried function
+ */
+export declare function propOr<V, K extends string>(defaultValue: V, key: K): <T extends Record<K, any>>(obj: T) => T[K] | V;
+export declare function propOr<V, K extends string, T extends Record<K, any>>(defaultValue: V, key: K, obj: T): T[K] | V;
+//# sourceMappingURL=propOr.d.ts.map

package/dist/types/object/propOr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propOr.d.ts","sourceRoot":"","sources":["../../../src/object/propOr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EACxC,YAAY,EAAE,CAAC,EACf,GAAG,EAAE,CAAC,GACL,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAClD,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAClE,YAAY,EAAE,CAAC,EACf,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,CAAC,GACL,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC"}

package/dist/types/object/set.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a shallow clone of an object with a value set at the given path.
+ * Creates intermediate objects/arrays as needed. Does not mutate the original.
+ *
+ * @example
+ * set({}, 'a.b.c', 42) // { a: { b: { c: 42 } } }
+ * set({ a: { b: 1 } }, 'a.b', 2) // { a: { b: 2 } }
+ * set({ x: 1 }, ['a', 'b'], 3) // { x: 1, a: { b: 3 } }
+ *
+ * @param obj - Source object
+ * @param path - Dot-separated string or array of keys
+ * @param value - Value to set
+ * @returns New object with the value set at the path
+ */
+export declare function set<T extends Record<string, any>>(obj: T, path: string | string[], value: unknown): T;
+//# sourceMappingURL=set.d.ts.map

package/dist/types/object/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../src/object/set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/C,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,KAAK,EAAE,OAAO,GACb,CAAC,CAiBH"}

package/dist/types/predicate/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Type guard predicates for runtime type checking
+ */
+export { isNil, isNotNil } from './isNil.js';
+export { isString } from './isString.js';
+export { isNumber } from './isNumber.js';
+export { isBoolean } from './isBoolean.js';
+export { isArray } from './isArray.js';
+export { isFunction } from './isFunction.js';
+export { isDate } from './isDate.js';
+export { isError } from './isError.js';
+export { isPrimitive } from './isPrimitive.js';
+export { isPromise } from './isPromise.js';
+export { isPlainObject } from './isPlainObject.js';
+export { isEqual } from './isEqual.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/predicate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/predicate/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,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,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/types/predicate/isArray.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard that checks if a value is an array.
+ *
+ * @example
+ * isArray([1, 2, 3]) // true
+ * isArray([]) // true
+ * isArray('hello') // false
+ * isArray({ length: 0 }) // false
+ *
+ * @param value - Value to check
+ * @returns true if value is an array
+ */
+export declare function isArray(value: unknown): value is unknown[];
+//# sourceMappingURL=isArray.d.ts.map

package/dist/types/predicate/isArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArray.d.ts","sourceRoot":"","sources":["../../../src/predicate/isArray.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,EAAE,CAE1D"}

package/dist/types/predicate/isBoolean.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard that checks if a value is a boolean.
+ *
+ * @example
+ * isBoolean(true) // true
+ * isBoolean(false) // true
+ * isBoolean(0) // false
+ * isBoolean('true') // false
+ *
+ * @param value - Value to check
+ * @returns true if value is a boolean
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+//# sourceMappingURL=isBoolean.d.ts.map

package/dist/types/predicate/isBoolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBoolean.d.ts","sourceRoot":"","sources":["../../../src/predicate/isBoolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D"}

package/dist/types/predicate/isDate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Type guard that checks if a value is a valid Date instance.
+ * Returns false for invalid dates (e.g., `new Date('invalid')`).
+ *
+ * @example
+ * isDate(new Date()) // true
+ * isDate(new Date('2024-01-01')) // true
+ * isDate(new Date('invalid')) // false
+ * isDate('2024-01-01') // false
+ * isDate(Date.now()) // false (number)
+ *
+ * @param value - Value to check
+ * @returns true if value is a valid Date
+ */
+export declare function isDate(value: unknown): value is Date;
+//# sourceMappingURL=isDate.d.ts.map

package/dist/types/predicate/isDate.d.ts.map

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

package/dist/types/predicate/isEqual.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Performs a deep equality check between two values.
+ * Handles primitives, objects, arrays, Date, RegExp, Map, Set, and nested structures.
+ *
+ * @example
+ * isEqual(1, 1) // true
+ * isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }) // true
+ * isEqual([1, [2, 3]], [1, [2, 3]]) // true
+ * isEqual({ a: 1 }, { a: 2 }) // false
+ * isEqual(new Date('2024-01-01'), new Date('2024-01-01')) // true
+ * isEqual(new Set([1, 2]), new Set([1, 2])) // true
+ *
+ * @param a - First value
+ * @param b - Second value
+ * @returns true if values are deeply equal
+ */
+export declare function isEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=isEqual.d.ts.map

package/dist/types/predicate/isEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqual.d.ts","sourceRoot":"","sources":["../../../src/predicate/isEqual.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CA+DvD"}

package/dist/types/predicate/isError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard that checks if a value is an Error instance.
+ *
+ * @example
+ * isError(new Error('fail')) // true
+ * isError(new TypeError('bad')) // true
+ * isError({ message: 'not an error' }) // false
+ * isError('error string') // false
+ *
+ * @param value - Value to check
+ * @returns true if value is an Error
+ */
+export declare function isError(value: unknown): value is Error;
+//# sourceMappingURL=isError.d.ts.map

package/dist/types/predicate/isError.d.ts.map

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

package/dist/types/predicate/isFunction.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard that checks if a value is a function.
+ *
+ * @example
+ * isFunction(() => {}) // true
+ * isFunction(Math.round) // true
+ * isFunction(class Foo {}) // true
+ * isFunction('hello') // false
+ *
+ * @param value - Value to check
+ * @returns true if value is a function
+ */
+export declare function isFunction(value: unknown): value is Function;
+//# sourceMappingURL=isFunction.d.ts.map

package/dist/types/predicate/isFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFunction.d.ts","sourceRoot":"","sources":["../../../src/predicate/isFunction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D"}

package/dist/types/predicate/isNil.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Type guard that checks if a value is null or undefined.
+ *
+ * @example
+ * isNil(null) // true
+ * isNil(undefined) // true
+ * isNil(0) // false
+ * isNil('') // false
+ * isNil(false) // false
+ *
+ * @param value - Value to check
+ * @returns true if value is null or undefined
+ */
+export declare function isNil(value: unknown): value is null | undefined;
+/**
+ * Type guard that checks if a value is NOT null or undefined.
+ * Narrows the type by excluding null and undefined.
+ *
+ * @example
+ * isNotNil(0) // true
+ * isNotNil('') // true
+ * isNotNil(null) // false
+ * isNotNil(undefined) // false
+ *
+ * @example
+ * const items = [1, null, 2, undefined, 3];
+ * items.filter(isNotNil) // [1, 2, 3] — type is number[]
+ *
+ * @param value - Value to check
+ * @returns true if value is not null or undefined
+ */
+export declare function isNotNil<T>(value: T | null | undefined): value is T;
+//# sourceMappingURL=isNil.d.ts.map

package/dist/types/predicate/isNil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNil.d.ts","sourceRoot":"","sources":["../../../src/predicate/isNil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,GAAG,SAAS,CAE/D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,IAAI,CAAC,CAEnE"}

package/dist/types/predicate/isNumber.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type guard that checks if a value is a finite number.
+ * Returns false for NaN and Infinity.
+ *
+ * @example
+ * isNumber(42) // true
+ * isNumber(3.14) // true
+ * isNumber(NaN) // false
+ * isNumber(Infinity) // false
+ * isNumber('42') // false
+ * isNumber(null) // false
+ *
+ * @param value - Value to check
+ * @returns true if value is a finite number
+ */
+export declare function isNumber(value: unknown): value is number;
+//# sourceMappingURL=isNumber.d.ts.map

package/dist/types/predicate/isNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumber.d.ts","sourceRoot":"","sources":["../../../src/predicate/isNumber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}

package/dist/types/predicate/isPlainObject.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if a value is a plain object (created by {} or Object.create(null)).
+ * Returns false for arrays, class instances, Date, Map, Set, etc.
+ *
+ * @example
+ * isPlainObject({}) // true
+ * isPlainObject({ key: 'value' }) // true
+ * isPlainObject(Object.create(null)) // true
+ * isPlainObject([]) // false
+ * isPlainObject(new Date()) // false
+ * isPlainObject(new Map()) // false
+ * isPlainObject(null) // false
+ *
+ * @param value - Value to check
+ * @returns true if value is a plain object
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=isPlainObject.d.ts.map

package/dist/types/predicate/isPlainObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject.d.ts","sourceRoot":"","sources":["../../../src/predicate/isPlainObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAM9E"}

package/dist/types/predicate/isPrimitive.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Type guard that checks if a value is a primitive type.
+ * Primitives: string, number, boolean, symbol, bigint, undefined, null.
+ *
+ * @example
+ * isPrimitive('hello') // true
+ * isPrimitive(42) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive({}) // false
+ * isPrimitive([]) // false
+ * isPrimitive(new Date()) // false
+ *
+ * @param value - Value to check
+ * @returns true if value is a primitive
+ */
+export declare function isPrimitive(value: unknown): value is string | number | boolean | symbol | bigint | undefined | null;
+//# sourceMappingURL=isPrimitive.d.ts.map

package/dist/types/predicate/isPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitive.d.ts","sourceRoot":"","sources":["../../../src/predicate/isPrimitive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAEnH"}

package/dist/types/predicate/isPromise.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard that checks if a value is a Promise (or thenable).
+ *
+ * @example
+ * isPromise(Promise.resolve(1)) // true
+ * isPromise(new Promise(() => {})) // true
+ * isPromise({ then: () => {} }) // true (thenable)
+ * isPromise(42) // false
+ *
+ * @param value - Value to check
+ * @returns true if value is a Promise-like
+ */
+export declare function isPromise(value: unknown): value is Promise<unknown>;
+//# sourceMappingURL=isPromise.d.ts.map

package/dist/types/predicate/isPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPromise.d.ts","sourceRoot":"","sources":["../../../src/predicate/isPromise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAMnE"}

package/dist/types/predicate/isString.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard that checks if a value is a string.
+ *
+ * @example
+ * isString('hello') // true
+ * isString(123) // false
+ * isString(null) // false
+ * isString(new String('test')) // false — only primitives
+ *
+ * @param value - Value to check
+ * @returns true if value is a string primitive
+ */
+export declare function isString(value: unknown): value is string;
+//# sourceMappingURL=isString.d.ts.map

package/dist/types/predicate/isString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isString.d.ts","sourceRoot":"","sources":["../../../src/predicate/isString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}