@rzl-zone/utils-js 3.0.2-beta.2 → 3.1.0-beta.2

package/dist/predicates/index.d.ts

@@ -1,220 +1,283 @@
-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;
+import{k as IsPositive,P as ParseNumber,I as IsStringLiteral,C as CharAt,d as IsUnknown,m as IsReadonlyArray,o as IsArray,f as OrArr}from'../is-array--YjXV-Wx.js';import{A as AnyString,a as IsEmptyString,T as Trim}from'../string-XA-til3C.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-Bk_SBGdT.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-BVhBAPHX.js';export{G as GetPreciseTypeOptions,I as IsNumberOptions,g as getPreciseType,i as isNumber,b as isPlainObject}from'../isPlainObject-BVhBAPHX.js';import{I as IsNever}from'../never-BfayMBF9.js';import'../if-CvT4R7Kh.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 CustomizerIsEqualWith=(value:unknown,other:unknown,indexOrKey:PropertyKey,parent:unknown,otherParent:unknown,stack:unknown)=>boolean|undefined;type CustomizerIsMatchWith=(value:unknown,other:unknown,indexOrKey:PropertyKey,object:object,source:object)=>boolean|undefined;
 /** ----------------------------------------------------------
-* * ***Compares two arrays deeply to check if they are equal.***
+* * ***Predicate: `areArraysEqual`.***
 * ----------------------------------------------------------
-*
-* Supports deep comparison of arrays containing nested arrays or objects.
-* Can also ignore the order of elements at all levels by recursively sorting.
-*
-* ----------------------------------------------------------
-*
+* **Compares two arrays deeply to check if they are equal.**
+* @description 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.
-*
+*   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`.
-*
+*   The second array to compare against. Should match structure of `array1`.
+* @param {boolean|undefined} [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
-*
+* // ➔ true
 * areArraysEqual([1, 2, 3], [3, 2, 1]);
-* // → false
-*
+* // ➔ false
 * areArraysEqual([1, 2, 3], [3, 2, 1], true);
-* // → true (order ignored)
-*
+* // ➔ true (order ignored)
 * areArraysEqual([{ x: 1 }, { y: 2 }], [{ y: 2 }, { x: 1 }], true);
-* // → true
+* // ➔ true
 * ```
 */
 declare const areArraysEqual:(array1:unknown[],array2:unknown[],ignoreOrder?:boolean)=>boolean;
 /** ---------------------------------
-* * ***Compares two objects for deep equality.***
+* * ***Predicate: `areObjectsEqual`.***
 * ---------------------------------
-*
+* **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`.
-*
+* @param {*} object1 - The first object to compare.
+* @param {*} object2 - The second object to compare.
+* @returns {boolean} Return `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
+* areObjectsEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
+* // ➔ true
+* areObjectsEqual({ a: 1 }, { a: 1, b: undefined });
+* // ➔ false
+* areObjectsEqual([1, 2, 3], [1, 2, 3]);
+* // ➔ true
 */
 declare const areObjectsEqual:(object1:unknown,object2:unknown)=>boolean;
 /** ---------------------------------
-* * ***Checks if two URLs are the same, ignoring query parameters.***
+* * ***Predicate: `areURLsEqualPath`.***
 * ---------------------------------
-*
-* This function compares only the protocol, host, and pathname.
-*
+* **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`.
+* @example
+* // Same domain, same path, different query -> true
+* areURLsEqualPath(new URL("https://example.com/page?a=1"), new URL("https://example.com/page?b=2"));
+* // ➔ true
+*
+* // Same domain, different path -> false
+* areURLsEqualPath(new URL("https://example.com/page1"), new URL("https://example.com/page2"));
+* // ➔ false
+*
+* // Different protocol -> false
+* areURLsEqualPath(new URL("http://example.com/page"), new URL("https://example.com/page"));
+* // ➔ false
+*
+* // Same protocol, same host, same path (ignores query & hash) -> true
+* areURLsEqualPath(new URL("https://example.com/page#section"), new URL("https://example.com/page"));
+* // ➔ true
 */
 declare const areURLsEqualPath:(urlA:URL,urlB:URL)=>boolean;
 /** ---------------------------------
-* * ***Checks if two URLs are exactly the same, including protocol, host, pathname, and query parameters.***
+* * ***Predicate: `areURLsIdentical`.***
 * ---------------------------------
-*
+* **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`.***
-* ----------------------------------------------------------
+* @example
+* // Identical URLs -> true
+* areURLsIdentical(new URL("https://example.com/page?a=1"), new URL("https://example.com/page?a=1"));
+* // ➔ true
 *
-* - ✅ 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).
+* // Same path, different query parameter -> false
+* areURLsIdentical(new URL("https://example.com/page?a=1"), new URL("https://example.com/page?b=2"));
+* // ➔ false
 *
-* @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`.
+* // Same host & query, but different protocol -> false
+* areURLsIdentical(new URL("http://example.com/page?a=1"), new URL("https://example.com/page?a=1"));
+* // ➔ 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`)
+* // Same everything except trailing slash -> false
+* areURLsIdentical(new URL("https://example.com/page"), new URL("https://example.com/page/"));
+* // ➔ false
+*/
+declare const areURLsIdentical:(urlA:URL,urlB:URL)=>boolean;type OptionsTextContainsAll={
+/** If `true`, matches whole words only, defaultValue is `false`.
+*
+* @default false
 */
-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;
+/** Optional regex flags (default: `"i"` for case-insensitive).
+*
+* @default "i"
+*/
+flags?:string;};
 /** ----------------------------------------------------------
-* * ***Checks if the given `text` contains at least one of the specified `searchWords`.***
+* * ***Predicate: `textContainsAll`.***
 * ----------------------------------------------------------
+* **Checks if the given `text` contains all of the specified `searchWords`.**
+* - **Behavior:**
+*    - Returns `false` if `text` or `searchWords` is `null`/`undefined`/invalid.
+*    - 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|null|undefined} text - The string text to search within.
+* @param {string[]|null} [searchWords] - An array of words/phrases to match against the text.
+* @param {OptionsTextContainsAll} [options] - Optional configuration object.
+* @param {OptionsTextContainsAll["exactMatch"]} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.
+* @param {OptionsTextContainsAll["flags"]} [options.flags="i"] - Optional regex flags (default: `"i"` for case-insensitive).
+* @returns {boolean} Return `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`)
+* textContainsAll(null, ["test"]);
+* // ➔ false (invalid text)
+* textContainsAll("Hello", null);
+* // ➔ false (invalid searchWords)
+*/
+declare const textContainsAll:<T extends string>(text?:T|null,searchWords?:T[]|string[]|null,options?:OptionsTextContainsAll)=>boolean;type OptionsTextContainsAny={
+/** If `true`, matches whole words only, defaultValue is `false`.
 *
-* - ✅ 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`.
+* @default false
+*/
+exactMatch?:boolean;
+/** Optional regex flags (default: `"i"` for case-insensitive).
 *
+* @default "i"
+*/
+flags?:string;};
+/** ----------------------------------------------------------
+* * ***Predicate: `textContainsAny`.***
+* ----------------------------------------------------------
+* **Checks if the given `text` contains at least one of the specified `searchWords`.**
+* - **Behavior:**
+*    - Returns `false` if `text` or `searchWords` is `null`/`undefined`/invalid.
+*    - 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|null|undefined} text - The string text to search within.
+* @param {string[]|null} [searchWords] - An array of words/phrases to match against the text.
+* @param {OptionsTextContainsAny} [options] - Optional configuration object.
+* @param {OptionsTextContainsAny["exactMatch"]} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.
+* @param {OptionsTextContainsAny["flags"]} [options.flags="i"] - Optional regex flags (default: `"i"` for case-insensitive).
+* @returns {boolean} Return `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`)
+* 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`)
+* textContainsAny(null, ["test"]);
+* // ➔ false (invalid text)
+* textContainsAny("Hello", null);
+* // ➔ false (invalid searchWords)
 */
