@rzl-zone/utils-js 3.1.3-beta.0 → 3.2.0

package/dist/predicates/index.d.ts

@@ -1,4 +1,4 @@
-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;
+import{h as IsPositive,P as ParseNumber,I as IsStringLiteral,C as CharAt,c as IsUnknown,j as IsReadonlyArray,l as IsArray}from'../is-array-BJeHxPM3.js';import{A as AnyString,a as IsEmptyString,T as Trim}from'../string-B1jlOnws.js';import{I as IsAny}from'../any-v4TsK9ES.js';import{P as Prettify,A as AnyFunction,g as AnObjectNonArray,T as TypedArray}from'../prettify-3o8_Kw6b.js';import{E as Extends}from'../extends-DtdRjDyU.js';import{N as NumberRangeUnion}from'../NumberRangeUnion-B6bhM2s7.js';import{a as IsPlainObjectResult}from'../isPlainObject-DGJkcFYw.js';export{G as GetPreciseTypeOptions,I as IsNumberOptions,g as getPreciseType,i as isNumber,b as isPlainObject}from'../isPlainObject-DGJkcFYw.js';import{I as IsNever}from'../never-D89PbPh5.js';import{O as OrArr}from'../or-C6qzKt2I.js';import'../if-ChM35c_q.js';
 /** ----------------------------------------------------------
  * * ***Predicate: `areArraysEqual`.***
  * ----------------------------------------------------------
@@ -6,11 +6,11 @@ import{k as IsPositive,P as ParseNumber,I as IsStringLiteral,C as CharAt,d as Is
  * @description Supports deep comparison of arrays containing nested arrays or objects,
  *  can also ignore the order of elements at all levels by recursively sorting.
  * @param {unknown[]} array1
- *   The first array to compare. Can contain nested arrays or objects.
+ *   ***The first array to compare, can contain nested arrays or objects.***
  * @param {unknown[]} array2
- *   The second array to compare against. Should match structure of `array1`.
+ *   ***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.
+ *   ***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`.
@@ -56,19 +56,31 @@ declare const areObjectsEqual:(object1:unknown,object2:unknown)=>boolean;
  * @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"));
+ * 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"));
+ * 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"));
+ * 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"));
+ * areURLsEqualPath(
+ *   new URL("https://example.com/page#section"),
+ *   new URL("https://example.com/page")
+ * );
  * // ➔ true
  */
 declare const areURLsEqualPath:(urlA:URL,urlB:URL)=>boolean;
@@ -81,19 +93,31 @@ declare const areURLsEqualPath:(urlA:URL,urlB:URL)=>boolean;
  * @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"));
