@rzl-zone/utils-js 2.0.1 → 3.0.0-beta.0

package/dist/predicates/index.d.ts

@@ -0,0 +1,1839 @@
+import{m as IsPositive,P as ParseNumber,I as IsStringLiteral,C as CharAt,o as AnyString,a as IsEmptyString,T as Trim,e as IsUnknown,p as IsReadonlyArray,t as IsArray,h as OrArr}from'../is-array-Ckm_47hw.js';import{I as IsAny}from'../any-BmdI8UbK.js';import{A as AnyFunction,a as AnObjectNonArray,T as TypedArray}from'../type-data-DDs-u2kq.js';import{E as Extends}from'../extends-Mp81Hq9-.js';import{P as Prettify}from'../prettify-C4xLcYOP.js';import{N as NumberRangeUnion}from'../NumberRangeUnion-DC-C3_Kq.js';import{a as IsPlainObjectResult}from'../isPlainObject-BKYaI6a8.js';export{G as GetPreciseTypeOptions,I as IsNumberOptions,g as getPreciseType,i as isNumber,b as isPlainObject}from'../isPlainObject-BKYaI6a8.js';import{I as IsNever}from'../never-BfayMBF9.js';import'../if-CvT4R7Kh.js';import'../array-CIZRbqTF.js';type EmptyObject<T>={[K in keyof T]?:never;};type EmptyObjectOf<T>=EmptyObject<T>extends T?EmptyObject<T>:never;type List<T>=ArrayLike<T>;type IsEqualCustomizer=(value:unknown,other:unknown,indexOrKey:PropertyKey,parent:unknown,otherParent:unknown,stack:unknown)=>boolean|undefined;type isMatchWithCustomizer=(value:unknown,other:unknown,indexOrKey:PropertyKey,object:object,source:object)=>boolean|undefined;
+/** ----------------------------------------------------------
+* * ***Compares two arrays deeply to check if they are equal.***
+* ----------------------------------------------------------
+*
+* Supports deep comparison of arrays containing nested arrays or objects.
+* Can also ignore the order of elements at all levels by recursively sorting.
+*
+* ----------------------------------------------------------
+*
+* @param {unknown[]} array1
+*    The first array to compare. Can contain nested arrays or objects.
+*
+* @param {unknown[]} array2
+*    The second array to compare against. Should match structure of `array1`.
+*
+* @param {boolean} [ignoreOrder=false]
+*    Whether to ignore the order of elements when comparing.
+*    If `true`, will sort both arrays recursively before comparing.
+*    Default is `false`.
+*
+* @returns {boolean}
+*    Returns `true` if both arrays are deeply equal, otherwise `false`.
+*
+* @throws {TypeError}
+*    Throws if `array1` or `array2` are not arrays, or if `ignoreOrder` is not a boolean.
+*
+* @example
+* ```ts
+* areArraysEqual([1, 2, 3], [1, 2, 3]);
+* // → true
+*
+* areArraysEqual([1, 2, 3], [3, 2, 1]);
+* // → false
+*
+* areArraysEqual([1, 2, 3], [3, 2, 1], true);
+* // → true (order ignored)
+*
+* areArraysEqual([{ x: 1 }, { y: 2 }], [{ y: 2 }, { x: 1 }], true);
+* // → true
+* ```
+*/
+declare const areArraysEqual:(array1:unknown[],array2:unknown[],ignoreOrder?:boolean)=>boolean;
+/** ---------------------------------
+* * ***Compares two objects for deep equality.***
+* ---------------------------------
+*
+* @template T1 The type of the first object.
+* @template T2 The type of the second object.
+* @param {T1} object1 - The first object to compare.
+* @param {T2} object2 - The second object to compare.
+* @returns {boolean} `true` if both objects are deeply equal, otherwise `false`.
+*
+* @example
+* areObjectsEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // Returns true
+* areObjectsEqual({ a: 1 }, { a: 1, b: undefined }); // Returns false
+* areObjectsEqual([1, 2, 3], [1, 2, 3]); // Returns true
+*/
+declare const areObjectsEqual:(object1:unknown,object2:unknown)=>boolean;
+/** ---------------------------------
+* * ***Checks if two URLs are the same, ignoring query parameters.***
+* ---------------------------------
+*
+* This function compares only the protocol, host, and pathname.
+*
+* @param {URL} urlA - The first URL to compare.
+* @param {URL} urlB - The second URL to compare.
+* @returns {boolean} Returns `true` if both URLs are the same (ignoring search parameters), otherwise `false`.
+*/
+declare const areURLsEqualPath:(urlA:URL,urlB:URL)=>boolean;
+/** ---------------------------------
+* * ***Checks if two URLs are exactly the same, including protocol, host, pathname, and query parameters.***
+* ---------------------------------
+*
+* @param {URL} urlA - The first URL to compare.
+* @param {URL} urlB - The second URL to compare.
+* @returns {boolean} Returns `true` if both URLs are identical, otherwise `false`.
+*/
+declare const areURLsIdentical:(urlA:URL,urlB:URL)=>boolean;
+/** ----------------------------------------------------------
+* * ***Checks if the given `text` contains all of the specified `searchWords`.***
+* ----------------------------------------------------------
+*
+* - ✅ Uses **regular expressions** for flexible pattern matching.
+* - ✅ **Escapes special characters** to prevent regex injection attacks.
+* - ✅ **Trims input** to avoid false positives with empty spaces.
+* - ✅ **Supports exact word matching** (optional).
+*
+* @param {string} text - The text to search within.
+* @param {string[]} searchWords - An array of words/phrases to match against the text.
+* @param {boolean} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.
+* @param {string} [options.flags="i"] - Optional regex flags (default: `"i"` for case-insensitive).
+* @returns {boolean} - `true` if all `searchWords` are found in `text`, otherwise `false`.
+*
+* @example
+* textContainsAll("Hello world, WithAI APP", ["Hello", "world"]); // true
+* textContainsAll("JavaScript and TypeScript", ["Java", "Script"]); // true
+* textContainsAll("Machine Learning", ["AI", "Learning"]); // false
+* textContainsAll("open-source", ["open"], { exactMatch: true }); // false (because options `exactMatch=true`)
+*/
+declare const textContainsAll:<T extends string>(text:T,searchWords:T[]|string[],options?:{
+/** If `true`, matches whole words only, defaultValue is `false`. */
+exactMatch?:boolean;
+/** Optional regex flags (default: `"i"` for case-insensitive). */
+flags?:string;})=>boolean;
+/** ----------------------------------------------------------
+* * ***Checks if the given `text` contains at least one of the specified `searchWords`.***
+* ----------------------------------------------------------
+*
+* - ✅ Uses **regular expressions** for flexible pattern matching.
+* - ✅ **Escapes special characters** to prevent regex injection attacks.
+* - ✅ **Trims input** to avoid false positives with empty spaces.
+* - ✅ **Supports exact word matching** (optional).
+*
+* @param {string} text - The text to search within.
+* @param {string[]} searchWords - An array of words/phrases to match against the text.
+* @param {boolean} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.
+* @param {string} [options.flags="i"] - Optional regex flags (default: `"i"` for case-insensitive).
+* @returns {boolean} - `true` if at least one `searchWord` is found in `text`, otherwise `false`.
+*
+* @example
+* textContainsAny("Hello world", ["hello", "test"]); // true
+* textContainsAny("withAI APP", ["chat", "ai"]); // false
+* textContainsAny("TypeScript is great!", ["script", "java"]); // true
+* textContainsAny("open-source", ["open"], { exactMatch: true }); // false (because options `exactMatch=true`)
+*/
+declare const textContainsAny:<T extends string>(text:T,searchWords:T[]|string[],options?:{
+/** If `true`, matches whole words only, defaultValue is `false`. */
+exactMatch?:boolean;
+/** Optional regex flags (default: `"i"` for case-insensitive). */
+flags?:string;})=>boolean;
+/** ----------------------------------------------------------
+* * ***Recursively checks if a given key exists in an object or array.***
+* ----------------------------------------------------------
+*
+* - ✅ **Supports deeply nested objects and arrays**, searching recursively.
+* - ✅ Uses `Object.prototype.hasOwnProperty.call()` to safely check if the key exists at each level,
+*      even if its value is `null` or `undefined`.
+* - ✅ Optimized to return `true` immediately when the key is found (short-circuits).
+* - ✅ Handles edge cases gracefully:
+*      - Returns `false` for `null`, `undefined`, or non-object inputs.
+*      - Returns `false` if key is not found anywhere, even in deeply nested structures.
+*
+* ⚠️ Note: This function only checks for **the existence of the key itself**,
+* not whether its value is non-null or non-undefined.
+* If you need to check for both existence and meaningful value, write a stricter function.
+*
+* @template T - The type of the input object or array.
+* @param {T | Record<string, unknown> | unknown[]} object - The object or array to search.
+* @param {PropertyKey} key - The key to look for (string, number, or symbol).
+* @returns {boolean} Returns `true` if the key exists anywhere in the object or array (even with `null` / `undefined` value), otherwise `false`.
+*
+* @example
+* doesKeyExist({ name: "John", age: 30 }, "age"); // true
+* doesKeyExist({ user: { profile: { email: "test@example.com" } } }, "email"); // true
+* doesKeyExist([{ id: 1 }, { id: 2 }], "id"); // true
+* doesKeyExist({ a: { b: { c: 10 } } }, "d"); // false
+* doesKeyExist(null, "name"); // false
+* doesKeyExist(undefined, "test"); // false
+*
+* @example
+* // Key exists even if value is null or undefined:
+* doesKeyExist({ a: null, b: undefined, c: { d: null } }, "a"); // true
+* doesKeyExist({ a: null, b: undefined, c: { d: null } }, "b"); // true
+* doesKeyExist({ a: null, b: undefined, c: { d: null } }, "d"); // true
+*
+* @example
+* doesKeyExist({ a: 1 }, true); // ❌ Throws TypeError
+* doesKeyExist({ a: 1 }, ["not", "valid"]); // ❌ Throws TypeError
+*/
+declare const doesKeyExist:(object:Record<string,unknown>|unknown[],key:PropertyKey)=>boolean;
+/** ----------------------------------------------------------
+* * ***Checks if at least one element from `targetArray` exists in `sourceArray`.***
+* ----------------------------------------------------------
+*
+* - ✅ Uses `Set` for **faster lookup** compared to `Array.prototype.includes()`.
+* - ✅ Supports **any data type** (`number`, `string`, `boolean`, `object`, `array`, `function`, etc.).
+* - ✅ Uses **reference equality** for non-primitive values (object, array, function).
+* - ✅ Returns `false` if either array is missing, empty, or not an array.
+*
+* @template T - The expected type of array elements.
+*
+* @param {T[]} [sourceArray] - The array to search within.
+* @param {T[]} [targetArray] - The array containing elements to match.
+*
+* @returns {boolean}
+*    - `true` if **at least one element from `targetArray` is strictly found in `sourceArray`**.
+*    - Comparison uses:
+*       - **Value equality** for primitives (`number`, `string`, `boolean`, `null`, `undefined`).
+*       - **Reference equality** for objects, arrays, and functions.
+*    - `false` if:
+*       - No matching elements exist,
+*       - Either array is not provided, not an actual array, or is empty.
+*
+* @example
+* arrayHasAnyMatch(["apple", "banana", "cherry"], ["banana", "grape"]); // → true
+* arrayHasAnyMatch(["red", "blue"], ["green", "yellow"]); // → false
+* arrayHasAnyMatch([1, 2, 3], [3, 4, 5]); // → true
+* arrayHasAnyMatch([], ["test"]); // → false
+* arrayHasAnyMatch(["A", "B", "C"], []); // → false
+*
+* @example
+* const obj = { x: 1 };
+* arrayHasAnyMatch([obj], [obj]); // → true (same reference)
+* arrayHasAnyMatch([{ x: 1 }], [{ x: 1 }]); // → false (different reference)
+*
+* @example
+* const fn = () => "hello";
+* arrayHasAnyMatch([fn], [fn]); // → true
+* arrayHasAnyMatch([() => "hello"], [() => "hello"]); // → false (different function reference)
+*
+* @example
+* const arr = [1, 2];
+* arrayHasAnyMatch([arr], [arr]); // → true
+* arrayHasAnyMatch([[1, 2]], [[1, 2]]); // → false (different array object)
+*/
+declare const arrayHasAnyMatch:<T>(sourceArray?:T[],targetArray?:T[])=>boolean;
+/** Restrict array indices to a fixed numeric range (1–25). */
+type ArrayIndex=NumberRangeUnion<1,25>;
+/** Remove `undefined` from a type. */
+type NonUndef<T>=T extends undefined?never:T;
+/** Remove `null` from a type. */
+type NonNull<T>=T extends null?never:T;
+/** Convert optional boolean for "discard undefined" to actual boolean. */
+type EffectiveDiscardUndefined<O extends boolean|undefined>=O extends boolean?O:true;
+/** Convert optional boolean for "discard null" to actual boolean. */
+type EffectiveDiscardNull<O extends boolean|undefined>=O extends boolean?O:false;
+/** Unwrap array type. */
+type UnwrapArray<T>=T extends(infer U)[]?U:T extends readonly(infer U)[]?U:T;
+/** Force symbol key to be deep required. */
+type IsOptionalKey<T,K extends keyof T>=Record<never,never>extends Pick<T,K>?true:false;
+/** Returns numeric keys of an object.  */
+type NumericKeyOfHasOwnProp<Obj>=Extract<keyof Obj,number>;
+/** Generate all nested keys of an object or array in dot/bracket notation.
+*
+* Example:
+* ```ts
+* type Keys = NestedKeyOfHasOwnProp<{ users: { name: string }[] }>
+* // Keys = "users" | "users.[number]" | "users.[number].name"
+* ```
+*/
+type NestedKeyOfHasOwnProp<T>=T extends readonly(infer U)[]?`[${number}]`|`[${number}].${NestedKeyOfHasOwnProp<U>}`:T extends object?{[K in keyof T &(string|number)]:K extends string|number?NonNullable<T[K]>extends readonly unknown[]?`${K}`|`${K}.[${ArrayIndex}]`|`${K}.[${ArrayIndex}].${NestedKeyOfHasOwnProp<UnwrapArray<T[K]>>}`:NonNullable<T[K]>extends object?`${K}`|`${K}.${NestedKeyOfHasOwnProp<NonNullable<T[K]>>}`:`${K}`:never;}[keyof T &(string|number)]:never;
+/** Apply discard rules to the last key of a path.
+*
+* Rules:
+* - If discardUndefined=true -> remove `undefined` from value
+* - If discardNull=true -> remove `null` from value
+*
+* Order: first strip undefined (if requested), then strip null (if requested)
+*/
+type ApplyLastRulesHasOwnProp<V,DiscardU extends boolean,DiscardN extends boolean>=DiscardU extends true?DiscardN extends true?NonNull<NonUndef<V>>:NonUndef<V>:DiscardN extends true?NonNull<V>:V|Extract<V,undefined>;
+/** Force an array index N to type U. */
+type RefineArrayAtIndex<T extends readonly unknown[],N extends number,U>=T &{[K in N]:U;};
+/** Narrow object/array type based on a path string.
+*
+* @template T - object type to narrow
+* @template P - path string like "user.addresses.[2].zip"
+* @template DU - discard undefined
+* @template DN - discard null
+*/
+type NarrowByPathHasOwnProp<T,P extends string,DU extends boolean=true,DN extends boolean=false>=P extends`${infer Head}.${infer Rest}`?Head extends`[${infer N extends number}]`?T extends readonly(infer U)[]?RefineArrayAtIndex<T,N,NarrowByPathHasOwnProp<U,Rest,DU,DN>>:T:Head extends keyof T?Rest extends`[${infer M extends number}]${infer R}`?M extends R?{[K in keyof T]-?:NarrowByPathHasOwnProp<EffectiveDiscardUndefined<DU>extends true?NonUndef<T[K]>:EffectiveDiscardNull<DN>extends true?NonNull<T[K]>:T[K],Rest,DU,DN>;}:EffectiveDiscardUndefined<DU>extends true?{[K in keyof T]-?:K extends Head?Exclude<NarrowByPathHasOwnProp<EffectiveDiscardNull<DN>extends true?Exclude<T[K],null>:EffectiveDiscardUndefined<DU>extends true?Exclude<T[K],undefined>:T[K],Rest,DU,DN>,undefined>:EffectiveDiscardNull<DN>extends true?Exclude<T[K],null>:EffectiveDiscardUndefined<DU>extends true?Exclude<T[K],undefined>:T[K];}:{[K in keyof T]:K extends Head?NarrowByPathHasOwnProp<EffectiveDiscardNull<DN>extends true?Exclude<T[K],null>:EffectiveDiscardUndefined<DU>extends true?Exclude<T[K],undefined>:T[K],Rest,DU,DN>:EffectiveDiscardNull<DN>extends true?Exclude<T[K],null>:EffectiveDiscardUndefined<DU>extends true?Exclude<T[K],undefined>:T[K];}:{[K in keyof T]:K extends Head?NarrowByPathHasOwnProp<NonNullable<T[K]>,Rest,DU,DN>:T[K];}&{[K in Head]-?:NarrowByPathHasOwnProp<NonNullable<T[K]>,Rest,DU,DN>;}:T:P extends`[${infer N extends number}]`?T extends readonly(infer U)[]?RefineArrayAtIndex<T,N,ApplyLastRulesHasOwnProp<NonNullable<U>,DU,DN>>:T:P extends keyof T?DU extends true?{[K in keyof T]:K extends P?ApplyLastRulesHasOwnProp<T[K],DU,DN>:T[K];}&{[K in P]-?:ApplyLastRulesHasOwnProp<T[P],DU,DN>;}:{[K in keyof T]:K extends P?ApplyLastRulesHasOwnProp<T[K],DU,DN>:T[K];}:T;
+/** Expand an array/string/function into a nested type according to a dot/bracket path. */
+type SmartDetectStringHasOwnProp<Obj extends string|undefined|null,Key extends string|number>=Obj extends undefined?undefined:Obj extends null?null:IsPositive<ParseNumber<Key>>extends true?Extends<IsStringLiteral<Obj>,true>extends true?CharAt<Exclude<Obj,null|undefined>,ParseNumber<Key>>:string|undefined|null:IsPositive<ParseNumber<Key>>extends true?string|undefined|null:AnyString|undefined|null;type SmartDetectArrayFuncHasOwnProp<Obj extends unknown[]|AnyFunction,Key extends PropertyKey>=Prettify<Obj & DotToNestedSpecialSmartDetect<Key>&{length:number;},{recursive:false;}>;
+/** Smartly detect nested path keys of an unknown object or function, falls-back to inferred nested structure when path is not valid. */
+type SmartDetectUnknownKeyHasOwnProp<Obj extends unknown|AnyFunction,Key extends PropertyKey,DiscardUndefined extends boolean=true,DiscardNull extends boolean=false>=Trim<Key>extends""?Obj:Prettify<Obj &(Key extends NestedKeyOfHasOwnProp<Obj>?GuardedHasOwnProp<Obj,Key,DiscardUndefined,DiscardNull>:DotToNestedSpecialSmartDetect<Key>),{recursive:true;}>;
+/** Convert dot/bracket path string to nested object type with leaf value.
+* Path not found in object key → return unknown.
+*/
+type DotToNestedSpecialSmartDetect<Path extends PropertyKey,Value=unknown>=IsEmptyString<Extract<Path,string>>extends true?undefined:Path extends`${infer Head}.${infer Rest}`?Head extends`[${number}]`?DotToNestedSpecialSmartDetect<Rest,Value>[]:{[Key in Head]:DotToNestedSpecialSmartDetect<Rest,Value>;}:Path extends`[${number}]`?Value[]:{[Key in Path]:Value;};
+/** Guarded wrapper for `NarrowByPathHasOwnProp` with `Prettify`. */
+type GuardedHasOwnProp<Obj,Key extends NestedKeyOfHasOwnProp<Obj>,DiscardUndefined extends boolean|undefined,DiscardNull extends boolean|undefined>=Prettify<Obj & NarrowByPathHasOwnProp<Obj,Key & string,EffectiveDiscardUndefined<DiscardUndefined>,EffectiveDiscardNull<DiscardNull>>,{recursive:true;}>;
+/** Make a specific symbol key deeply required in an object symbols.
+*
+* Used internally to enforce stronger type narrowing.
+*/
+type DeepRequiredSymbolHasOwnProp<Obj,Sym extends symbol,DU extends boolean=true,DN extends boolean=false>=Prettify<Obj &({[K in keyof Obj & Sym as DU extends true?K:never]-?:DN extends true?NonNull<NonUndef<Obj[K]>>:NonUndef<Obj[K]>;}&{[K in keyof Obj & Sym as DU extends true?never:K]?:DN extends true?NonNull<Obj[K]>:Obj[K];}),{recursive:true;}>;
+/** Apply discard rules to numeric keys in an object type.
+*
+* - If `discardUndefined = true` → undefined removed, key required
+* - If `discardNull = true` → null removed
+*/
+type NumericKeyHasOwnPropMapped<Obj extends object,K extends NumericKeyOfHasOwnProp<Obj>,DU extends boolean,DN extends boolean>=Prettify<Obj &(IsOptionalKey<Obj,K>extends true?{[P in K]?:DN extends true?NonNull<Obj[K]>:Obj[K];}&(DU extends true?{[P in K]-?:NonUndef<Obj[K]>;}:Record<never,never>):{[P in K]-?:DN extends true?NonNull<Obj[K]>:Obj[K];}&(DU extends true?{[P in K]-?:NonUndef<Obj[K]>;}:Record<never,never>)),{recursive:true;}>;
+/** Options to control `hasOwnProp` behavior. */
+type HasOwnPropOptions<DiscardUndefined extends boolean=true,DiscardNull extends boolean=false>={
+/**
+* If `true` (default), properties with `undefined` values are treated as non-existent.
+*
+* **Effects:**
+* - **Runtime:** `hasOwnProp(obj, key)` returns `false` if the property exists but its value is `undefined`.
+* - **TypeScript narrowing:** The property's type is narrowed to exclude `undefined`.
+*
+* **Example:**
+* ```ts
+* const obj = { a: undefined, b: 123 };
+* hasOwnProp(obj, "a"); // false
+* hasOwnProp(obj, "a", { discardUndefined: false }); // true
+* ```
+*/
+discardUndefined?:DiscardUndefined;
+/**
+* If `true` (default: `false`), properties with `null` values are treated as non-existent.
+*
+* **Effects:**
+* - **Runtime:** `hasOwnProp(obj, key)` returns `false` if the property exists but its value is `null`.
+* - **TypeScript narrowing:** The property's type is narrowed to exclude `null`.
+*
+* **Example:**
+* ```ts
+* const obj = { a: null, b: 123 };
+* hasOwnProp(obj, "a"); // true (default discardNull = false)
+* hasOwnProp(obj, "a", { discardNull: true }); // false
+* ```
+*/
+discardNull?:DiscardNull;};
+/** -------------------------------------------------------
+* * ***A **type-safe** replacement for `Object.prototype.hasOwnProperty`
+*   with runtime validation and **TypeScript-aware type narrowing**.***
+* -------------------------------------------------------
+*
+* ---
+* #### Supported Targets
+* - **Plain objects** ➔ `{ foo: "bar" }`
+* - **Arrays** ➔ `[ { id: 1 }, { id: 2 } ]`
+* - **Strings** ➔ `"hello"` (as array-like objects with `.length`, index, etc.)
+* - **Functions** ➔ callable objects with extra props
+* - **Symbols** ➔ own property symbols
+*
+* ---
+* #### Key Advantages over `in` or `obj.hasOwnProperty(key)`
+* - Supports **dot/bracket path notation** (e.g. `"user.address.city"`, `"addresses[0].zip"`)
+* - Handles **symbol** keys safely
+* - **Narrows** the type of `obj` in TypeScript (stronger type safety)
+* - Configurable handling of **`undefined`** and **`null`**
+*
+* ---
+* #### Runtime Behavior
+* ✅ Returns `true` if:
+* - `obj` is an object/array/string/function **and**
+* - the property exists **and**
+* - it passes the `options` checks
+*
+* ❌ Returns `false` if:
+* - `obj` is not a valid type
+* - the property does not exist
+* - the value is `undefined` and `discardUndefined: true` (default)
+* - the value is `null` and `discardNull: true`
+* - the `key` (after trimming) is an **empty string** ➔ treated as **invalid**
+*
+* ---
+* #### TypeScript Behavior
+* Inside an `if (hasOwnProp(...)) {}` block:
+* - The property is **guaranteed to exist**
+* - Depending on `options`, the property type is narrowed to exclude
+*   `undefined` and/or `null`
+*
+* ---
+* #### ⚠️ Caveats
+* - **Empty keys are invalid**:
+*    - If the `key` string is empty (`""`) after trimming whitespace or other characters,
+*      it will **not** be considered a valid property and always returns `false`.
+*
+* - **Arrays are limited by TypeScript inference**:
+*    - Checking index `[0]` only narrows **that specific index**, not the rest.
+*    - Example:
+*        - `hasOwnProp(users, "[0].id")` does **not** imply `users[1].id` exists.
+*            - 👉 For different indices, use **optional chaining** (`users[1]?.id`).
+*
+* - **Autocomplete limitation for array indices**:
+*    - Autocompletion for `[index]` is only supported up to **25** (`[0]` ➔ `[24]`).
+*    -  This limit is intentional for **performance and safety**:
+*      generating infinite union types for all possible indices would cause
+*      **TypeScript IntelliSense to hang or crash**.
+*      You can still check higher indices manually (e.g. `"[999].id"`),
+*      but they will not show up in IntelliSense suggestions.
+*
+* ---
+* #### Options
+* @param options.discardUndefined - Default `true`.
+*   If `true`, properties with `undefined` values are treated as **missing**.
+*
+* @param options.discardNull - Default `false`.
+*   If `true`, properties with `null` values are treated as **missing**.
+*
+* ---
+* @example
+*
+* #### ✅ Objects
+* ```ts
+* const obj: { name?: string | null } = {};
+*
+* if (hasOwnProp(obj, "name")) {
+*   // obj is now ➔ { name: string | null }
+*   console.log(obj.name); // string | null
+* }
+*
+* if (hasOwnProp(obj, "name", { discardUndefined: true, discardNull: true })) {
+*   // obj is now ➔ { name: string }
+*   console.log(obj.name.toUpperCase()); // safe
+* }
+* ```
+*
+* #### ✅ Arrays
+* ```ts
+* const users = [{ id: 1 }, { id: 2 }];
+*
+* if (hasOwnProp(users, "[1].id")) {
+*   // ➔ users[1].id is guaranteed to exist
+*   console.log(users[1].id); // number
+* }
+*
+* // ⚠️ Caveat: narrowing only applies to checked index
+* if (hasOwnProp(users, "[0].id")) {
+*   console.log(users[0].id); // ✅ safe
+*   console.log(users[1].id); // ❌ not guaranteed!
+* }
+*
+* // 👉 Solution: optional chaining
+* console.log(users[1]?.id); // ➔ safe, even without narrowing
+* ```
+*
+* #### ✅ Symbols
+* ```ts
+* const secret = Symbol("secret");
+* const obj2 = { [secret]: 42 };
+*
+* if (hasOwnProp(obj2, secret)) {
+*   console.log(obj2[secret] + 1); // ➔ 43
+* }
+* ```
+*
+* #### ✅ Strings
+* ```ts
+* if (hasOwnProp("hello", "length")) {
+*   console.log("hello".length); // ➔ 5
+* }
+*
+* if (hasOwnProp("hello", 1)) {
+*   console.log("hello"[1]); // ➔ "e"
+* }
+* ```
+*
+*
+* #### ✅ Functions
+* ```ts
+* function fn() {}
+* fn.extra = 123;
+*
+* if (hasOwnProp(fn, "extra")) {
+*   console.log(fn.extra); // ➔ 123
+* }
+* ```
+*
+* #### ❌ Empty key
+* ```ts
+* const obj = { a: 1 };
+*
+* hasOwnProp(obj, "");        // ➔ false (invalid key)
+* hasOwnProp(obj, "   ");     // ➔ false (trimmed to empty)
+* ```
+*/
+declare function hasOwnProp<Obj>(obj:IsAny<Obj>extends true?Obj:never,key:PropertyKey,options?:HasOwnPropOptions<boolean,boolean>
+/** @ts-expect-error we force `any` to `unknown` at result */
+):obj is unknown;declare function hasOwnProp<Obj extends null|undefined>(obj:Obj,key:PropertyKey,options?:HasOwnPropOptions<boolean,boolean>):false;declare function hasOwnProp<Obj extends object|AnyFunction,Key extends NestedKeyOfHasOwnProp<Obj>,DiscardUndefined extends boolean=true,DiscardNull extends boolean=false>(obj:Obj|null|undefined,key:Key,options?:HasOwnPropOptions<DiscardUndefined,DiscardNull>
+/** @ts-expect-error we force to override recursive type result */
+):obj is GuardedHasOwnProp<Obj,Key,DiscardUndefined,DiscardNull>;declare function hasOwnProp<Obj extends object,Num extends NumericKeyOfHasOwnProp<Obj>,DiscardUndefined extends boolean=true,DiscardNull extends boolean=false>(obj:Obj|null|undefined,key:Num,options?:HasOwnPropOptions<DiscardUndefined,DiscardNull>
+/** @ts-expect-error we force to override recursive type result */
+):obj is NumericKeyHasOwnPropMapped<Obj,Num,DiscardUndefined,DiscardNull>;declare function hasOwnProp<Obj extends object|AnyFunction,Sym extends symbol,DiscardUndefined extends boolean=true,DiscardNull extends boolean=false>(obj:Obj|null|undefined,key:Sym,options?:HasOwnPropOptions<DiscardUndefined,DiscardNull>
+/** @ts-expect-error we force to override recursive type result */
+):obj is DeepRequiredSymbolHasOwnProp<Obj,Sym,DiscardUndefined,DiscardNull>;declare function hasOwnProp<Obj extends string|null|undefined,Key extends string|number>(obj:Obj|null|undefined,key:Key,options?:HasOwnPropOptions<boolean,boolean>
+/** @ts-expect-error we force to override recursive type result */
+):obj is IsStringLiteral<SmartDetectStringHasOwnProp<Obj,Key>>extends true?AnyString|SmartDetectStringHasOwnProp<Obj,Key>:SmartDetectStringHasOwnProp<Obj,Key>;declare function hasOwnProp<Obj extends unknown[]|AnyFunction,Key extends PropertyKey>(obj:Obj,key:Key,options?:HasOwnPropOptions<boolean,boolean>):obj is SmartDetectArrayFuncHasOwnProp<Obj,Key>;declare function hasOwnProp<Obj extends unknown|AnyFunction,Key extends PropertyKey,DiscardUndefined extends boolean=true,DiscardNull extends boolean=false>(obj:Obj,key:Key|"length"|(IsPlainObjectResult<Obj>extends never?never:keyof Obj),options?:HasOwnPropOptions<DiscardUndefined,DiscardNull>
+/** @ts-expect-error we force to override recursive type result */
+):obj is SmartDetectUnknownKeyHasOwnProp<Obj,Key,DiscardUndefined,DiscardNull>;
+/** -------------------
+* * ***Type guard: `isArguments`.***
+* -------------------
+* @description Checks if `value` is likely an `arguments` object.
+*
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is an **[IArguments](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments)** object,
+*  else `false`.
+* @example
+* isArguments(function() { return arguments; }());
+* // ➔ true
+* isArguments([1, 2, 3]);
+* // ➔ false
+*/
+declare const isArguments:(value:unknown)=>value is IArguments;
+/** @deprecated bugs */
+type IsArrayResult<T>=IsUnknown<T>extends true?unknown[] & T:IsNever<T>extends true?[]:IsReadonlyArray<T>extends true?T:IsArray<T>extends true?T:unknown[];
+/** ----------------------------------------------------------
+* * ***Type guard: `isArray`.***
+* ----------------------------------------------------------
+* @description Checks if a value is an [`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
+*
+* - Uses **[`Array.isArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)** for reliable and safe type checking.
+* - Supports TypeScript **type narrowing** using `value is T[]`.
+* - Handles edge cases like `null`, `undefined`, and non-array objects.
+*
+* @template T - The expected type of array elements.
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is an `array`, otherwise `false`.
+* @example
+* isArray([1, 2, 3]);
+* // ➔ true
+* isArray([]);
+* // ➔ true
+* isArray("hello");
+* // ➔ false
+* isArray({ key: "value" });
+* // ➔ false
+* isArray(null);
+* // ➔ false
+* isArray(undefined);
+* // ➔ false
+*/
+declare function isArray<T extends unknown[]>(value:T):value is Extract<T,unknown[]>;declare function isArray<T extends readonly unknown[]>(value:T):value is Extract<T,readonly unknown[]>;declare function isArray(value:unknown):value is unknown[];
+/** ----------------------------------------------------
+* * ***Type guard: `isArrayBuffer`.***
+* ----------------------------------------------------
+* @description Checks if `value` is classified as an `ArrayBuffer` object.
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is instance of **[ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)**, else `false`.
+* @example
+* isArrayBuffer(new ArrayBuffer(2));
+* // ➔ true
+* isArrayBuffer(new Array(2));
+* // ➔ false
+*/
+declare function isArrayBuffer(value:unknown):value is ArrayBuffer;
+/** ----------------------------------------------------
+* * ***Type guard: `isArrayLike`.***
+* ----------------------------------------------------
+* @description Checks if `value` is array-like. A value is considered array-like if it's
+* not a function and has a `value.length` that's an integer greater than or
+* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+*
+* @template T - The type of the value being checked.
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+* @example
+* isArrayLike([1, 2, 3]);
+* // ➔ true
+* isArrayLike(document.body.children);
+* // ➔ true
+* isArrayLike(noop);
+* // ➔ false
+* isArrayLike('abc');
+* // ➔ false
+*/
+declare function isArrayLike<T extends{__anyHack:unknown;}>(value:T):boolean;declare function isArrayLike(value:AnyFunction|null|undefined):value is never;declare function isArrayLike(value:unknown):value is{length:number;};
+/** ----------------------------------------------------
+* * ***Type guard: `isArrayLikeObject`.***
+* ----------------------------------------------------
+* @description This method is like **{@link isArrayLike}** except that it also checks if `value` is an object.
+* @template T - The type of the value being checked.
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is `array-like object`, else `false`.
+* @example
+* isArrayLikeObject([1, 2, 3]);
+* // ➔ true
+* isArrayLikeObject(document.body.children);
+* // ➔ true
+* isArrayLikeObject('abc');
+* // ➔ false
+* isArrayLikeObject(noop);
+* // ➔ false
+*/
+declare function isArrayLikeObject<T extends{__anyHack:unknown;}>(value:T):boolean;declare function isArrayLikeObject(value:AnyFunction|string|boolean|number|null|undefined):value is never;declare function isArrayLikeObject(value:unknown):value is object &{length:number;};
+/** ----------------------------------------------------------
+* * ***Type guard: `isBigInt`.***
+* ----------------------------------------------------------
+* @description Checks if a value is of type bigint.
+* - Uses `typeof value === "bigint"` for strict type checking.
+* - Supports TypeScript type narrowing with `value is bigint`.
+* - Returns `false` for `BigInt` object (object-wrapped), e.g. `Object(BigInt(123))`.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if value is a primitive **[`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)**.
+* @example
+* isBigInt(123n);
+* // ➔ true
+* isBigInt(BigInt(123));
+* // ➔ true
+* isBigInt("123");
+* // ➔ false
+* isBigInt(Object(BigInt(1)));
+* // ➔ false
+*/
+declare const isBigInt:(value:unknown)=>value is bigint;
+/** ----------------------------------------------------------
+* * ***Type guard: `isBoolean`.***
+* ----------------------------------------------------------
+* @description Checks if a value is of type boolean.
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is a **[`boolean`](https://developer.mozilla.org/en-US/docs/Glossary/Boolean/JavaScript)**, otherwise `false`.
+* @example
+* isBoolean(true);   // ➔ true
+* isBoolean(false);  // ➔ true
+* isBoolean("true"); // ➔ false
+*/
+declare const isBoolean:(value:unknown)=>value is boolean;
+/** ----------------------------------------------------
+* * ***Type guard: `isBuffer`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a **Node.js Buffer** instance.
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a **{@link Buffer}**, else `false`.
+* @example
+* isBuffer(new Buffer(2));
+* // ➔ true
+* isBuffer(Buffer.alloc(10));
+* // ➔ true
+* isBuffer(Buffer.from('foo'));
+* // ➔ true
+* isBuffer([]);
+* // ➔ false
+* isBuffer('a string');
+* // ➔ false
+* isBuffer(new Uint8Array(1024));
+* // ➔ false
+*/
+declare const isBuffer:(value:unknown)=>value is Buffer;
+/** -----------------------------------------------------------
+* * ***Checks whether a value looks like a currency or number string.***
+* -----------------------------------------------------------
+* Determines if the given `input` can be interpreted as a currency-like number,
+* using the same **multi-locale parsing logic** as **{@link parseCurrencyString}**.
+*
+* Highlights:
+*  - Supports strings or numbers like:
+*    - "15.000,10"  (European)
+*    - "15,000.10"  (US)
+*    - "15'000.10"  (Swiss)
+*    - "15 000,10"  (French)
+*    - "Rp 15.000,10" or "$15,000.10"
+*  - Also accepts simple numbers (15300.95).
+*
+* Uses the same core logic as **{@link parseCurrencyString}** but
+* just checks if a final parsed float is sensible.
+*
+* @param {*} input - The input value to check.
+*
+* @returns {boolean} Return `true` if it can be reasonably parsed into a currency-like number, `false` otherwise.
+*
+* @example
+* isCurrencyLike(15300.95);
+* // ➔ true
+* isCurrencyLike("$15,000.10");
+* // ➔ true
+* isCurrencyLike("(15'000.10)");
+* // ➔ true
+* isCurrencyLike("Rp 15.000,10");
+* // ➔ true
+* isCurrencyLike("");
+* // ➔ false
+* isCurrencyLike("abc");
+* // ➔ false
+*/
+declare const isCurrencyLike:(input:unknown)=>boolean;
+/** ----------------------------------------------------------
+* * ***Type guard: `isDate`.***
+* ----------------------------------------------------------
+* @description Determines whether the given `value` is a real, valid JavaScript **[`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)** object.
+* - Checks if value is an instance of `Date`.
+* - Ensures the date is valid (`!isNaN(date.getTime())`).
+* - Returns false for strings or invalid date objects.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if value is a valid Date object.
+* @example
+* isDate(new Date());
+* // ➔ true
+* isDate(new Date("invalid"));
+* // ➔ false
+* isDate("2024-01-01");
+* // ➔ false
+*/
+declare const isDate:(value:unknown)=>value is Date;
+/** ----------------------------------------------------------
+* * ***Performs a deep equality check between two values.***
+* ----------------------------------------------------------
+* - Compares nested arrays, objects, Dates, RegExp, NaN, Symbols, Set, and Map.
+* - Handles special cases:
+*    - `NaN` is considered equal to `NaN`.
+*    - `Date` objects are equal if `.getTime()` is equal.
+*    - `RegExp` objects are equal if `.toString()` is equal.
+*    - `Symbol("x")` and `Symbol("x")` are treated equal if `.toString()` matches.
+*    - `Set` and `Map` are deeply compared by content (order-insensitive).
+* - Does not support circular references.
+*
+* @param {*} a - First value to compare.
+* @param {*} b - Second value to compare.
+* @returns {boolean} `true` if both values are deeply equal, otherwise `false`.
+* @example
+* // ✅ Primitives
+* isDeepEqual(1, 1);
+* // ➔ true
+* isDeepEqual(NaN, NaN);
+* // ➔ true
+* isDeepEqual("hello", "world");
+* // ➔ false
+*
+* // ✅ Objects
+* isDeepEqual({ x: 1 }, { x: 1 });
+* // ➔ true
+* isDeepEqual({ x: 1 }, { y: 1 });
+* // ➔ false
+*
+* // ✅ Arrays
+* isDeepEqual([1, 2], [1, 2]);
+* // ➔ true
+* isDeepEqual([1, 2], [2, 1]);
+* // ➔ false
+*
+* // ✅ Dates
+* isDeepEqual(new Date(123), new Date(123));
+* // ➔ true
+*
+* // ✅ Sets
+* isDeepEqual(new Set([1, 2]), new Set([2, 1]));
+* // ➔ true
+*
+* // ✅ Maps
+* isDeepEqual(new Map([["a", 1]]), new Map([["a", 1]]));
+* // ➔ true
+*
+* // ❌ Different types
+* isDeepEqual(1, "1");
+* // ➔ false
+*/
+declare const isDeepEqual:(a:unknown,b:unknown)=>boolean;
+/** ----------------------------------------------------
+* * ***Type guard: `isElement`.***
+* ----------------------------------------------------------
+* @description Checks if `value` is likely a **[`DOM Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element)**.
+* @template T - The type of the value being checked.
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is extends instance of **[`Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element)**, else `false`.
+* @example
+* isElement(document.body);
+* // ➔ true
+* isElement(document.createElement("div"));
+* // ➔ true
+* isElement('<body>');
+* // ➔ false
+* isElement(document);
+* // ➔ false
+* isElement({ tagName: "DIV" });
+* // ➔ false
+*/
+declare function isElement(value:[]):value is [];declare function isElement<T extends Element>(value:T):value is T;declare function isElement(value:unknown):value is Element;
+/** ----------------------------------------------------
+* * ***Utility: `isEmpty`.***
+* ----------------------------------------------------------
+* @description Checks if `value` is an empty object, collection, map, or set.
+* - **Objects** are empty if they have no own enumerable string keyed properties.
+* - **Array-like values** (arrays, strings, `arguments`, typed arrays, buffers) are empty if their `length` is `0`.
+* - **Maps** and **Sets** are empty if their `size` is `0`.
+* - **Booleans**, **numbers** (including `NaN`), **symbols**, and `null`/`undefined` are treated as empty.
+* - **Functions** are considered empty if they have no own enumerable keys.
+*
+* **⚠️ Notes:** For More Strict, you can use **{@link isEmptyValue}**.
+*
+* @template T - The type of the value being checked.
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is empty, else `false`.
+* @example
+* isEmpty(null);
+* // ➔ true
+* isEmpty(true);
+* // ➔ true
+* isEmpty(false);
+* // ➔ true
+* isEmpty(1);
+* // ➔ true
+* isEmpty(0);
+* // ➔ true
+* isEmpty(Symbol("x"));
+* // ➔ true
+* isEmpty(() => {});
+* // ➔ true
+* isEmpty("");
+* // ➔ true
+* isEmpty("   ");
+* // ➔ false
+* isEmpty([1, 2, 3]);
+* // ➔ false
+* isEmpty({ 'a': 1 });
+* // ➔ false
+*/
+declare function isEmpty<T extends{__trapAny:any;}>(value?:T):boolean;declare function isEmpty(value:string):value is"";declare function isEmpty(value:Map<any,any>|Set<any>|List<any>|null|undefined):boolean;declare function isEmpty(value:object):boolean;declare function isEmpty<T extends object>(value:T|null|undefined):value is EmptyObjectOf<T>|null|undefined;declare function isEmpty(value:any):boolean;
+/** ----------------------------------------------------------
+* * ***Type guard: `isEmptyArray`.***
+* ----------------------------------------------------------
+* @description
+* - Checks whether a given value is an empty array.
+* - Non-array inputs are considered "empty" (defensive strategy).
+*
+* @param {*} [value] - The value to check.
+* @returns {boolean} Returns `true` if it's not an array or an empty array.
+* @example
+* isEmptyArray([]);             // ➔ true
+* isEmptyArray([1, 2, 3]);      // ➔ false
+* isEmptyArray("not an array"); // ➔ true
+* isEmptyArray(null);           // ➔ true
+* isEmptyArray(undefined);      // ➔ true
+*
+* if (isEmptyArray(data.items)) {
+*   console.log("No items to display.");
+* }
+*/
+declare const isEmptyArray:(value:unknown)=>boolean;
+/** ----------------------------------------------------------
+* * ***Predicate: `isEmptyDeep`.***
+* ----------------------------------------------------------
+* @description
+* Recursively checks whether a value is **deeply empty**.
+*
+* - Returns `true` for:
+*    - Empty objects: `{}`
+*    - Empty arrays: `[]`
+*    - Nested empty structures: `{ a: [], b: {} }`
+*    - Falsy values (except numbers): `null`, `undefined`, `false`, `""`, `NaN`
+*
+* - Returns `false` for:
+*    - Non-zero numbers
+*    - Objects or arrays containing non-empty values
+*    - Non-empty strings, `true`, functions, symbols, etc.
+*
+* @param {*} value - The value to deeply check.
+* @returns {boolean} `true` if the value is deeply empty, otherwise `false`.
+* @example
+* isEmptyDeep({});
+* // ➔ true
+* isEmptyDeep([]);
+* // ➔ true
+* isEmptyDeep({ a: {} });
+* // ➔ true
+* isEmptyDeep([[], {}]);
+* // ➔ true
+* isEmptyDeep({ a: [1] });
+* // ➔ false
+* isEmptyDeep([0]);
+* // ➔ false
+* isEmptyDeep("test");
+* // ➔ false
+* isEmptyDeep("");
+* // ➔ true
+* isEmptyDeep(0);
+* // ➔ false
+* isEmptyDeep(NaN);
+* // ➔ true
+*/
+declare const isEmptyDeep:(value:unknown)=>boolean;type IsEmptyObjectOptions={
+/** Whether to check for symbol properties in addition to string keys.
+*
+* DefaultValue: `false`.
+*
+* @default false
+*/
+checkSymbols?:boolean;};
+/** ----------------------------------------------------------
+* * ***Predicate: `isEmptyObject`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a plain object with **no own enumerable string-key properties**,
+* and optionally **no own enumerable symbol-key properties** when `checkSymbols` is `true`.
+*
+* - If the value is **not an object** (e.g. `null`, array, primitive), it is considered empty.
+* - If `options.checkSymbols` is `true`, symbol properties are also checked.
+*
+* @param {*} value - The value to check.
+* @param {IsEmptyObjectOptions} [options] - Optional settings.
+* @param {boolean} [options.checkSymbols=false] - Whether to also check symbol properties.
+* @returns {boolean} Return `true` if the value is considered empty or not an object, false otherwise.
+* @example
+* isEmptyObject({});
+* // ➔ true
+* isEmptyObject({}, { checkSymbols: true });
+* // ➔ true
+* isEmptyObject({ a: 1 });
+* // ➔ false
+* isEmptyObject({ [Symbol('s')]: 1 });
+* // ➔ true
+* isEmptyObject({ [Symbol('s')]: 1 }, { checkSymbols: true });
+* // ➔ false
+* isEmptyObject(null);
+* // ➔ true (not object)
+* isEmptyObject([]);
+* // ➔ true (not plain object)
+* isEmptyObject(123);
+* // ➔ true (not object)
+*/
+declare function isEmptyObject(value:unknown,options?:IsEmptyObjectOptions):boolean;type IsEmptyStringOptions={
+/** Whether to trim the string before checking.
+*
+* DefaultValue: `true`.
+*
+* @default `true` */
+trim?:boolean;};
+/** ----------------------------------------------------------
+* * ***Predicate: `isEmptyString`.***
+* ----------------------------------------------------------
+* @description Checks whether a given value is an **empty string**.
+*
+* - Considers `""` and whitespace-only strings as empty (if `trim` is enabled, which is the default).
+* - Non-string inputs are also considered empty.
+*
+* @param {*} [value] - The value to check.
+* @param {IsEmptyStringOptions | undefined} [options] - Optional settings.
+* @param {boolean} [options.trim=true] - Whether to trim the string before checking, defaultValue `true`.
+* @returns {boolean} Returns `true` if the value is string not a string or value string is considered empty.
+* @example
+* isEmptyString("");
+* // ➔ true
+* isEmptyString("   ");
+* // ➔ true (default trims)
+* isEmptyString("   ", { trim: false });
+* // ➔ false
+* isEmptyString("hello");
+* // ➔ false
+* isEmptyString(undefined);
+* // ➔ true
+* isEmptyString(null);
+* // ➔ true
+* isEmptyString(123 as any);
+* // ➔ true
+*
+* // Used in validation
+* if (isEmptyString(form.name)) {
+*   throw new Error("Name cannot be empty.");
+* }
+*/
+declare const isEmptyString:(value:unknown,options?:IsEmptyStringOptions)=>boolean;type IsEmptyValueOptions={
+/** Whether to check symbol properties when checking empty objects.
+*
+* DefaultValue: `false`.
+*
+* @default false
+*/
+checkSymbols?:boolean;};
+/** ----------------------------------------------------------
+* * ***Predicate: `isEmptyValue`.***
+* ----------------------------------------------------------
+* @description Determines if a value is **`empty`**, covering:
+*
+* - Empty objects: `{}`
+* - Empty arrays: `[]`
+* - Empty strings: `""` or whitespace-only (trimmed)
+* - `null`, `undefined`, `false`, or `NaN`
+*
+* Returns **`false`** for:
+* - Non-empty objects/arrays
+* - Non-empty strings
+* - Numbers (except `NaN`)
+* - Functions, `true`, symbols, etc.
+*
+* @param {*} value - The value to evaluate.
+* @param {IsEmptyValueOptions} options - Optional settings.
+* @returns {boolean} Return `true` if the value is considered empty, otherwise `false`.
+*
+* @example
+* isEmptyValue({});
+* // ➔ true
+* isEmptyValue([]);
+* // ➔ true
+* isEmptyValue({ key: "value" });
+* // ➔ false
+* isEmptyValue({ [Symbol("foo")]: 123 });
+* // ➔ true (default `checkSymbols` is `false`)
+* isEmptyValue({ [Symbol("foo")]: 123 }, { checkSymbols: false });
+* // ➔ true (default `checkSymbols` is `false`)
+* isEmptyValue({ [Symbol("foo")]: 123 }, { checkSymbols: true });
+* // ➔ false
+* isEmptyValue([1, 2, 3]);
+* // ➔ false
+* isEmptyValue(NaN);
+* // ➔ true
+* isEmptyValue(true);
+* // ➔ false
+* isEmptyValue(false);
+* // ➔ true
+* isEmptyValue(null);
+* // ➔ true
+* isEmptyValue(undefined);
+* // ➔ true
+* isEmptyValue("");
+* // ➔ true
+* isEmptyValue("   ");
+* // ➔ true
+* isEmptyValue(0);
+* // ➔ false
+* isEmptyValue(-1);
+* // ➔ false
+* isEmptyValue(2);
+* // ➔ false
+* isEmptyValue(() => {});
+* // ➔ false
+*/
+declare const isEmptyValue:(value:unknown,options?:IsEmptyValueOptions)=>boolean;
+/** ----------------------------------------------------
+* * ***Performs a deep comparison between two values to determine if they are equivalent.***
+* ----------------------------------------------------------
+* @description
+* Checks whether two values are **deeply equal**, not just reference-equal (`===`).
+*
+*  - This method compares:
+*    - Arrays and TypedArrays
+*    - ArrayBuffers
+*    - Plain objects (`Object`) → own enumerable properties only
+*    - Booleans, Numbers, Strings, Symbols
+*    - Dates
+*    - Errors
+*    - Maps
+*    - Sets
+*    - Regular expressions
+*
+* ❌ Functions and DOM nodes are **not supported**.
+*
+* @param {*} value The value to compare.
+* @param {*} other The other value to compare.
+* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+* @example
+* const obj1 = { user: "fred" };
+* const obj2 = { user: "fred" };
+*
+* isEqual(obj1, obj2);
+* // ➔ true
+* obj1 === obj2;
+* // ➔ false (different references)
+* isEqual([1, 2, 3], [1, 2, 3]);
+* // ➔ true
+* isEqual(new Date("2020-01-01"), new Date("2020-01-01"));
+* // ➔ true
+* isEqual(new Set([1, 2]), new Set([2, 1]));
+* // ➔ true
+* isEqual(/abc/i, new RegExp("abc", "i"));
+* // ➔ true
+* isEqual({ a: 1 }, { a: 1, b: undefined });
+* // ➔ false
+*/
+declare function isEqual(value:unknown,other:unknown):boolean;
+/** ----------------------------------------------------
+* * ***Performs a deep comparison between two values with support for a customizer function.***
+* ----------------------------------------------------
+* @description
+* This method is like **{@link isEqual}** except that it accepts a `customizer`
+* which is invoked to compare values.
+* - If `customizer` returns `undefined`,
+* the comparison is handled by the default deep equality algorithm.
+*
+* - The `customizer` is invoked with up to six arguments:
+*   - `(value, other, indexOrKey, parent, otherParent, stack)`.
+*
+* - Supports comparing arrays, objects, maps, sets, dates, regexes, typed arrays, etc.
+* - Functions and DOM nodes are **not** supported.
+*
+* @param {*} value The value to compare.
+* @param {*} other The other value to compare.
+* @param {IsEqualCustomizer} [customizer] The function to customize comparisons.
+* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+* @example
+* function isGreeting(value: unknown) {
+*   return typeof value === "string" && /^h(?:i|ello)$/.test(value);
+* }
+*
+* function customizer(objValue: unknown, othValue: unknown) {
+*   if (isGreeting(objValue) && isGreeting(othValue)) {
+*     return true;
+*   }
+* }
+*
+* const array = ["hello", "goodbye"];
+* const other = ["hi", "goodbye"];
+*
+* console.log(isEqualWith(array, other, customizer));
+* // ➔ true
+*/
+declare function isEqualWith(value:unknown,other:unknown,customizer?:IsEqualCustomizer):boolean;
+/** ----------------------------------------------------------
+* * ***Type guard: `isError`.***
+* ----------------------------------------------------------
+* @description Checks whether the given value is an **`Error` object**.
+*
+* - ✅ Ensures that the provided value is a valid JavaScript error instance.
+* - ✅ Useful in TypeScript for narrowing types during error handling.
+*
+* @param {*} error - The value to check.
+* @returns {boolean} Returns `true` if `value` is instance of **[Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)**, else `false`.
+* @example
+* isError(new Error("Something went wrong"));
+* // ➔ true
+* isError("Error message");
+* // ➔ false
+* isError(null);
+* // ➔ false
+*/
+declare const isError:(error:unknown)=>error is Error;
+/** -----------------------------------------------------------------------------
+* * ***Checks if a value is a finite primitive number.***
+* -----------------------------------------------------------------------------
+* @description
+* This function verifies that `value` is a **primitive number** and is **finite**
+* (i.e., not `NaN`, `Infinity`, or `-Infinity`).
+*
+* - Behaves like [`Number.isFinite()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite).
+* - But also works as a **TypeScript type guard**.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if `value` is a finite primitive number, else `false`.
+*
+* @example
+* import * as RzlUtilsJs from "@rzl-zone/utils-js";
+*
+* // Strict finite number check (only primitive numbers)
+* RzlUtilsJs.isFinite(3);
+* // ➔ true
+* RzlUtilsJs.isFinite(Number.MIN_VALUE);
+* // ➔ true
+* RzlUtilsJs.isFinite("3");
+* // ➔ false (string is not a number)
+* RzlUtilsJs.isFinite(NaN);
+* // ➔ false
+* RzlUtilsJs.isFinite(Infinity);
+* // ➔ false
+* RzlUtilsJs.isFinite(new Number(3));
+* // ➔ false (Number object is not primitive)
+*
+* // Comparison with global isFinite()
+* isFinite("3");
+* // ➔ true (global coerces string to number)
+* isFinite(new Number(3));
+* // ➔ true (object coerced to primitive number)
+*/
+declare function isFinite(value:unknown):value is number;
+/** ----------------------------------------------------------
+* * ***Type guard: `isFunction`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a function.
+* - Uses `typeof value === "function"` for strict type checking.
+* - Supports TypeScript type narrowing with `value is (...args: any[]) => any`.
+* - Safe alternative to `Function` type (doesn't trigger ESLint warning).
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if the value is a function.
+*
+* @example
+* isFunction(() => {});
+* // ➔ true
+* isFunction(async () => {});
+* // ➔ true
+* isFunction(null);
+* // ➔ false
+* isFunction({});
+* // ➔ false
+*/
+declare const isFunction:(value:unknown)=>value is AnyFunction;
+/** ----------------------------------------------------
+* * ***Type guard: `isInteger`.***
+* ----------------------------------------------------------
+* @description Checks if a value is an integer.
+*
+* **Note:** This method is based on
+* [`Number.isInteger`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger).
+*
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is an integer, else `false`.
+* @example
+* isInteger(3);
+* // ➔ true
+* isInteger(Number.MIN_VALUE);
+* // ➔ false
+* isInteger(NaN);
+* // ➔ false
+* isInteger(Infinity);
+* // ➔ false
+* isInteger(-Infinity);
+* // ➔ false
+* isInteger('3');
+* // ➔ false
+*/
+declare function isInteger(value:unknown):value is number;
+/** ----------------------------------------
+* * ***Type guard: `isLength`.***
+* ----------------------------------------------------------
+* @description Checks whether the given value is a **valid array-like length**.
+*
+* - ✅ Ensures the value is a **non-negative integer**.
+* - ✅ Ensures the value is **not greater than `Number.MAX_SAFE_INTEGER`**.
+* - ❌ Excludes non-numeric values, `Infinity`, and fractional numbers.
+*
+* **Note:** This method is loosely based on
+* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+*
+* A valid length must be a non-negative integer
+* and **not greater than `Number.MAX_SAFE_INTEGER`**.
+*
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+* @example
+* isLength(3);
+* // ➔ true
+* isLength(Number.MAX_SAFE_INTEGER);
+* // ➔ true
+* isLength(Number.MAX_SAFE_INTEGER + 1);
+* // ➔ false
+* isLength("3");
+* // ➔ false
+* isLength(-1);
+* // ➔ false
+* isLength(3.14);
+* // ➔ false
+* isLength(Infinity);
+* // ➔ false
+* isLength(-Infinity);
+* // ➔ false
+* isLength(Number.MIN_VALUE);
+* // ➔ false
+*/
+declare function isLength(value:unknown):boolean;
+/** --------------------------------------------------
+* * ***Type guard: `isMap`.***
+* ----------------------------------------------------------
+* @description Checks whether the given value is a **`Map` object**.
+*
+* - Ensures that the provided value is an instance of **[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)**.
+* - Useful in TypeScript for narrowing types when working with collections.
+*
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is instance of **[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)**, else `false`.
+* @example
+* isMap(new Map());
+* // ➔ true
+* isMap(new WeakMap());
+* // ➔ false
+* isMap({});
+* // ➔ false
+*/
+declare function isMap<K=unknown,V=unknown>(value:Map<K,V>):value is Map<K,V>;declare function isMap(value:unknown):value is Map<unknown,unknown>;
+/** ----------------------------------------------------
+* * ***Performs a partial deep comparison between `object` and `source`.***
+* ----------------------------------------------------
+* @description Determines whether `object` contains equivalent property values from `source`.
+*
+* - ✅ Returns `true` if **all properties** in `source` exist in `object` and are deeply equal.
+* - ❌ Does **not** require `object` and `source` to be the same shape—`object` may have extra properties.
+* - ⚠️ Arrays are treated as objects: only matching indexed keys are compared.
+*
+* @remarks
+* - This is functionally equivalent to a partially applied `matches(source)` predicate.
+* - Special cases:
+*   - An empty array (`[]`) in `source` matches any array in `object`.
+*   - An empty object (`{}`) in `source` matches any object in `object`.
+* @param {object} object - The object to inspect.
+* @param {object} source - The object containing property values to match.
+* @returns {boolean} Returns `true` if `object` is a match, else `false`.
+* @example
+* const object = { a: 1, b: 2 };
+*
+* isMatch(object, { b: 2 });
+* // ➔ true
+* isMatch(object, { b: 1 });
+* // ➔ false
+* isMatch([1, 2, 3], [1, 2]);
+* // ➔ true (treats arrays as objects with index keys)
+*/
+declare function isMatch(object:object,source:object):boolean;
+/** ----------------------------------------------------
+* * ***Performs a partial deep comparison between `object` and `source`,
+*   like `isMatch`, but with a `customizer` function to control comparisons.***
+* ----------------------------------------------------
+* If `customizer` returns a value other than `undefined`, that value is used
+* as the result of the comparison for the current property. Otherwise,
+* the comparison falls back to the default deep equality logic.
+*
+* @remarks
+* - The `customizer` function is invoked with up to **five** arguments:
+*   `(objValue, srcValue, keyOrIndex, object, source)`.
+* - Returning `true` from `customizer` will short-circuit further comparison
+*   for that key.
+* - Returning `false` will cause `isMatchWith` to return `false` immediately.
+* - Returning `undefined` allows default comparison to proceed.
+* @param {*} value - The object to inspect.
+* @param {*} other - The object of property values to match.
+* @param {isMatchWithCustomizer} customizer - The function to customize comparisons.
+* @returns Returns `true` if `object` is a match, else `false`.
+*
+* @example
+* function isGreeting(value: unknown) {
+*   return typeof value === 'string' && /^h(?:i|ello)$/.test(value);
+* }
+*
+* function customizer(objValue: unknown, srcValue: unknown) {
+*   if (isGreeting(objValue) && isGreeting(srcValue)) {
+*     return true;
+*   }
+* }
+*
+* const object = { greeting: 'hello' };
+* const source = { greeting: 'hi' };
+*
+* isMatchWith(object, source, customizer);
+* // ➔ true
+*/
+declare function isMatchWith(value:object,other:object,customizer?:isMatchWithCustomizer):boolean;
+/** ----------------------------------------------------
+* * ***Type guard: `isNaN`.***
+* ----------------------------------------------------
+* @description Checks if a value is [`NaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).
+*
+* **Note:** This method is based on [`Number.isNaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN)
+* and is **not** the same as the global [`isNaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN),
+* which returns `true` for `undefined` and other non-number values.
+*
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+* @example
+* import * as RzlUtilsJs from "@rzl-zone/utils-js";
+*
+* RzlUtilsJs.isNaN(NaN);
+* // ➔ true
+* RzlUtilsJs.isNaN(new Number(NaN));
+* // ➔ true
+* RzlUtilsJs.isNaN(undefined);
+* // ➔ false
+*
+* // This global isNaN:
+* isNaN(undefined);
+* // ➔ true
+*/
+declare function isNaN(value:unknown):boolean;
+/** ----------------------------------------------------
+* * ***Type guard: `isNative`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a **pristine native function**.
+*
+* **Note:**
+*    - This method may not reliably detect native functions when using packages
+* like `core-js`, as they override native behavior.
+*    - Attempts to detect native functions
+* in such environments may fail or throw errors.
+*    - This also affects packages like
+* [babel-polyfill](https://www.npmjs.com/package/babel-polyfill).
+*
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a native function,
+*  else `false`.
+* @example
+* isNative(Array.prototype.push);
+* // ➔ true
+*
+* import * as RzlUtilsJs from "@rzl-zone/utils-js";
+* isNative(RzlUtilsJs);
+* // ➔ false
+*/
+declare function isNative(value?:unknown):value is AnyFunction;
+/** ----------------------------------------------------
+* * ***Type guard: `isNil`.***
+* ----------------------------------------------------------
+* @description Checks if a value is `null` or `undefined`.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is `null` or `undefined`, otherwise `false`.
+* @example
+* isNil(null);
+* // ➔ true
+* isNil(undefined);
+* // ➔ true
+* isNil(void 0);
+* // ➔ true
+* isNil(NaN);
+* // ➔ false
+*/
+declare function isNil(value?:unknown):value is null|undefined;
+/** ----------------------------------------------------------
+* * ***Type guard: `isNonEmptyArray`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a **non-empty array**.
+*
+* - Ensures the value is an actual array using **[`Array.isArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)**.
+* - Ensures the array contains at least one item.
+* - Narrows type to `T[]` (non-empty array) when true.
+*
+* @template T - The type of the value being checked.
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if value is a non-empty array.
+*
+* @example
+* isNonEmptyArray([1, 2, 3]); // ➔ true
+* isNonEmptyArray([]);        // ➔ false
+* isNonEmptyArray(null);      // ➔ false
+* isNonEmptyArray("test");    // ➔ false
+*/
+declare function isNonEmptyArray(value:[]):value is [];declare function isNonEmptyArray<T extends unknown[]>(value:T):value is NonNullable<Extract<T,unknown[]>>;declare function isNonEmptyArray(value:unknown):value is unknown[];type IsNonEmptyStringOptions={
+/**
+* Whether to trim the string before checking.
+*
+* @default `true` */
+trim?:boolean;};
+/** ----------------------------------------------------------
+* * ***Type guard: `isNonEmptyString`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a **non-empty string**.
+*
+* Determines whether the given `value` is a string containing at least one non-whitespace character, with optional trimming behavior.
+*
+* - Ensures the value is a string using **{@link isString}**.
+* - Optionally trims whitespace before checking (`trim` defaults to `true`).
+* - Narrows type to `string` when true.
+*
+* @param {*} value - The value to test.
+* @param {IsNonEmptyStringOptions} options - Optional settings.
+* @param {boolean} options.trim - If `true`, trims the string before checking. Defaults to `true`.
+*
+* @returns {boolean} `true` if `value` is a non-empty string, otherwise `false`.
+*
+* @example
+* isNonEmptyString("hello");
+* // ➔ true
+* isNonEmptyString("   ", { trim: true });
+* // ➔ false
+* isNonEmptyString("   ", { trim: false });
+* // ➔ true
+* isNonEmptyString("");
+* // ➔ false
+* isNonEmptyString(123);
+* // ➔ false
+* isNonEmptyString(undefined);
+* // ➔ false
+* isNonEmptyString(null);
+* // ➔ false
+* isNonEmptyString({});
+* // ➔ false
+* isNonEmptyString([]);
+* // ➔ false
+*/
+declare const isNonEmptyString:(value:unknown,options?:IsNonEmptyStringOptions)=>value is string;type IsNonEmptyValueOptions={
+/**
+* Whether to check symbol properties when checking empty objects.
+* @default false
+*/
+checkSymbols?:boolean;};
+/** ----------------------------------------------------------
+* * ***Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items)
+* or generally truthy.***
+* ----------------------------------------------------------
+*
+* - Returns `true` for objects with properties, non-empty arrays, numbers (except NaN), functions, `true`, and other truthy values.
+* - Returns `false` for `{}`, `[]`, `null`, `undefined`, `""`, `"  "`, `false`, and `NaN`.
+* - Safely handles `null`, `undefined`, and non-object types without throwing.
+*
+* - Returns `true` for `{}`, `[]`, `null`, `undefined`, `""`, `"  "`, `false`, and `NaN`.
+* - Returns `false` for objects with properties, non-empty arrays, numbers, functions, `true` (Truthy) and other non-empty values.
+* - Safely handles `null`, `undefined`, and non-object types without throwing.
+*
+* @param {*} value - The value to evaluate.
+* @param {IsNonEmptyValueOptions} options - Optional settings.
+* @returns `true` if the value is considered non-empty/truthy, otherwise `false`.
+*
+* @example
+* isNonEmptyValue({});
+* // ➔ false
+* isNonEmptyValue([]);
+* // ➔ false
+* isNonEmptyValue({ key: "value" });
+* // ➔ true
+* isNonEmptyValue({ [Symbol("foo")]: 123 });
+* // ➔ false (default `checkSymbols` is `false`)
+* isNonEmptyValue({ [Symbol("foo")]: 123 }, { checkSymbols: false });
+* // ➔ false (default `checkSymbols` is `false`)
+* isNonEmptyValue({ [Symbol("foo")]: 123 }, { checkSymbols: true });
+* // ➔ true
+* isNonEmptyValue([1, 2, 3]);
+* // ➔ true
+* isNonEmptyValue(NaN);
+* // ➔ false
+* isNonEmptyValue(true);
+* // ➔ true
+* isNonEmptyValue(false);
+* // ➔ false
+* isNonEmptyValue(null);
+* // ➔ false
+* isNonEmptyValue(undefined);
+* // ➔ false
+* isNonEmptyValue("");
+* // ➔ false
+* isNonEmptyValue("   ");
+* // ➔ false
+* isNonEmptyValue(0);
+* // ➔ true
+* isNonEmptyValue(-1);
+* // ➔ true
+* isNonEmptyValue(2);
+* // ➔ true
+* isNonEmptyValue(() => {});
+* // ➔ true
+*/
+declare const isNonEmptyValue:(value:unknown,options?:IsNonEmptyValueOptions)=>boolean;
+/** ---------------------------------------------------------
+* * ***Type guard: `isNull`.***
+* ----------------------------------------------------------
+* @description Checks if a value is **[`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/null)**.
+*
+* - Strictly compares the value against `null`.
+* - Narrows type to `null` when true.
+*
+* @param {*} val - The value to check.
+* @returns {val is null} Returns `true` if the value is `null`, otherwise `false`.
+*
+* @example
+* isNull(null);      // ➔ true
+* isNull(0);         // ➔ false
+* isNull(undefined); // ➔ false
+*/
+declare const isNull:(val:unknown)=>val is null;type HasKeys$1<T>=keyof T extends never?false:true;type IsObject<T>=unknown extends T?T & Record<PropertyKey,unknown>:T extends object?T extends AnObjectNonArray?T:HasKeys$1<T>extends false?T & Record<PropertyKey,unknown>:IsArray<T>extends true?Exclude<T,unknown[]>:T:never;
+/** ---------------------------------------------------------
+* * ***Type guard: `isObject`.***
+* ----------------------------------------------------------
+* @description
+* Checks if a value is an **object** (excluding `null` and arrays).
+*
+* - ✅ Returns `true` for any non-null object (arrays excluded), including:
+*    - Plain objects (`{}`, `Object.create(null)`)
+*    - Custom class instances
+*    - Built-ins: `Date`, `RegExp`, `Error`, `URL`, `URLSearchParams`
+*    - Collections: `Map`, `Set`, `WeakMap`, `WeakSet`
+*    - Binary/typed data: `ArrayBuffer`, `DataView`, typed arrays (`Uint8Array`, `Int32Array`, etc.)
+*    - DOM/Node objects: `HTMLElement`, `DocumentFragment`, etc.
+*    - Proxies (wrapping any object type)
+* ---------------------------------------------------------
+* - ❌ Returns `false` for:
+*    - `null`
+*    - Arrays (`[]`, `new Array()`)
+*    - Functions (regular functions, arrow functions, class constructors)
+*    - Primitives: `string`, `number`, `boolean`, `symbol`, `bigint`
+*    - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`
+*    - `undefined` (including `NaN`, which is a primitive number)
+*
+* Note: If you specifically need to check for ***plain objects***, use **{@link isPlainObject}** instead.
+*
+* @template T - The type of the value being checked.
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is a plain object, otherwise `false`.
+*
+* @example
+* isObject({});                  // ➔ true
+* isObject(Object.create(null)); // ➔ true
+* isObject(new Date());          // ➔ true
+* isObject(new Map());           // ➔ true
+* isObject(new Uint8Array());    // ➔ true
+* isObject(new String("x"));     // ➔ true
+* isObject([]);                  // ➔ false
+* isObject(null);                // ➔ false
+* isObject(undefined);           // ➔ false
+* isObject(123);                 // ➔ false
+* isObject(() => {});            // ➔ false
+*/
+declare function isObject<T extends object>(value:T):value is IsObject<T>;declare function isObject(value:unknown):value is Record<PropertyKey,unknown>;
+/** ----------------------------------------------------------
+* * ***Type guard: `isObjectLoose`.***
+* ----------------------------------------------------------
+* @description
+* Checks if a value is the
+* [ECMAScript language type **Object**](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types).
+*
+* - ✅ Returns `true` for:
+*    - Plain objects (`{}`)
+*    - Arrays (`[]`)
+*    - Functions
+*    - Regexes (`/abc/`)
+*    - Boxed primitives:
+*      - `new Number(0)`
+*      - `new String("")`
+*      - `new Boolean(false)`
+*  ----------------------------
+* - ❌ Returns `false` for:
+*    - `null`
+*    - `undefined`
+*    - Primitives:
+*      - `string`
+*      - `number`
+*      - `boolean`
+*      - `symbol`
+*      - `bigint`
+*
+* @note ⚠️ **For More Strict Object Use {@link isObject} or {@link isPlainObject} instead.**
+*
+* @template T - The type of the value being checked.
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+* @example
+* isObjectLoose({});
+* // ➔ true
+* isObjectLoose([1, 2, 3]);
+* // ➔ true
+* isObjectLoose(()=> {});
+* // ➔ true
+* isObjectLoose(null);
+* // ➔ false
+* isObjectLoose(undefined);
+* // ➔ false
+*/
+declare function isObjectLoose<T=object>(value:unknown):value is T;type HasKeys<T>=keyof T extends never?false:true;type IsObjectOrArray<T>=OrArr<[ IsNever<T>,Extends<T,Record<PropertyKey,unknown>>,Extends<unknown,T>]>extends true?T & Record<PropertyKey,unknown>& unknown[]:T extends object?T extends unknown[]?T:T extends AnObjectNonArray?T:HasKeys<T>extends false?T & Record<PropertyKey,unknown>:T:Extract<T,Record<PropertyKey,unknown>& unknown[]>;
+/** ---------------------------------------------------------
+* * ***Type guard: `isObjectOrArray`.***
+* ----------------------------------------------------------
+* @description
+* Checks if a value is an **object** or an **array**.
+*
+* - ✅ Returns `true` for:
+*    - Plain objects (`{}`, `Object.create(null)`)
+*    - Custom objects
+*    - Arrays (`[]`, `[1,2,3]`)
+* ----------------------------
+* - ❌ Returns `false` for:
+*    - `null`
+*    - `undefined`
+*    - Primitives:
+*        - `string`
+*        - `number`
+*        - `boolean`
+*        - `symbol`
+*        - `bigint`
+*    - Functions
+*
+* @template T - The type of the value being checked.
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is an `object` or `array`.
+*
+* @example
+* isObjectOrArray({ name: "Alice" }); // ➔ true
+* isObjectOrArray([1,2,3]);           // ➔ true
+* isObjectOrArray(null);              // ➔ false
+* isObjectOrArray(undefined);         // ➔ false
+* isObjectOrArray("hello");           // ➔ false
+*/
+declare function isObjectOrArray(value:[]):value is [];declare function isObjectOrArray<T>(value:T):value is IsObjectOrArray<T>;
+/** ----------------------------------------------------------
+* * ***Type guard: `isRegExp`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a RegExp instance.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if value is an instance of **[RegExp](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp)**.
+*
+* @example
+* isRegExp(/abc/);             // ➔ true
+* isRegExp(new RegExp("abc")); // ➔ true
+* isRegExp("abc");             // ➔ false
+*/
+declare const isRegExp:(value:unknown)=>value is RegExp;
+/** --------------------------------------------------
+* * ***Checks if `value` is a **[`Safe-Integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger)**.***
+* --------------------------------------------------
+* An integer is considered *safe* if:
+* - It is an IEEE-754 **double precision number**.
+* - It can be exactly represented without rounding errors.
+* - It lies within the range **-(2^53 - 1) to 2^53 - 1**.
+*
+* **Note:** This method is based on **{@link Number.isSafeInteger}**.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if `value` is a safe integer, otherwise `false`.
+* @example
+* isSafeInteger(3);
+* // ➔ true
+* isSafeInteger(Number.MIN_VALUE);
+* // ➔ false
+* isSafeInteger(Infinity);
+* // ➔ false
+* isSafeInteger('3');
+* // ➔ false
+*/
+declare function isSafeInteger(value:unknown):value is number;
+/** ---------------------------------------------------------
+* * ***Type guard: `isSet`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a **[`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set)** object.
+*
+* - Narrows type to `Set<T>` when true.
+* - Excludes `WeakSet`, arrays, plain objects, and other non-Set values.
+*
+* @template T - The type of the value being checked.
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is a `Set`, otherwise `false`.
+* @example
+* isSet(new Set);
+* // ➔ true
+* isSet(new WeakSet);
+* // ➔ false
+*/
+declare function isSet<T=unknown>(value:Set<T>):value is Set<T>;declare function isSet(value:unknown):value is Set<unknown>;
+/** ---------------------------------------------------------
+* * ***Type guard: `isString`.***
+* ----------------------------------------------------------
+* @description Checks if a value is of type
+* **[`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**.
+*
+* - Uses the `typeof` operator for strict checking.
+* - Narrows type to `string` when true.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is a string, otherwise `false`.
+*
+* @example
+* isString("hello"); // ➔ true
+* isString(123);     // ➔ false
+*
+* // Usage in type narrowing
+* const value: unknown = getValue();
+* if (isString(value)) {
+*   // TypeScript now knows `value` is a string
+*   console.log(value.toUpperCase());
+* }
+*/
+declare const isString:(value:unknown)=>value is string;
+/** ----------------------------------------------------------
+* * ***Type guard: `isSymbol`.***
+* ----------------------------------------------------------
+* @description Checks if a value is of type
+* **[`symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/Symbol)**.
+*
+* - Uses the `typeof` operator for strict checking.
+* - Narrows type to `symbol` when true.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is a symbol, otherwise `false`.
+*
+* @example
+* isSymbol(Symbol("id"));   // ➔ true
+* isSymbol("not a symbol"); // ➔ false
+* isSymbol(123);            // ➔ false
+* isSymbol(undefined);      // ➔ false
+*/
+declare const isSymbol:(value:unknown)=>value is symbol;
+/** --------------------------------------------------
+* * ***Type guard: `isTypedArray`.***
+* ----------------------------------------------------------
+* @description Checks if `value` is classified as a
+* **[TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.
+*
+* - Validates that `value` is a non-null object.
+* - Uses `Object.prototype.toString` tag matching against known typed array tags.
+* - Narrows type to **{@link TypedArray}** when true.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.
+* @example
+* isTypedArray(new Uint8Array);          // ➔ true
+* isTypedArray(new Uint8Array());        // ➔ true
+* isTypedArray(new Float32Array());      // ➔ true
+* isTypedArray(new Uint8ClampedArray()); // ➔ true
+* isTypedArray([]);                      // ➔ false
+* isTypedArray(Buffer.from("hi"));       // ➔ false
+*/
+declare function isTypedArray(value:unknown):value is TypedArray;
+/** ---------------------------------------------------------
+* * ***Type guard: `isURL`.***
+* ----------------------------------------------------------
+* @description Checks if a value is an instance of the
+* **[`URL`](https://developer.mozilla.org/docs/Web/API/URL)** class.
+*
+* - Narrows type to `URL` when true.
+* - Excludes strings, plain objects, and other non-URL values.
+*
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.
+*
+* @example
+* isURL(new URL("https://example.com"));
+* // ➔ true
+* isURL("https://example.com");
+* // ➔ false
+*/
+declare const isURL:(value:unknown)=>value is URL;
+/** ---------------------------------------------------------
+* * ***Type guard: `isUndefined`.***
+* ----------------------------------------------------------
+* @description Checks if a value is
+* **[`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)**.
+*
+* - Narrows type to `undefined` when true.
+* - Excludes `null`, objects, arrays, strings, numbers, and all other values.
+*
+* @param {*} value - The value to check.
+* @returns {value is undefined} Returns `true` if the value is `undefined`, otherwise `false`.
+* @example
+* isUndefined(undefined); // ➔ true
+* isUndefined([]);        // ➔ false
+* isUndefined(123);       // ➔ false
+* isUndefined(null);      // ➔ false
+* isUndefined("abc");     // ➔ false
+*/
+declare const isUndefined:(value:unknown)=>value is undefined;
+/** ---------------------------------
+* * ***Validates whether a given string is a properly formatted URL.***
+* ---------------------------------------------------------
+*
+* Ensures that the input is:
+* - A non-empty string.
+* - A valid **[URL](https://developer.mozilla.org/docs/Web/API/URL)** with `http://` or `https://` scheme.
+*
+* @description
+* - ✅ Includes decoding for percent-encoded URLs (e.g., `https%3A%2F%2F...`).
+* - ❌ Rejects invalid strings, unsupported schemes, and malformed domains.
+*
+* @param {*} url - The value to validate.
+* @returns {boolean} Return `true` if the value is a **valid URL string**, otherwise `false`.
+* @example
+* isValidURL("https://example.com");
+* // ➔ true
+*
+* isValidURL("ftp://example.com");
+* // ➔ false
+*
+* isValidURL("not-a-url");
+* // ➔ false
+*/
+declare const isValidURL:(url:unknown)=>boolean;
+/** --------------------------------------------------
+* * ***Type guard: `isWeakMap`.***
+* ----------------------------------------------------------
+* @description Checks if a value is a **[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/WeakMap)** object.
+*
+* - Narrows type to `WeakMap<K, V>` when true.
+* - Excludes `Map`, arrays, plain objects, and other non-WeakMap values.
+*
+* @template K - Keys must be objects.
+* @template V - Type of values stored in the WeakMap.
+* @param {*} value - The value to check.
+* @returns {boolean} Returns `true` if the value is a `WeakMap`, otherwise `false`.
+* @example
+*
+* isWeakMap(new WeakMap);
+* // ➔ true
+* isWeakMap(new Map);
+* // ➔ false
+*/
+declare function isWeakMap<K extends object=object,V=unknown>(value:unknown):value is WeakMap<K,V>;export{type IsArrayResult,IsPlainObjectResult,areArraysEqual,areObjectsEqual,areURLsEqualPath,areURLsIdentical,arrayHasAnyMatch,doesKeyExist,hasOwnProp,isArguments,isArray,isArrayBuffer,isArrayLike,isArrayLikeObject,isBigInt,isBoolean,isBuffer,isCurrencyLike,isDate,isDeepEqual,isElement,isEmpty,isEmptyArray,isEmptyDeep,isEmptyObject,isEmptyString,isEmptyValue,isEqual,isEqualWith,isError,isFinite,isFunction,isInteger,isLength,isMap,isMatch,isMatchWith,isNaN,isNative,isNil,isNonEmptyArray,isNonEmptyString,isNonEmptyValue,isNull,isObject,isObjectLoose,isObjectOrArray,isRegExp,isSafeInteger,isSet,isString,isSymbol,isTypedArray,isURL,isUndefined,isValidURL,isWeakMap,textContainsAll,textContainsAny};