-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;
+declare const textContainsAny:<T extends string>(text?:T|null,searchWords?:T[]|string[]|null,options?:OptionsTextContainsAny)=>boolean;
 /** ----------------------------------------------------------
-* * ***Recursively checks if a given key exists in an object or array.***
+* * ***Predicate: `doesKeyExist`.***
 * ----------------------------------------------------------
-*
-* - ✅ **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.
-*
+* **Recursively checks if a given key exists in an object or array.**
+* - **Behavior:**
+*    - **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
+* 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
+* 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
+* 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`.***
+* * ***Predicate: `arrayHasAnyMatch`.***
 * ----------------------------------------------------------
-*
-* - ✅ 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.
-*
+* **Checks if at least one element from `targetArray` exists in `sourceArray`.**
+* - **Behavior:**
+*    - 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.
-*
+* @param {T[] | null | undefined} sourceArray - The array to search within.
+* @param {T[] | null | undefined} targetArray - The array containing elements to match.
 * @returns {boolean}
-*    - `true` if **at least one element from `targetArray` is strictly found in `sourceArray`**.
+*  ***Return:***
+*  - `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.
-*
+*      - **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
+* 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)
+* 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)
+* 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)
+* arrayHasAnyMatch([arr], [arr]);
+* // ➔ true
+* arrayHasAnyMatch([[1, 2]], [[1, 2]]);
+* // ➔ false (different array object)
 */