+ * 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"));
+ * 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"));
+ * 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/"));
+ * areURLsIdentical(
+ *   new URL("https://example.com/page"),
+ *   new URL("https://example.com/page/")
+ * );
  * // ➔ false
  */
 declare const areURLsIdentical:(urlA:URL,urlB:URL)=>boolean;type OptionsTextContainsAll={
@@ -189,9 +213,9 @@ declare const textContainsAny:<T extends string>(text?:T|null,searchWords?:T[]|s
  *      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.**
+ *      - 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.
@@ -292,9 +316,14 @@ type EffectiveDiscardNull<O extends boolean|undefined>=O extends boolean?O:false
 type UnwrapArray<T>=T extends(infer U)[]?U:T extends readonly(infer U)[]?U:T;
 /** Force symbol key to be deep required. */
 type IsOptionalKey<T,K extends keyof T>=Record<never,never>extends Pick<T,K>?true:false;
-/** Returns numeric keys of an object.  */
+/** * ***Returns numeric keys of an object.***
+ *
+ * @private ***types for {@link hasOwnProp}.***
+ */
 type NumericKeyOfHasOwnProp<Obj>=Extract<keyof Obj,number>;
-/** Generate all nested keys of an object or array in dot/bracket notation.
+/** * ***Generate all nested keys of an object or array in dot/bracket notation.***
+ *
+ * @private ***types for {@link hasOwnProp}.***
  *
  * Example:
  * ```ts
@@ -322,28 +351,43 @@ type RefineArrayAtIndex<T extends readonly unknown[],N extends number,U>=T &{[K
  * @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. */
+/** * ***Expand an array/string/function into a nested type according
+ * to a dot/bracket path.***
+ * @private ***types for {@link hasOwnProp}.***
+ */
+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;
+/** @private ***types for {@link hasOwnProp}.*** */
+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.***
+ *
+ * @private ***types for {@link hasOwnProp}.***
+ */
 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`. */
+/** * ***Guarded wrapper for `NarrowByPathHasOwnProp` with `Prettify`.***
+ * @private ***types for {@link hasOwnProp}.***
+ */
 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.
+/** * ***Make a specific symbol key deeply required in an object symbols.***
+ * **Used internally to enforce stronger type narrowing.**
+ * @private ***types for {@link hasOwnProp}.***
  */
 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.
+/** * ***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
+ *
+ * @private ***types for {@link hasOwnProp}.***
  */
 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. */
+/** * ***Options to control `hasOwnProp` behavior.***
+ * @private ***types options for {@link hasOwnProp}.***
+ */
 type HasOwnPropOptions<DiscardUndefined extends boolean=true,DiscardNull extends boolean=false>={
 /** If `true` ***(default)***, properties with `undefined` values are treated as non-existent.
  *
@@ -372,31 +416,30 @@ discardUndefined?:DiscardUndefined;
  */
 discardNull?:DiscardNull;};
 /** -------------------------------------------------------
- * * ***Utility: `hasOwnProp`.***
+ * * ***Predicate: `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
+ *    - **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`**
+ *    - 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
+ *        - Value `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**
+ *        - Value `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**.
@@ -417,18 +460,17 @@ discardNull?:DiscardNull;};
  *            **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} [options] - ***Optional configuration object.***
  * @param {HasOwnPropOptions["discardUndefined"]} [options.discardUndefined=true]
- *  If `true`, properties with `undefined` values are treated as **missing**, default: `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.
+ *  ***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)
+ *  ***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
  *
@@ -610,14 +652,14 @@ declare function isArrayLikeObject<T extends{__anyHack:unknown;}>(value:T):boole
 /** ----------------------------------------------------------
  * * ***Type guard: `isBigInt`.***
  * ----------------------------------------------------------
- * **Checks if a value is of type bigint.**
+ * **Checks if a value is of type **[`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/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)**.
+ * @returns {boolean} Return `true` if value is a primitive bigint.
  * @example
  * isBigInt(123n);
  * // ➔ true
@@ -632,21 +674,35 @@ declare const isBigInt:(value:unknown)=>value is bigint;
 /** ----------------------------------------------------------
  * * ***Type guard: `isBoolean`.***
  * ----------------------------------------------------------
- * **Checks if a value is of type boolean.**
+ * **Checks if a value is of type **[`boolean`](https://developer.mozilla.org/en-US/docs/Glossary/Boolean/JavaScript)**.**
  * @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`.
+ * @returns {boolean} Returns `true` if the value is a `boolean`, otherwise `false`.
  * @example
  * isBoolean(true);   // ➔ true
  * isBoolean(false);  // ➔ true
  * isBoolean("true"); // ➔ false
  */
 declare const isBoolean:(value:unknown)=>value is boolean;
+/** ----------------------------------------------------
+ * * ***Type guard: `isBooleanObject`.***
+ * ----------------------------------------------------
+ * **Checks if a value is a **`Boolean` object wrapper**
+ * (`new Boolean(...)`), not a primitive boolean.**
+ * @param {*} value The value to check.
+ * @returns {value is Boolean} Returns `true` if `value` is a `Boolean` object.
+ * @example
+ * isBooleanObject(new Boolean(true));
+ * // ➔ true
+ * isBooleanObject(true);
+ * // ➔ false
+ */
+declare function isBooleanObject(value:unknown):value is Boolean;
 /** ----------------------------------------------------
  * * ***Type guard: `isBuffer`.***
  * ----------------------------------------------------------
- * **Checks if a value is a **Node.js Buffer** instance.**
+ * **Checks if a value is a *****{@link Buffer | `Node.js - Buffer`}***** instance.**
  * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a ***{@link Buffer | `Buffer`}***, else `false`.
+ * @returns {boolean} Returns `true` if `value` is a `Buffer`, else `false`.
  * @example
  * isBuffer(new Buffer(2));
  * // ➔ true
@@ -663,12 +719,12 @@ declare const isBoolean:(value:unknown)=>value is boolean;
  */
 declare const isBuffer:(value:unknown)=>value is Buffer;
 /** -----------------------------------------------------------
- * * ***Checks whether a value looks like a currency or number string.***
+ * * ***Predicate: `isCurrencyLike`.***
  * -----------------------------------------------------------
  * **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:
+ *    - *Supports strings or numbers like:*
  *      - `"15.000,10"` ***(European)***.
  *      - `"15,000.10"` ***(US)***.
  *      - `"15'000.10"` ***(Swiss)***.
@@ -695,27 +751,46 @@ declare const isBuffer:(value:unknown)=>value is Buffer;
  * isCurrencyLike("abc");
  * // ➔ false
  */
-declare const isCurrencyLike:(input:unknown)=>boolean;
+declare const isCurrencyLike:(input:unknown)=>boolean;type isDateOptions={
+/** * ***Skip the validity check (`!isNaN(date.getTime())`).***
+ *
+ * When `true`, the function only checks that the value is an
+ * instance of `Date` without verifying that it represents a valid
+ * date value, default: `false`.
+ *
+ * @default false
+ */
+skipInvalidDate?:boolean;};
 /** ----------------------------------------------------------
  * * ***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`.
+ *    - Returns **true** only if:
+ *      - `value` is an instance of `Date`.
+ *      - and, unless `options.skipInvalidDate` is `true`,
+ *        the underlying time value is valid (`!isNaN(value.getTime())`).
+ *    - Returns **false** for:
+ *      - non-Date values (strings, numbers, etc.).
+ *      - `Date` instances that represent an invalid time value
+ *        (e.g. `new Date("bad")`), unless skipping is enabled.
  * @param {*} value - The value to check.
+ * @param {isDateOptions} [options] - Optional settings.
  * @returns {boolean} Return `true` if value is a valid Date object.
  * @example
  * isDate(new Date());
- * // ➔ true
+ * // ➜ true
  * isDate(new Date("invalid"));
- * // ➔ false
+ * // ➜ false
  * isDate("2024-01-01");
- * // ➔ false
+ * // ➜ false
+ *
+ * // Skipping validity check:
+ * isDate(new Date("invalid"), { skipInvalidDate: true });
+ * // ➜ true
  */
-declare const isDate:(value:unknown)=>value is Date;
+declare const isDate:(value:unknown,options?:isDateOptions)=>value is Date;
 /** ----------------------------------------------------------
  * * ***Predicate: `isDeepEqual`.***
  * ----------------------------------------------------------
@@ -794,8 +869,68 @@ declare const isDeepEqual:(a:unknown,b:unknown)=>boolean;
  * // ➔ 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;
+/**
+ * -------------------------------------------------------------------
+ * * ***Array-like structure interface.***
+ * -------------------------------------------------------------------
+ * **Represents objects with indexed elements and a `length` property,
+ * similar to arrays, but not necessarily full Array instances.**
+ * @template T The type of elements stored in the array-like object.
+ * @example
+ * ```ts
+ * function logArrayLike<T>(items: ArrayLike<T>) {
+ *   for (let i = 0; i < items.length; i++) {
+ *     console.log(items[i]);
+ *   }
+ * }
+ *
+ * const myNodeList: ArrayLike<Element> = document.querySelectorAll("div");
+ * logArrayLike(myNodeList);
+ * ```
+ */
+interface ArrayLike<T>{
+/** * ***Number of elements in the array-like object.*** */
+readonly length:number;
+/** * ***Indexed access to elements.*** */
+readonly [n:number]:T;}
+/** -------------------------------------------------------------------
+ * * ***Represents an object with no allowed properties.***
+ * -------------------------------------------------------------------
+ * **Useful for cases where you want to ensure a type has **no keys**.**
+ * @template T - The base type to convert into an empty object type.
+ * @example
+ * ```ts
+ * type Test = EmptyObject<{ a: number }>;
+ * // ➔ { a?: never }
+ * ```
+ */
+type EmptyObject<T>={[K in keyof T]?:never;};
+/** -------------------------------------------------------------------
+ * * ***Conditional empty object type.***
+ * -------------------------------------------------------------------
+ * **Produces `EmptyObject<T>` only if it is assignable to `T`.**
+ * @template T - The base type to check.
+ * @example
+ * ```ts
+ * type Test = EmptyObjectOf<{ a: number }>;
+ * // ➔ { a?: never } | never depending on assignability
+ * ```
+ */
+type EmptyObjectOf<T>=EmptyObject<T>extends T?EmptyObject<T>:never;
+/** -------------------------------------------------------------------
+ * * ***List type alias.***
+ * -------------------------------------------------------------------
+ * **Represents any array-like structure.**
+ * @template T - The type of elements in the list.
+ * @example
+ * ```ts
+ * const arr: List<number> = [1, 2, 3];
+ * const nodeList: List<Element> = document.querySelectorAll("div");
+ * ```
+ */
+type List<T>=ArrayLike<T>;
 /** ----------------------------------------------------
- * * ***Utility: `isEmpty`.***
+ * * ***Predicate: `isEmpty`.***
  * ----------------------------------------------------------
  * **Checks if `value` is an empty object, collection, map, or set.**
  * - **Behavior:**
@@ -838,11 +973,11 @@ declare function isElement(value:[]):value is [];declare function isElement<T ex
  */
 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`.***
+ * * ***Predicate: `isEmptyArray`.***
  * ----------------------------------------------------------
  * **Checks whether a given value is an empty array.**
  * - **Behavior:**
- *    - Non-array inputs are considered `"empty"` ***(defensive strategy)***.
+ *    - 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
@@ -895,7 +1030,7 @@ declare const isEmptyArray:(value:unknown)=>boolean;
  * // ➔ true
  */
 declare const isEmptyDeep:(value:unknown)=>boolean;type IsEmptyObjectOptions={
-/** Whether to check for symbol properties in addition to string keys, defaultValue: `true`.
+/** Whether to check for symbol properties in addition to string keys, defaultValue: `false`.
  *
  * @default false
  */
@@ -933,12 +1068,12 @@ checkSymbols?:boolean;};
 declare function isEmptyObject(value:unknown,options?:IsEmptyObjectOptions):boolean;type IsEmptyStringOptions={
 /** Whether to trim the string before checking, defaultValue: `true`.
  *
- * @default `true` */
+ * @default true */
 trim?:boolean;};
 /** ----------------------------------------------------------
  * * ***Predicate: `isEmptyString`.***
  * ----------------------------------------------------------
- * **Checks whether a given value is an **empty string**.**
+ * **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).
@@ -969,9 +1104,8 @@ trim?:boolean;};
  * }
  */
 declare const isEmptyString:(value:unknown,options?:IsEmptyStringOptions)=>boolean;type IsEmptyValueOptions={
-/** Whether to check symbol properties when checking empty objects.
- *
- * DefaultValue: `false`.
+/** **Whether to check symbol properties when checking empty objects.**
+ * - **DefaultValue:** `false`.
  *
  * @default false
  */
@@ -1072,6 +1206,52 @@ declare const isEmptyValue:(value:unknown,options?:IsEmptyValueOptions)=>boolean
  * // ➔ false
  */
 declare function isEqual(value:unknown,other:unknown):boolean;
+/** -------------------------------------------------------------------
+ * * ***Customizer function for `isEqualWith`.***
+ * -------------------------------------------------------------------
+ * **Allows customizing how two values are compared for deep equality.**
+ * @param value
+ * - The current value being compared.
+ * @param other
+ * - The corresponding value from the other object.
+ * @param indexOrKey
+ * - The property key (for objects) or index (for arrays) of the current value.
+ * @param parent
+ * - The parent object or array containing `value`.
+ * @param otherParent
+ * - The parent object or array containing `other`.
+ * @param stack
+ * - WeakMap or tracking structure for already visited objects to handle circular references.
+ * @returns
+ * - `true`  → Treat the values as equal.
+ * - `false` → Treat the values as unequal.
+ * - `undefined` → Fallback to default deep equality comparison.
+ * @example
+ * ```ts
+ * const customizer: CustomizerIsEqualWith = (value, other, key) => {
+ *   if (typeof value === "string" && typeof other === "string") {
+ *     return value.toLowerCase() === other.toLowerCase();
+ *   }
+ *   return undefined;
+ * };
+ *
+ * baseDeepEqual({ name: "Alice" }, { name: "alice" }, customizer);
+ * // returns true
+ * ```
+ */
+type CustomizerIsEqualWith=(
+/** * ***The current value being compared.*** */
+value:unknown,
+/** * ***The corresponding value from the other object.*** */
+other:unknown,
+/** * ***Property key (for objects) or index (for arrays) of the current value.*** */
+indexOrKey:PropertyKey,
+/** * ***Parent object or array containing `value`.*** */
+parent:unknown,
+/** * ***Parent object or array containing `other`.*** */
+otherParent:unknown,
+/** * ***WeakMap or tracking structure for visited objects to handle circular references.*** */
+stack:unknown)=>boolean|undefined;
 /** ----------------------------------------------------
  * * ***Predicate: `isEqualWith`.***
  * ----------------------------------------------------
@@ -1114,12 +1294,12 @@ declare function isEqualWith(value:unknown,other:unknown,customizer?:CustomizerI
 /** ----------------------------------------------------------
  * * ***Type guard: `isError`.***
  * ----------------------------------------------------------
- * **Checks whether the given value is an **`Error` object**.**
+ * **Checks whether the given value is an ****[`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/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`.
+ * @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
@@ -1143,7 +1323,7 @@ declare const isError:(error:unknown)=>error is Error;
  * @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";
+ * import * as RzlUtilsJs from "@rzl-zone/utils-js/predicates";
  *
  * // Strict finite number check (only primitive numbers)
  * RzlUtilsJs.isFinite(3);
@@ -1187,10 +1367,36 @@ declare function isFinite(value:unknown):value is number;
  * // ➔ false
  */
 declare const isFunction:(value:unknown)=>value is AnyFunction;
+/** ----------------------------------------------------
+ * * ***Type guard: `isInfinityNumber`.***
+ * ----------------------------------------------------
+ * **Checks if a value is positive or negative
+ * [`Infinity`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity).**
+ * - **ℹ️ Note:**
+ *    - This is stricter than the global `isFinite`,
+ *      because it only returns `true` for `Infinity` or `-Infinity`,
+ *      not other non-finite values.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `Infinity` or `-Infinity`, else `false`.
+ * @example
+ * import * as RzlUtilsJs from "@rzl-zone/utils-js/predicates";
+ *
+ * RzlUtilsJs.isInfinityNumber(Infinity);
+ * // ➔ true
+ * RzlUtilsJs.isInfinityNumber(-Infinity);
+ * // ➔ true
+ * RzlUtilsJs.isInfinityNumber(new Number(Infinity));
+ * // ➔ true
+ * RzlUtilsJs.isInfinityNumber(NaN);
+ * // ➔ false
+ * RzlUtilsJs.isInfinityNumber(123);
+ * // ➔ false
+ */
+declare function isInfinityNumber(value:unknown):boolean;
 /** ---------------------------------------------------------
  * * ***Type guard: `isInteger`.***
  * ----------------------------------------------------------
- * **Checks if a value is an integer.**
+ * **Checks if a value is an integer number.**
  * - **ℹ️ Note:**
  *    - This method is based on
  *      [`Number.isInteger`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger).
@@ -1212,7 +1418,7 @@ declare const isFunction:(value:unknown)=>value is AnyFunction;
  */
 declare function isInteger(value:unknown):value is number;
 /** ----------------------------------------
- * * ***Type guard: `isLength`.***
+ * * ***Predicate: `isLength`.***
  * ----------------------------------------------------------
  * **Checks whether the given value is a **valid array-like length**.**
  * - **Behavior:**
@@ -1220,10 +1426,10 @@ declare function isInteger(value:unknown):value is number;
  *    - ✅ 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
+ *    - 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`**.
- * [`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
@@ -1250,12 +1456,12 @@ declare function isLength(value:unknown):boolean;
 /** --------------------------------------------------
  * * ***Type guard: `isMap`.***
  * ----------------------------------------------------------
- * **Checks whether the given value is a **`Map` object**.**
+ * **Checks whether the given value is a **[`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/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)**.
+ *    - 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`.
+ * @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
@@ -1294,6 +1500,48 @@ declare function isMap<K=unknown,V=unknown>(value:Map<K,V>):value is Map<K,V>;de
  * // ➔ true (treats arrays as objects with index keys)
  */
 declare function isMatch(object:object,source:object):boolean;
+/** -------------------------------------------------------------------
+ * * ***Customizer function for `isMatchWith`.***
+ * -------------------------------------------------------------------
+ * **Allows customizing how two values are compared for partial/object match.**
+ * @param value
+ * - The current value from the object being tested.
+ * @param other
+ * - The corresponding value from the source object.
+ * @param indexOrKey
+ * - The property key (for objects) or index (for arrays) of the current value.
+ * @param object
+ * - The parent object containing `value`.
+ * @param source
+ * - The parent source object containing `other`.
+ * @returns
+ * - `true`  → Treat the values as matching.
+ * - `false` → Treat the values as not matching.
+ * - `undefined` → Fallback to default match comparison.
+ * @example
+ * ```ts
+ * const customizer: CustomizerIsMatchWith = (value, other) => {
+ *   if (typeof value === "string" && typeof other === "string") {
+ *     return value.toLowerCase() === other.toLowerCase();
+ *   }
+ *   return undefined;
+ * };
+ *
+ * baseIsMatch({ name: "Alice" }, { name: "alice" }, customizer);
+ * // returns true
+ * ```
+ */
+type CustomizerIsMatchWith=(
+/** * ***Current value from the object being tested.*** */
+value:unknown,
+/** * ***Corresponding value from the source object.*** */
+other:unknown,
+/** * ***Property key (objects) or index (arrays) of the current value.*** */
+indexOrKey:PropertyKey,
+/** * ***Parent object containing `value`.*** */
+object:object,
+/** * ***Parent source object containing `other`.*** */
+source:object)=>boolean|undefined;
 /** ----------------------------------------------------
  * * ***Predicate: `isMatchWith`.***
  * ----------------------------------------------------
@@ -1345,7 +1593,7 @@ declare function isMatchWith(value:object,other:object,customizer?:CustomizerIsM
  * @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";
+ * import * as RzlUtilsJs from "@rzl-zone/utils-js/predicates";
  *
  * RzlUtilsJs.isNaN(NaN);
  * // ➔ true
@@ -1376,7 +1624,7 @@ declare function isNaN(value:unknown):boolean;
  * isNative(Array.prototype.push);
  * // ➔ true
  *
- * import * as RzlUtilsJs from "@rzl-zone/utils-js";
+ * import * as RzlUtilsJs from "@rzl-zone/utils-js/predicates";
  * isNative(RzlUtilsJs);
  * // ➔ false
  */
@@ -1418,10 +1666,9 @@ declare function isNil(value:unknown):value is null|undefined;
  * 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.
+/** Whether to trim the string before checking, defaultValue: `true`.
  *
- * @default `true` */
+ * @default true */
 trim?:boolean;};
 /** ----------------------------------------------------------
  * * ***Type guard: `isNonEmptyString`.***
@@ -1539,7 +1786,21 @@ declare const isNonEmptyValue:(value:unknown,options?:IsNonEmptyValueOptions)=>b
  * 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;
+declare const isNull:(val:unknown)=>val is null;
+/** ----------------------------------------------------
+ * * ***Type guard: `isNumberObject`.***
+ * ----------------------------------------------------
+ * **Checks if a value is a **`Number` object wrapper**
+ * (`new Number(...)`), not a primitive number.**
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a `Number` object.
+ * @example
+ * isNumberObject(new Number(42));
+ * // ➔ true
+ * isNumberObject(42);
+ * // ➔ false
+ */
+declare function isNumberObject(value:unknown):value is Number;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`.***
  * ----------------------------------------------------------
@@ -1560,7 +1821,8 @@ declare const isNull:(val:unknown)=>val is null;type HasKeys$1<T>=keyof T extend
  *    - 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.
+ *    - If you specifically need to check for ***plain-objects*** only, use **{@link isPlainObject}** instead.
+ *    - If you specifically need to check for ***object***, ***plain-objects***, and include ***array***, use **{@link isObjectOrArray}** 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`.
@@ -1641,8 +1903,8 @@ declare function isObjectLoose<T=object>(value:unknown):value is T;type HasKeys<
  * @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({ name: "Alice" }); // ➔ true
  * isObjectOrArray(null);              // ➔ false
  * isObjectOrArray(undefined);         // ➔ false
  * isObjectOrArray("hello");           // ➔ false
@@ -1678,9 +1940,9 @@ declare function isPropertyKey(value:unknown):value is PropertyKey;
 /** ----------------------------------------------------------
  * * ***Type guard: `isRegExp`.***
  * ----------------------------------------------------------
- * **Checks if a value is a RegExp instance.**
+ * **Checks if a value is a [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/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)**.
+ * @returns {boolean} Return `true` if value is an instance of **`RegExp`**.
  * @example
  * isRegExp(/abc/);             // ➔ true
  * isRegExp(new RegExp("abc")); // ➔ true
@@ -1698,7 +1960,7 @@ declare const isRegExp:(value:unknown)=>value is RegExp;
  *    - 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}**.
+ *    - This method is based on **{@link Number.isSafeInteger | `Number.isSafeInteger`}**.
  * @param {*} value - The value to check.
  * @returns {boolean} Return `true` if `value` is a safe integer, otherwise `false`.
  * @example
@@ -1712,6 +1974,28 @@ declare const isRegExp:(value:unknown)=>value is RegExp;
  * // ➔ false
  */
 declare function isSafeInteger(value:unknown):value is number;
+/** ---------------------------------------------------------
+ * * ***Environment Predicate: `isServer`.***
+ * ---------------------------------------------------------
+ * **Detects whether the current code is executing in a
+ * **non-browser JavaScript runtime** (server-side) rather
+ * than in a web browser.**
+ * @description
+ * It simply checks for the absence of key browser globals like
+ * [**`window`**](https://developer.mozilla.org/docs/Web/API/Window/window) and
+ * [**`document`**](https://developer.mozilla.org/docs/Web/API/Window/document).
+ *  - *If those globals aren’t present, we treat the runtime as a server environment.*
+ * @returns {boolean}
+ *  * ***true**  – Code is executing on the `server`.*
+ *  * ***false** – Code is executing in a `browser`.*
+ * @example
+ * if (isServer()) {
+ *   console.log("Running on a server-side runtime");
+ * } else {
+ *   console.log("Running in a browser");
+ * }
+ */
+declare const isServer:()=>boolean;
 /** ---------------------------------------------------------
  * * ***Type guard: `isSet`.***
  * ----------------------------------------------------------
@@ -1751,6 +2035,20 @@ declare function isSet<T=unknown>(value:Set<T>):value is Set<T>;declare function
  * }
  */
 declare const isString:(value:unknown)=>value is string;
+/** ----------------------------------------------------
+ * * ***Type guard: `isStringObject`.***
+ * ----------------------------------------------------
+ * **Checks if a value is a **`String` object wrapper**
+ * (`new String(...)`), not a primitive string.**
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a `String` object.
+ * @example
+ * isStringObject(new String("hello"));
+ * // ➔ true
+ * isStringObject("hello");
+ * // ➔ false
+ */
+declare function isStringObject(value:unknown):value is String;
 /** ----------------------------------------------------------
  * * ***Type guard: `isSymbol`.***
  * ----------------------------------------------------------
@@ -1772,11 +2070,11 @@ declare const isSymbol:(value:unknown)=>value is symbol;
  * * ***Type guard: `isTypedArray`.***
  * ----------------------------------------------------------
  * **Checks if `value` is classified as a
- * **[TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**
+ * **[`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.
+ *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.
  * @param {*} value - The value to check.
  * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.
  * @example
@@ -1830,7 +2128,7 @@ 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.
+ *    - 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.
@@ -1862,4 +2160,25 @@ declare const isValidURL:(url:unknown)=>boolean;
  * 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};
