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

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