-declare const arrayHasAnyMatch:<T>(sourceArray?:T[],targetArray?:T[])=>boolean;
+declare const arrayHasAnyMatch:<T>(sourceArray:T[]|null|undefined,targetArray:T[]|null|undefined)=>boolean;
 /** Restrict array indices to a fixed numeric range (1–25). */
 type ArrayIndex=NumberRangeUnion<1,25>;
 /** Remove `undefined` from a type. */
@@ -282,180 +345,160 @@ type DeepRequiredSymbolHasOwnProp<Obj,Sym extends symbol,DU extends boolean=true
 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.
+/** 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:**
+* - **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
+*     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.
+/** 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:**
+* - **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
+*     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**.***
+* * ***Utility: `hasOwnProp`.***
 * -------------------------------------------------------
-*
-* ---
-* #### 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**.
-*
-* ---
+* **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:
+*          1. `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:**
+*          1. 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 {HasOwnPropOptions} [options] - Optional configuration object.
+* @param {HasOwnPropOptions["discardUndefined"]} [options.discardUndefined=true]
+*  If `true`, properties with `undefined` values are treated as **missing**, default: `true`.
+* @param {HasOwnPropOptions["discardNull"]} [options.discardNull=false]
+*  If `true`, properties with `null` values are treated as **missing**, default: `false`.
+* @param {*} obj - The `object`, `array`, `string`, `function`, or `other value` to check against.
+* @param {PropertyKey} key
+*  The property key to check, can be:
+*    - `string` (supports dot/bracket paths, e.g. `"user.address.city"`, `"[0].id"`)
+*    - `number` (array-like index)
+*    - `symbol` (own property symbols)
+* @returns {boolean} Return `true` if the property exists (and passes `options`), otherwise `false`.
 * @example
 *
-* #### ✅ Objects
+* - #### ✅ Objects:
 * ```ts
-* const obj: { name?: string | null } = {};
+*    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")) {
+*      // 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
-* }
+*    if (hasOwnProp(obj, "name", { discardUndefined: true, discardNull: true })) {
+*      // obj is now ➔ { name: string }
+*      console.log(obj.name.toUpperCase()); // safe
+*    }
 * ```
-*
-* #### ✅ Arrays
+* - #### ✅ Arrays:
 * ```ts
-* const users = [{ id: 1 }, { id: 2 }];
+*    const users = [{ id: 1 }, { id: 2 }];
 *
-* if (hasOwnProp(users, "[1].id")) {
-*   // ➔ users[1].id is guaranteed to exist
-*   console.log(users[1].id); // number
-* }
+*    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!
-* }
+*    // ⚠️ 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
+*    // 👉 Solution: optional chaining
+*    console.log(users[1]?.id); // ➔ safe, even without narrowing
 * ```
 *
-* #### ✅ Symbols
+* - #### ✅ Symbols:
 * ```ts
-* const secret = Symbol("secret");
-* const obj2 = { [secret]: 42 };
+*    const secret = Symbol("secret");
+*    const obj2 = { [secret]: 42 };
 *
-* if (hasOwnProp(obj2, secret)) {
-*   console.log(obj2[secret] + 1); // ➔ 43
-* }
+*    if (hasOwnProp(obj2, secret)) {
+*      console.log(obj2[secret] + 1); // ➔ 43
+*    }
 * ```
-*
-* #### ✅ Strings
+* - #### ✅ Strings:
 * ```ts
-* if (hasOwnProp("hello", "length")) {
-*   console.log("hello".length); // ➔ 5
-* }
+*    if (hasOwnProp("hello", "length")) {
+*      console.log("hello".length); // ➔ 5
+*    }
 *
-* if (hasOwnProp("hello", 1)) {
-*   console.log("hello"[1]); // ➔ "e"
-* }
+*    if (hasOwnProp("hello", 1)) {
+*      console.log("hello"[1]); // ➔ "e"
+*    }
 * ```
-*
-*
-* #### ✅ Functions
+* - #### ✅ Functions:
 * ```ts
-* function fn() {}
-* fn.extra = 123;
+*    function fn() {}
+*    fn.extra = 123;
 *
-* if (hasOwnProp(fn, "extra")) {
-*   console.log(fn.extra); // ➔ 123
-* }
+*    if (hasOwnProp(fn, "extra")) {
+*      console.log(fn.extra); // ➔ 123
+*    }
 * ```
-*
-* #### ❌ Empty key
+* - #### ❌ Empty key:
 * ```ts
-* const obj = { a: 1 };
+*    const obj = { a: 1 };
 *
-* hasOwnProp(obj, "");        // ➔ false (invalid key)
-* hasOwnProp(obj, "   ");     // ➔ false (trimmed to empty)
+*    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>
@@ -474,11 +517,9 @@ declare function hasOwnProp<Obj>(obj:IsAny<Obj>extends true?Obj:never,key:Proper
 /** -------------------
 * * ***Type guard: `isArguments`.***
 * -------------------
-* @description Checks if `value` is likely an `arguments` object.
-*
+* **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`.
+* @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
@@ -491,12 +532,11 @@ type IsArrayResult<T>=IsUnknown<T>extends true?unknown[] & T:IsNever<T>extends t
 /** ----------------------------------------------------------
 * * ***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.
-*
+***Checks if a value is an ***[`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)***.**
+* - **Behavior:**
+*    - 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`.
@@ -518,9 +558,9 @@ declare function isArray<T extends unknown[]>(value:T):value is Extract<T,unknow
 /** ----------------------------------------------------
 * * ***Type guard: `isArrayBuffer`.***
 * ----------------------------------------------------
-* @description Checks if `value` is classified as an `ArrayBuffer` object.
+* **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`.
+* @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
@@ -531,10 +571,9 @@ 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
+* **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`.
-*
+* 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`.
@@ -552,7 +591,8 @@ declare function isArrayLike<T extends{__anyHack:unknown;}>(value:T):boolean;dec
 /** ----------------------------------------------------
 * * ***Type guard: `isArrayLikeObject`.***
 * ----------------------------------------------------
-* @description This method is like **{@link isArrayLike}** except that it also checks if `value` is an object.
+* **This method is like ***{@link isArrayLike | `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`.
@@ -570,11 +610,12 @@ declare function isArrayLikeObject<T extends{__anyHack:unknown;}>(value:T):boole
 /** ----------------------------------------------------------
 * * ***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))`.
-*
+* **Checks if a value is of type bigint.**
+* - **Behavior:**
+*    - 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
@@ -591,7 +632,7 @@ declare const isBigInt:(value:unknown)=>value is bigint;
 /** ----------------------------------------------------------
 * * ***Type guard: `isBoolean`.***
 * ----------------------------------------------------------
-* @description Checks if a value is of type boolean.
+* **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
@@ -603,9 +644,9 @@ declare const isBoolean:(value:unknown)=>value is boolean;
 /** ----------------------------------------------------
 * * ***Type guard: `isBuffer`.***
 * ----------------------------------------------------------
-* @description Checks if a value is a **Node.js Buffer** instance.
+* **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`.
+* @returns {boolean} Returns `true` if `value` is a ***{@link Buffer | `Buffer`}***, else `false`.
 * @example
 * isBuffer(new Buffer(2));
 * // ➔ true
@@ -624,25 +665,22 @@ 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.
-*
+* **Determines if the given `input` can be interpreted as a currency-like number,
+* using the same **multi-locale parsing logic** as ***{@link parseCurrencyString | `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`).
+* - **ℹ️ Note:**
+*    - Uses the same core logic as
+*      ***{@link parseCurrencyString | `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
@@ -661,11 +699,12 @@ 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.
-*
+* **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.**
+* - **Behavior:**
+*    - 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
@@ -678,17 +717,21 @@ declare const isCurrencyLike:(input:unknown)=>boolean;
 */
 declare const isDate:(value:unknown)=>value is Date;
 /** ----------------------------------------------------------
-* * ***Performs a deep equality check between two values.***
+* * ***Predicate: `isDeepEqual`.***
 * ----------------------------------------------------------
-* - 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.
-*
+* **Performs a deep equality check between two values.**
+* - **Behavior:**
+*    - 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).
+* - **ℹ️ Note:**
+*    - 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`.
@@ -733,7 +776,8 @@ 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)**.
+* **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`.
@@ -753,15 +797,18 @@ declare function isElement(value:[]):value is [];declare function isElement<T ex
 /** ----------------------------------------------------
 * * ***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}**.
-*
+* **Checks if `value` is an empty object, collection, map, or set.**
+* - **Behavior:**
+*    - **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.
+* - **ℹ️ Note:**
+*    - For more `Strict`, you can use
+*      **{@link isEmptyValue | `isEmptyValue`}** instead.
 * @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`.
@@ -793,12 +840,11 @@ declare function isEmpty<T extends{__trapAny:any;}>(value?:T):boolean;declare fu
 /** ----------------------------------------------------------
 * * ***Type guard: `isEmptyArray`.***
 * ----------------------------------------------------------
-* @description
-* - Checks whether a given value is an empty array.
-* - Non-array inputs are considered "empty" (defensive strategy).
-*
+* **Checks whether a given value is an empty array.**
+* - **Behavior:**
+*    - 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.
+* @returns {boolean} Returns `true` if it's ***not an array*** or ***an empty-array***.
 * @example
 * isEmptyArray([]);             // ➔ true
 * isEmptyArray([1, 2, 3]);      // ➔ false
@@ -814,20 +860,16 @@ declare const isEmptyArray:(value:unknown)=>boolean;
 /** ----------------------------------------------------------
 * * ***Predicate: `isEmptyDeep`.***
 * ----------------------------------------------------------
-* @description
-* Recursively checks whether a value is **deeply empty**.
-*
-* - Returns `true` for:
+* **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:
+* - **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
@@ -853,9 +895,7 @@ declare const isEmptyArray:(value:unknown)=>boolean;
 * // ➔ true
 */
 declare const isEmptyDeep:(value:unknown)=>boolean;type IsEmptyObjectOptions={
-/** Whether to check for symbol properties in addition to string keys.
-*
-* DefaultValue: `false`.
+/** Whether to check for symbol properties in addition to string keys, defaultValue: `true`.
 *
 * @default false
 */
@@ -863,15 +903,14 @@ 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.
-*
+* **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`.**
+* - **Behavior:**
+*    - 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.
+* @param {IsEmptyObjectOptions["checkSymbols"]} [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({});
@@ -892,23 +931,21 @@ checkSymbols?:boolean;};
 * // ➔ true (not object)
 */
 declare function isEmptyObject(value:unknown,options?:IsEmptyObjectOptions):boolean;type IsEmptyStringOptions={
-/** Whether to trim the string before checking.
-*
-* DefaultValue: `true`.
+/** 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`.
+* **Checks whether a given value is an **empty string**.**
+* - **Behavior:**
+*    - 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} [options] - Optional settings.
+* @param {IsEmptyStringOptions["trim"]} [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("");
@@ -942,23 +979,20 @@ 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.
-*
+* **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.
+* @param {IsEmptyValueOptions} [options] - Optional settings.
 * @returns {boolean} Return `true` if the value is considered empty, otherwise `false`.
-*
 * @example
 * isEmptyValue({});
 * // ➔ true
@@ -999,24 +1033,22 @@ checkSymbols?:boolean;};
 */
 declare const isEmptyValue:(value:unknown,options?:IsEmptyValueOptions)=>boolean;
 /** ----------------------------------------------------
-* * ***Performs a deep comparison between two values to determine if they are equivalent.***
+* * ***Predicate: `isEqual`.***
 * ----------------------------------------------------------
+* **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**.
-*
+* - **✅ 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`.
@@ -1041,23 +1073,25 @@ declare const isEmptyValue:(value:unknown,options?:IsEmptyValueOptions)=>boolean
 */
 declare function isEqual(value:unknown,other:unknown):boolean;
 /** ----------------------------------------------------
-* * ***Performs a deep comparison between two values with support for a customizer function.***
+* * ***Predicate: `isEqualWith`.***
 * ----------------------------------------------------
+* **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.
-*
+* This method is like **{@link isEqual | `isEqual`}** except that it
+* accepts a `customizer` which is invoked to compare values.
+* - **Behavior:**
+*     - 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)`,
+*         see **{@link CustomizerIsEqualWith | `CustomizerIsEqualWith`}**.
+*     - 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.
+* @param {CustomizerIsEqualWith} [customizer] The function to customize comparisons.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 * function isGreeting(value: unknown) {
@@ -1073,18 +1107,17 @@ declare function isEqual(value:unknown,other:unknown):boolean;
 * const array = ["hello", "goodbye"];
 * const other = ["hi", "goodbye"];
 *
-* console.log(isEqualWith(array, other, customizer));
+* isEqualWith(array, other, customizer);
 * // ➔ true
 */