+declare function isWeakMap<K extends object=object,V=unknown>(value:unknown):value is WeakMap<K,V>;
+/** ----------------------------------------------------------
+ * * ***List of common acronyms that should remain uppercase in formatted output, extend this list if you have more acronyms to support.***
+ * ----------------------------------------------------------
+ *
+ * - **⚠️ Internal:**
+ *    - Helper constant for **{@link getPreciseType | `getPreciseType`}**.
+ *    - Don't use on your code base, this internal helper of **{@link getPreciseType | `getPreciseType`}** function.
+ */
+declare const __internalAcronyms__:readonly string[];
+/** ----------------------------------------------------------
+ * * ***Mapping of common JavaScript built-in and environment-specific
+ * type names to canonical human-readable PascalCase strings.***
+ * ----------------------------------------------------------
+ * ***Keys are normalized for flexible matching, values are formatted names used as type descriptions.***
+ * @description
+ * Add or remove entries depending on your target environment.
+ * - **⚠️ Internal:**
+ *    - Helper constant for **{@link getPreciseType | `getPreciseType`}**.
+ *    - Don't use on your code base, this internal helper of **{@link getPreciseType | `getPreciseType`}** function.
+ */
+declare const FIXES_RAW:{readonly string:"String";readonly number:"Number";readonly boolean:"Boolean";readonly bigint:"Big Int";readonly symbol:"Symbol";readonly undefined:"Undefined";readonly null:"Null";readonly regexp:"Reg Exp";readonly reflect:"Reflect";readonly proxy:"Proxy";readonly atomics:"Atomics";readonly object:"Object";readonly array:"Array";readonly arguments:"Arguments";readonly function:"Function";readonly asyncfunction:"Async Function";readonly generatorfunction:"Generator Function";readonly asyncgeneratorfunction:"Async Generator Function";readonly generator:"Generator";readonly promise:"Promise";readonly evalerror:"Eval Error";readonly rangeerror:"Range Error";readonly referenceerror:"Reference Error";readonly syntaxerror:"Syntax Error";readonly typeerror:"Type Error";readonly urierror:"URI Error";readonly aggregateerror:"Aggregate Error";readonly error:"Error";readonly int8array:"Int 8 Array";readonly uint8array:"Uint 8 Array";readonly uint8clampedarray:"Uint 8 Clamped Array";readonly int16array:"Int 16 Array";readonly uint16array:"Uint 16 Array";readonly int32array:"Int 32 Array";readonly uint32array:"Uint 32 Array";readonly float32array:"Float 32 Array";readonly float64array:"Float 64 Array";readonly bigint64array:"Big Int 64 Array";readonly biguint64array:"Big Uint 64 Array";readonly arraybuffer:"Array Buffer";readonly sharedarraybuffer:"Shared Array Buffer";readonly dataview:"Data View";readonly arraybufferview:"Array Buffer View";readonly map:"Map";readonly set:"Set";readonly weakmap:"Weak Map";readonly weakset:"Weak Set";readonly mapiterator:"Map Iterator";readonly setiterator:"Set Iterator";readonly arrayiterator:"Array Iterator";readonly stringiterator:"String Iterator";readonly readablestream:"Readable Stream";readonly writablestream:"Writable Stream";readonly transformstream:"Transform Stream";readonly readablestreamdefaultreader:"Readable Stream Default Reader";readonly writablestreamdefaultwriter:"Writable Stream Default Writer";readonly readablestreamdefaultcontroller:"Readable Stream Default Controller";readonly transformstreamdefaultcontroller:"Transform Stream Default Controller";readonly abortcontroller:"Abort Controller";readonly abortsignal:"Abort Signal";readonly fetch:"fetch";readonly request:"Request";readonly response:"Response";readonly headers:"Headers";readonly formdata:"FormData";readonly blob:"Blob";readonly file:"File";readonly filelist:"FileList";readonly filereader:"FileReader";readonly intl:"Intl";readonly collator:"Intl. Collator";readonly datetimeformat:"Intl. Date Time Format";readonly listformat:"Intl. List Format";readonly numberformat:"Intl. Number Format";readonly pluralrules:"Intl. Plural Rules";readonly relativetimeformat:"Intl. Relative Time Format";readonly segmenter:"Intl. Segmenter";readonly locale:"Intl. Locale";readonly displaynames:"Intl. Display Names";readonly finalizationregistry:"Finalization Registry";readonly weakref:"Weak Ref";readonly structuredclone:"structured Clone";readonly urlpattern:"URL Pattern";readonly performance:"Performance";readonly performanceobserver:"Performance Observer";readonly performanceentry:"Performance Entry";readonly performancemark:"Performance Mark";readonly performancemeasure:"Performance Measure";readonly webassembly:"Web Assembly";readonly wasmmodule:"WebAssembly .Module";readonly wasminstance:"WebAssembly. Instance";readonly wasmmemory:"WebAssembly. Memory";readonly wasmtable:"WebAssembly. Table";readonly buffer:"Buffer";readonly process:"Process";readonly eventemitter:"Event Emitter";readonly stream:"Stream";readonly fs:"fs";readonly path:"path";readonly url:"URL";readonly urlsearchparams:"URL Search Params";readonly node:"Node";readonly element:"Element";readonly htmlelement:"HTML Element";readonly svgelement:"SVG Element";readonly document:"Document";readonly documentfragment:"Document Fragment";readonly shadowroot:"Shadow Root";readonly nodelist:"Node List";readonly htmlcollection:"HTML Collection";readonly mutationobserver:"Mutation Observer";readonly intersectionobserver:"Intersection Observer";readonly resizeobserver:"Resize Observer";};export{FIXES_RAW,type IsArrayResult,IsPlainObjectResult,__internalAcronyms__,areArraysEqual,areObjectsEqual,areURLsEqualPath,areURLsIdentical,arrayHasAnyMatch,doesKeyExist,hasOwnProp,isArguments,isArray,isArrayBuffer,isArrayLike,isArrayLikeObject,isBigInt,isBoolean,isBooleanObject,isBuffer,isCurrencyLike,isDate,isDeepEqual,isElement,isEmpty,isEmptyArray,isEmptyDeep,isEmptyObject,isEmptyString,isEmptyValue,isEqual,isEqualWith,isError,isFinite,isFunction,isInfinityNumber,isInteger,isLength,isMap,isMatch,isMatchWith,isNaN,isNative,isNil,isNonEmptyArray,isNonEmptyString,isNonEmptyValue,isNull,isNumberObject,isObject,isObjectLoose,isObjectOrArray,isPropertyKey,isRegExp,isSafeInteger,isServer,isSet,isString,isStringObject,isSymbol,isTypedArray,isURL,isUndefined,isValidURL,isWeakMap,textContainsAll,textContainsAny};