-declare function isEqualWith(value:unknown,other:unknown,customizer?:IsEqualCustomizer):boolean;
+declare function isEqualWith(value:unknown,other:unknown,customizer?:CustomizerIsEqualWith):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.
-*
+* **Checks whether the given value is an **`Error` object**.**
+* - **Behavior:**
+*    - 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
@@ -1096,19 +1129,19 @@ declare function isEqualWith(value:unknown,other:unknown,customizer?:IsEqualCust
 * // ➔ false
 */
 declare const isError:(error:unknown)=>error is Error;
-/** -----------------------------------------------------------------------------
-* * ***Checks if a value is a finite primitive number.***
-* -----------------------------------------------------------------------------
+/** ----------------------------------------------------------
+* * ***Type guard: `isFinite`.***
+* -----------------------------------------------------------
+* **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**.
-*
+* - **Behavior:**
+*    - 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";
 *
@@ -1135,15 +1168,14 @@ declare const isError:(error:unknown)=>error is Error;
 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).
-*
+* -----------------------------------------------------------
+* **Checks if a value is a function.**
+* - **Behavior:**
+*    - Uses `typeof value === "function"` for strict type checking.
+*    - Safe alternative to `Function` type (doesn't trigger ESLint warning).
+*    - Supports TypeScript type narrowing with `value is (...args: any[]) => any`.
 * @param {*} value - The value to check.
 * @returns {boolean} Return `true` if the value is a function.
-*
 * @example
 * isFunction(() => {});
 * // ➔ true
@@ -1155,14 +1187,13 @@ declare function isFinite(value:unknown):value is number;
 * // ➔ 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).
-*
+* **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
@@ -1183,18 +1214,16 @@ 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
+* **Checks whether the given value is a **valid array-like length**.**
+* - **Behavior:**
+*    - ✅ 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
+*    - A valid length must be a non-negative integer and **not greater
+*      than `Number.MAX_SAFE_INTEGER`**.
 * [`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
@@ -1221,11 +1250,10 @@ 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.
-*
+* **Checks whether the given value is a **`Map` object**.**
+* - **Behavior:**
+*    - 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
@@ -1238,19 +1266,20 @@ declare function isLength(value:unknown):boolean;
 */
 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`.***
+* * ***Predicate: `isMatch`.***
 * ----------------------------------------------------
-* @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`.
+* **Performs a partial deep comparison between `object` and `source`.**
+* @description
+* Determines whether `object` contains equivalent property values from `source`.
+* - **Behavior:**
+*    - ✅ 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`.
@@ -1266,25 +1295,25 @@ declare function isMap<K=unknown,V=unknown>(value:Map<K,V>):value is Map<K,V>;de
 */
 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.***
+* * ***Predicate: `isMatchWith`.***
 * ----------------------------------------------------
+* **Performs a partial deep comparison between `object` and `source`, like `isMatch`, but with a `customizer` function to control comparisons.**
+* @description
 * 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.
+* - **Behavior:**
+*    - The `customizer` function is invoked with up to **five** arguments:
+*        - `(objValue, srcValue, keyOrIndex, object, source)`,
+*        see **{@link CustomizerIsMatchWith | `CustomizerIsMatchWith`}**.
+*    - 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 {object} value - The object to inspect.
+* @param {object} other - The object of property values to match.
+* @param {CustomizerIsMatchWith} [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);
@@ -1302,16 +1331,17 @@ declare function isMatch(object:object,source:object):boolean;
 * isMatchWith(object, source, customizer);
 * // ➔ true
 */
-declare function isMatchWith(value:object,other:object,customizer?:isMatchWithCustomizer):boolean;
+declare function isMatchWith(value:object,other:object,customizer?:CustomizerIsMatchWith):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.
-*
+* **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
@@ -1332,19 +1362,16 @@ declare function isNaN(value:unknown):boolean;
 /** ----------------------------------------------------
 * * ***Type guard: `isNative`.***
 * ----------------------------------------------------------
-* @description Checks if a value is a **pristine native function**.
-*
-* **Note:**
+* **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.
+*      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).
-*
+*      **[`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`.
+* @returns {boolean} Returns `true` if `value` is a native function, else `false`.
 * @example
 * isNative(Array.prototype.push);
 * // ➔ true
@@ -1353,12 +1380,13 @@ declare function isNaN(value:unknown):boolean;
 * isNative(RzlUtilsJs);
 * // ➔ false
 */
-declare function isNative(value?:unknown):value is AnyFunction;
+declare function isNative(value:unknown):value is AnyFunction;
 /** ----------------------------------------------------
 * * ***Type guard: `isNil`.***
 * ----------------------------------------------------------
-* @description Checks if a value is `null` or `undefined`.
-*
+* **Checks if a value is `null` or `undefined`.**
+* - **Behavior:**
+*    - Narrows type to `null` or `undefined` when true.
 * @param {*} value - The value to check.
 * @returns {boolean} Returns `true` if the value is `null` or `undefined`, otherwise `false`.
 * @example
@@ -1371,20 +1399,18 @@ declare function isNative(value?:unknown):value is AnyFunction;
 * isNil(NaN);
 * // ➔ false
 */
-declare function isNil(value?:unknown):value is null|undefined;
+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.
-*
+* **Checks if a value is a **non-empty array**.**
+* - **Behavior:**
+*    - 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
@@ -1400,20 +1426,17 @@ trim?:boolean;};
 /** ----------------------------------------------------------
 * * ***Type guard: `isNonEmptyString`.***
 * ----------------------------------------------------------
-* @description Checks if a value is a **non-empty string**.
-*
+* **Checks if a value is a **non-empty string**.**
+* @description
 * 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.
-*
+* - **Behavior:**
+*    - Ensures the value is a string using **{@link isString | `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`.
-*
+* @param {IsNonEmptyStringOptions} [options] - Optional settings.
+* @param {boolean} options.trim - If `true`, trims the string before checking, defaults: `true`.
+* @returns {boolean} Return `true` if `value` is a non-empty string, otherwise `false`.
 * @example
 * isNonEmptyString("hello");
 * // ➔ true
@@ -1435,28 +1458,34 @@ trim?:boolean;};
 * // ➔ false
 */
 declare const isNonEmptyString:(value:unknown,options?:IsNonEmptyStringOptions)=>value is string;type IsNonEmptyValueOptions={
-/**
-* Whether to check symbol properties when checking empty objects.
+/** Whether to check symbol properties when checking empty objects, default: `false`.
+*
 * @default false
 */
 checkSymbols?:boolean;};
 /** ----------------------------------------------------------
-* * ***Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items)
-* or generally truthy.***
+* * ***Predicated: `isNonEmptyValue`.***
 * ----------------------------------------------------------
-*
-* - 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.
-*
+* **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**
+* - **Behavior:**
+*    - Returns `true` for:
+*      - Objects **with properties**
+*      - Arrays **with items**
+*      - Non-empty, non-whitespace strings
+*      - Numbers (except `NaN`, includes `0`)
+*      - Functions
+*      - `true`
+*    - Returns `false` for:
+*      - Empty objects (`{}`)
+*      - Empty arrays (`[]`)
+*      - `null` or `undefined`
+*      - Empty strings (`""`) or whitespace-only strings (`"  "`)
+*      - `false`
+*      - `NaN`
+*    - 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`.
-*
+* @param {IsNonEmptyValueOptions} [options] - Optional settings.
+* @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.
 * @example
 * isNonEmptyValue({});
 * // ➔ false
@@ -1499,14 +1528,12 @@ declare const isNonEmptyValue:(value:unknown,options?:IsNonEmptyValueOptions)=>b
 /** ---------------------------------------------------------
 * * ***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.
-*
+* **Checks if a value is **[`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/null)**.**
+* - **Behavior:**
+*    - Narrows type to `null` when true.
+*    - Strictly compares the value against `null`.
 * @param {*} val - The value to check.
-* @returns {val is null} Returns `true` if the value is `null`, otherwise `false`.
-*
+* @returns {boolean} Returns `true` if the value is `null`, otherwise `false`.
 * @example
 * isNull(null);      // ➔ true
 * isNull(0);         // ➔ false
@@ -1516,32 +1543,27 @@ declare const isNull:(val:unknown)=>val is null;type HasKeys$1<T>=keyof T extend
 /** ---------------------------------------------------------
 * * ***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)`)
+* **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:
+* - **❌ 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.
-*
+* - **ℹ️ 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`.
-*
+* @returns {boolean} Returns `true` if the value is a ***plain-objects***, otherwise `false`.
 * @example
 * isObject({});                  // ➔ true
 * isObject(Object.create(null)); // ➔ true
@@ -1559,11 +1581,9 @@ declare function isObject<T extends object>(value:T):value is IsObject<T>;declar
 /** ----------------------------------------------------------
 * * ***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:
+* **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
@@ -1572,8 +1592,7 @@ declare function isObject<T extends object>(value:T):value is IsObject<T>;declar
 *      - `new Number(0)`
 *      - `new String("")`
 *      - `new Boolean(false)`
-*  ----------------------------
-* - ❌ Returns `false` for:
+* - **❌ Returns `false` for:**
 *    - `null`
 *    - `undefined`
 *    - Primitives:
@@ -1582,9 +1601,8 @@ declare function isObject<T extends object>(value:T):value is IsObject<T>;declar
 *      - `boolean`
 *      - `symbol`
 *      - `bigint`
-*
-* @note ⚠️ **For More Strict Object Use {@link isObject} or {@link isPlainObject} instead.**
-*
+* - **ℹ️ 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`.
@@ -1604,15 +1622,12 @@ declare function isObjectLoose<T=object>(value:unknown):value is T;type HasKeys<
 /** ---------------------------------------------------------
 * * ***Type guard: `isObjectOrArray`.***
 * ----------------------------------------------------------
-* @description
-* Checks if a value is an **object** or an **array**.
-*
-* - ✅ Returns `true` for:
+* **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:
+* - **❌ Returns `false` for:**
 *    - `null`
 *    - `undefined`
 *    - Primitives:
@@ -1622,11 +1637,9 @@ declare function isObjectLoose<T=object>(value:unknown):value is T;type HasKeys<
 *        - `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
@@ -1636,13 +1649,38 @@ declare function isObjectLoose<T=object>(value:unknown):value is T;type HasKeys<
 */
 declare function isObjectOrArray(value:[]):value is [];declare function isObjectOrArray<T>(value:T):value is IsObjectOrArray<T>;
 /** ----------------------------------------------------------
+* * ***Type guard: `PropertyKey`.***
+* ----------------------------------------------------------
+* **Checks if a value is a valid `PropertyKey`.**
+* - **In JavaScript/TypeScript, a **`PropertyKey`** is any of:**
+*    - **`string`**
+*    - **`number`**
+*    - **`symbol`**
+* - **This function ensures the given `value` is one of these types.**
+*    - Narrows type to {@link PropertyKey | ***`PropertyKey`***} when true.
+*    - Useful for working with dynamic object keys.
+*    - Strictly rejects `null`, `undefined`, `boolean`, `object`, `function`, etc.
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if `value` is a valid property key, otherwise `false`.
+* @example
+* isPropertyKey("foo");
+* // ➔ true
+* isPropertyKey(123);
+* // ➔ true
+* isPropertyKey(Symbol("id"));
+* // ➔ true
+* isPropertyKey({});
+* // ➔ false
+* isPropertyKey(null);
+* // ➔ false
+*/
+declare function isPropertyKey(value:unknown):value is PropertyKey;
+/** ----------------------------------------------------------
 * * ***Type guard: `isRegExp`.***
 * ----------------------------------------------------------
-* @description Checks if a value is a RegExp instance.
-*
+* **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
@@ -1650,15 +1688,17 @@ declare function isObjectOrArray(value:[]):value is [];declare function isObject
 */
 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)**.***
+* * ***Type guard: `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}**.
-*
+* **Checks if `value` is a **[`Safe-Integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger)**.**
+* - **Behavior:**
+*    - Narrows type to `number` when true.
+* - **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
@@ -1675,11 +1715,10 @@ 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.
-*
+* **Checks if a value is a **[`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set)** object.**
+* - **Behavior:**
+*    - 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`.
@@ -1693,15 +1732,13 @@ declare function isSet<T=unknown>(value:Set<T>):value is Set<T>;declare function
 /** ---------------------------------------------------------
 * * ***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.
-*
+* **Checks if a value is of type
+* **[`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**.**
+* - **Behavior:**
+*    - Narrows type to `string` when true.
+*    - Uses the `typeof` operator for strict checking.
 * @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
@@ -1717,15 +1754,13 @@ 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.
-*
+* **Checks if a value is of type
+* **[`symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/Symbol)**.**
+* - **Behavior:**
+*    - Narrows type to `symbol` when true.
+*    - Uses the `typeof` operator for strict checking.
 * @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
@@ -1736,13 +1771,12 @@ 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.
-*
+* **Checks if `value` is classified as a
+* **[TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**
+* - **Behavior:**
+*    - 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
@@ -1757,15 +1791,13 @@ 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.
-*
+* **Checks if a value is an instance of the
+* **[`URL`](https://developer.mozilla.org/docs/Web/API/URL)** class.**
+* - **Behavior:**
+*    - 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
@@ -1776,14 +1808,14 @@ 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.
-*
+* **Checks if a value is
+* **[`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)**.**
+* - **Behavior:**
+*    - 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`.
+* @returns {boolean} Returns `true` if the value is `undefined`, otherwise `false`.
 * @example
 * isUndefined(undefined); // ➔ true
 * isUndefined([]);        // ➔ false
@@ -1792,27 +1824,23 @@ declare const isURL:(value:unknown)=>value is URL;
 * isUndefined("abc");     // ➔ false
 */
 declare const isUndefined:(value:unknown)=>value is undefined;
-/** ---------------------------------
-* * ***Validates whether a given string is a properly formatted URL.***
+/** ---------------------------------------------------------
+* * ***Predicate: `isValidURL`.***
 * ---------------------------------------------------------
-*
-* 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.
-*
+* **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.
+* - **Behavior:**
+*    - ✅ 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
 */
@@ -1820,20 +1848,18 @@ 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.
-*
+* **Checks if a value is a **[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/WeakMap)** object.**
+* - **Behavior:**
+*    - 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};
+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,isPropertyKey,isRegExp,isSafeInteger,isSet,isString,isSymbol,isTypedArray,isURL,isUndefined,isValidURL,isWeakMap,textContainsAll,textContainsAny};