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

package/dist/conversions/index.d.ts

@@ -1,4 +1,4 @@
-import{A as AnyFunction,T as TypedArray,W as WebApiObjects,I as IntlObjects}from'../type-data-DDs-u2kq.js';import{N as NormalizeEmptyArraysRecursive,R as RemoveEmptyArrayElements,F as FixNeverArrayRecursive}from'../arrays-normalize-recursive-CnjYJ9xg.js';import{h as Nullish,a as KeepNull,b as KeepUndef}from'../nils-DMz3kU7M.js';import{I as IsAny}from'../any-BmdI8UbK.js';import{c as IfNotExtends,I as IfExtends}from'../extends-Mp81Hq9-.js';import{P as Prettify}from'../prettify-C4xLcYOP.js';import{N as NumberRangeUnion}from'../NumberRangeUnion-DC-C3_Kq.js';import'../if-CvT4R7Kh.js';import'../array-CIZRbqTF.js';import'../never-BfayMBF9.js';type ExcludeNil<T>=Exclude<T,null|undefined>;
+import{A as AnyFunction,T as TypedArray,W as WebApiObjects,I as IntlObjects}from'../type-data-DDs-u2kq.js';import{N as NormalizeEmptyArraysRecursive,R as RemoveEmptyArrayElements,F as FixNeverArrayRecursive}from'../arrays-normalize-recursive-CnjYJ9xg.js';import{h as Nullish,a as KeepNull,b as KeepUndef}from'../nils-DMz3kU7M.js';import{I as IsAny}from'../any-BmdI8UbK.js';import{i as IfNotExtends,I as IfExtends}from'../extends-Bk_SBGdT.js';import{P as Prettify}from'../prettify-C4xLcYOP.js';import{N as NumberRangeUnion}from'../NumberRangeUnion-DC-C3_Kq.js';import'../if-CvT4R7Kh.js';import'../never-BfayMBF9.js';type ExcludeNil<T>=Exclude<T,null|undefined>;
 /** ----------------------------------------------------------
 *  * ***Element extractor***
 * ----------------------------------------------------------
@@ -27,178 +27,125 @@ forceToString?:F;
 */
 flatten?:Fl;};
 /** ----------------------------------------------------------
-* * ***Removes `null` and `undefined` values from an array, including nested arrays.***
-* ----------------------------------------------------------
-*
-* - ✅ Returns `undefined` if the input is explicitly `undefined` or `null`.
-* - ✅ Returns `[]` if input is empty or all elements are removed after filtering.
-* - ✅ Recursively filters nested arrays while preserving structure.
-* - ✅ Ensures proper type inference for safer downstream operations.
-*
-* @template T - The type of elements in the array.
-* @param {T[]} [input] - The array to be filtered.
+* * ***Utility: `filterNilArray`.***
+* ---------------------------------------------
+* **Removes `null` and `undefined` values from an array, including nested arrays.**
+* - **Behavior:**
+*    - Returns `undefined` if the input is explicitly `undefined` or `null`.
+*    - Returns `[]` if input is empty or all elements are removed after filtering.
+*    - Recursively filters nested arrays while preserving structure.
+*    - Ensures proper type inference for safer downstream operations.
+* @template A - The type of elements in the array.
+* @param {T[]|null|undefined} input - The array to be filtered.
 * @returns {T[] | undefined} A new array with `null` and `undefined` values removed,
 * or `undefined` if the input is explicitly `undefined` or `null`.
-*
 * @example
 * ```ts
 * filterNilArray([1, null, 2, undefined, 3]);
 * // ➔ [1, 2, 3]
-*
 * filterNilArray([null, undefined]);
 * // ➔ []
-*
 * filterNilArray(undefined);
 * // ➔ undefined
-*
 * filterNilArray(null);
 * // ➔ undefined
-*
 * filterNilArray([]); // or
 * filterNilArray([[[]]]); // or
 * filterNilArray([[[],undefined,null]]);
 * // ➔ []
-*
 * filterNilArray([1, [null, 2, [undefined, 3]]]);
 * // ➔ [1, [2, [3]]]
 * ```
 */
-declare function filterNilArray(input?:null):undefined;declare function filterNilArray<A extends readonly unknown[]>(input:A):PreserveMutability<A,FilterNilArrayFromTuple<A>>;declare function filterNilArray<A extends readonly unknown[]>(input:A|null|undefined):PreserveMutability<A,FilterNilArrayFromTuple<A>>|undefined;declare function filterNilArray<T>(input?:(T|null|undefined)[]|null|undefined):FilterNilArray<T>|undefined;declare function filterNilArray(input:readonly unknown[]|null|undefined):unknown[]|undefined;declare function filterNilArray(input:unknown[]):unknown[];
-/** ----------------------------------------------------------
-* * ***Removes `null` and `undefined` values from an array, including nested arrays.***
-* ----------------------------------------------------------
-*
-* **⚠️ Notes:** This function is deprecated and renamed to `filterNilArray`, will remove in the next version.
-*
-* @deprecated Use `filterNilArray` instead.
-*/
-declare const filterNullArray:typeof filterNilArray;
+declare function filterNilArray(input:null|undefined):undefined;declare function filterNilArray<A extends readonly unknown[]>(input:A):PreserveMutability<A,FilterNilArrayFromTuple<A>>;declare function filterNilArray<A extends readonly unknown[]>(input:A|null|undefined):PreserveMutability<A,FilterNilArrayFromTuple<A>>|undefined;declare function filterNilArray<A>(input:(A|null|undefined)[]|null|undefined):FilterNilArray<A>|undefined;declare function filterNilArray(input:readonly unknown[]|null|undefined):unknown[]|undefined;declare function filterNilArray(input:unknown[]):unknown[];
 /** ----------------------------------------------------------
-* * ***Deduplicates values in an array (with optional flattening and deep stringification).***
-* ----------------------------------------------------------
-*
+* * ***Utility: `dedupeArray`.***
+* ---------------------------------------------
+* @description
+* Deduplicates values in an array (with optional flattening and deep stringification).
 * - Supports various modes for converting values to strings before deduplication:
 *    - `"stringOrNumber"`: Converts strings and numbers to strings.
 *    - `"primitives"`: Converts all primitives (string, number, boolean, bigint, null, undefined, NaN) to strings.
 *    - `"all"`: Converts all values (primitives, objects, Maps, Sets, Symbols, RegExp, Dates, Errors, Promises, functions)
 *   to strings, including nested object properties.
 *    - `false` (default): No conversion applied.
-*
 * - Options:
 *    - `forceToString`: Enables string conversion for comparison, default is `false`.
 *    - `flatten`: If true, deeply flattens arrays, Maps, and Sets before deduplication, default is `false`.
-*
 * @template ForceToString - `forceToString` mode.
 * @template Flattening - `flatten` mode.
-*
 * @param {unknown[]} inputArray - The array to deduplicate. Can be deeply nested and contain any mix of types.
-* @param {{ forceToString?: false | "stringOrNumber" | "primitives" | "all" }} [options] - Options to control string conversion.
+* @param {DedupeArrayOptions<ForceToString, Flattening>|undefined} [options] - Options to control string conversion.
 * @returns {DedupeResult<ForceToString, Flattening>} Deduplicated array with optional transformations.
-*
 * @throws {TypeError} If the input is not an array, or options is not an object, or if `forceToString` is invalid.
-*
 * @example
 * ```ts
 * dedupeArray(["apple", "banana", "apple"]);
 * // ➔ ["apple", "banana"]
-*
 * dedupeArray([[1, 2], [1, 2]], { flatten: true });
 * // ➔ [1, 2]
-*
 * dedupeArray([new Set([1, 2]), new Set([2, 3])], { flatten: true });
 * // ➔ [1, 2, 3]
-*
 * dedupeArray([1, "1", 2, "2"], {
 *    forceToString: "stringOrNumber"
-* });
-* // ➔ ["1", "2"]
-*
+* }); // ➔ ["1", "2"]
 * dedupeArray([true, "true", false, undefined], {
 *    forceToString: "primitives"
-* });
-* // ➔ ["true", "false", "undefined"]
-*
+* }); // ➔ ["true", "false", "undefined"]
 * dedupeArray([1, "1", { a: 1 }], {
 *    forceToString: "all"
-* });
-* // ➔ ["1", { a: "1" }]
-*
+* }); // ➔ ["1", { a: "1" }]
 * dedupeArray([1, 1, [2, 2, [3, 3]]]);
 * // ➔ [1, [2, [3]]]
-*
 * dedupeArray([null, undefined, null]);
 * // ➔ [null, undefined]
-*
 * dedupeArray([[], [[]], [[[]]], [[]], [[[]]]]);
 * // ➔ [[], [[]], [[[]]]]
-*
 * const fn = () => 1;
 * dedupeArray([fn, fn, () => 1]);
 * // ➔ [fn, () => 1] cause: ref () => 1 and fn is different but ref const `fn` and `fn` is same ref.
-*
 * dedupeArray([Symbol("x"), Symbol("x")]);
 * // ➔ [Symbol("x")] (symbols are same by identity, so dedupe
-*
 * dedupeArray([NaN, NaN, 1, "1"]);
 * // ➔ [NaN, 1, "1"]
-*
 * dedupeArray([NaN, NaN, 1, "1"], {
 *    forceToString: "primitives"
-* });
-* // ➔ ["NaN", "1"]
-*
+* }); // ➔ ["NaN", "1"]
 * dedupeArray([new Date("2025-01-01"), new Date("2025-01-01")]);
 * // ➔ [Date("2025-01-01")] (same time, deduped)
-*
 * dedupeArray([new Date("2025-01-01"), new Date("2025-01-01")], {
 *    forceToString: "all"
-* });
-* // ➔ ["2025-01-01T00:00:00.000Z"]
-*
+* }); // ➔ ["2025-01-01T00:00:00.000Z"]
 * dedupeArray([/abc/, /abc/], {
 *    forceToString: "all"
-* });
-* // ➔ ["/abc/"]
-*
+* }); // ➔ ["/abc/"]
 * dedupeArray([new Map(), new Set(), new Error("err")], {
 *    forceToString: "all"
-* });
-* // ➔ ["[object Map]", "[object Set]", "Error: err"]
-*
+* }); // ➔ ["[object Map]", "[object Set]", "Error: err"]
 * dedupeArray([Promise.resolve(1), Promise.resolve(1)], {
 *    forceToString: "all"
-* });
-* // ➔ ["[object Promise]"]
-*
+* }); // ➔ ["[object Promise]"]
 * dedupeArray([{ a: 1 }, { a: 1 }, { a: 2 }], {
 *    forceToString: "primitives"
-* });
-* // ➔ [{ a: "1" }, { a: "2" }]
-*
+* }); // ➔ [{ a: "1" }, { a: "2" }]
 * dedupeArray([{ a: { b: 1 } }, { a: { b: 1 } }], {
 *    forceToString: "all"
-* });
-* // ➔ [{ a: { b: "1" } }]
-*
+* }); // ➔ [{ a: { b: "1" } }]
 * dedupeArray("not an array");
-* // Throws TypeError
-*
+* // ➔ Throws TypeError
 * dedupeArray([1, 2, 3], {
 *    forceToString: "invalid"
-* });
-* // Throws TypeError
+* }); // ➔ Throws TypeError
 * ```
 */
 declare const dedupeArray:<ForceToString extends ForceToStringOptions=false,Flattening extends boolean=false>(inputArray:unknown[],options?:DedupeArrayOptions<ForceToString,Flattening>)=>DedupeResult<ForceToString,Flattening>;type NormalizeInputToNumberArrayUnRecursive<T>=T extends string|bigint|boolean|number|Nullish?T:HasNonNumberLikeNonNullish<T>;
-/**
-* Detects whether `T` contains any number-like type (`string | number | bigint`).
+/** Detects whether `T` contains any number-like type (`string | number | bigint`).
 *
 * @template T Input type.
 * @returns `true` if `T` contains number-like, otherwise `false`.
 */
 type HasNumberLike<T>=[Extract<T,string|bigint|number>] extends [never]?false:true;
-/**
-* Detects whether `T` contains a string type.
+/** Detects whether `T` contains a string type.
 *
 * - Useful for identifying values that may fail parsing to number (`undefined` when `R=false`).
 *
@@ -206,96 +153,76 @@ type HasNumberLike<T>=[Extract<T,string|bigint|number>] extends [never]?false:tr
 * @returns `true` if `T` contains `string`, otherwise `false`.
 */
 type HasString<T>=[Extract<T,string>] extends [never]?false:true;
-/**
-* Detects whether `T` contains non-number-like, non-nullish values
-* (objects, arrays, symbols, functions, etc.).
+/** Detects whether `T` contains non-number-like, non-nullish values (`objects`, `arrays`, `symbols`, `functions`, `etc`.).
 *
 * @template T Input type.
 * @returns `true` if such types exist, otherwise `false`.
 */
 type HasNonNumberLikeNonNullish<T>=[ Exclude<T,string|bigint|number|Nullish>] extends [never]?false:true;
-/**
-* Computes the return type of `toNumberArrayUnRecursive` based on input type `T` and option `R`.
+/** Computes the return type of `toNumberArrayUnRecursive` based on input type `T` and option `R`.
 *
+* **Behavior:**
+* - If `R = true` (`removeInvalidValueNumber: true`):
+*    - If `T` is only `null | undefined` → returns `[]`.
+*    - If `T` contains number-like (`string | number | bigint`) → returns `number[]`.
+*    - Otherwise → returns `[]`.
+* - If `R = false` (`removeInvalidValueNumber: false`):
+*    - Preserves `null[]` or `undefined[]` if input is purely nullish.
+*    - Otherwise returns an array of:
+*      - `number` if `T` includes number-like.
+*      - `undefined` if parsing fails (string or invalid non-number-like).
+*      - Original `null` / `undefined` from input.
 * @template T Input element type.
 * @template R Flag indicating whether invalid values should be removed (`true`) or kept (`false`).
 *
-* Behavior:
-*
-* - If `R = true` (`removeInvalidValueNumber: true`):
-*   - If `T` is only `null | undefined` → returns `[]`.
-*   - If `T` contains number-like (`string | number | bigint`) → returns `number[]`.
-*   - Otherwise → returns `[]`.
-*
-* - If `R = false` (`removeInvalidValueNumber: false`):
-*   - Preserves `null[]` or `undefined[]` if input is purely nullish.
-*   - Otherwise returns an array of:
-*     - `number` if `T` includes number-like.
-*     - `undefined` if parsing fails (string or invalid non-number-like).
-*     - Original `null` / `undefined` from input.
 */
 type ToNumberArrayUnRecursiveReturn<T,R extends boolean>=R extends true?[ Exclude<T,null|undefined>] extends [never]?[]:HasNumberLike<T>extends true?number[]:[]:[ Exclude<T,null>] extends [never]?null[]:[Exclude<T,undefined>] extends [never]?undefined[]:Array<(HasNumberLike<T>extends true?number:never)|(HasString<T>extends true?undefined:never)|(HasNonNumberLikeNonNullish<T>extends true?undefined:never)|KeepNull<T>|KeepUndef<T>>;
-/**
-* Options object for `toNumberArrayUnRecursive`.
+/** Options object for `toNumberArrayUnRecursive`.
 *
 * @template T Flag indicating whether invalid values should be removed.
 */
 type ToNumberArrayUnRecursiveOptions<T extends boolean>={
-/**
-* If true, removes invalid number values (`NaN`, non-numeric strings, `null`, `undefined`) from the result, defaultValue: `true`.
+/** If true, removes invalid number values (`NaN`, non-numeric strings, `null`, `undefined`) from the result, defaultValue: `true`.
 *
 * @default true
 */
 removeInvalidValueNumber?:T;};
 /** -------------------------------------------------------
-* * ***Converts a flat array of strings, numbers, nulls, or undefineds into numbers.***
+* * ***Utility: `toNumberArrayUnRecursive`.***
 * -------------------------------------------------------
-*
-* - Only supports **flat arrays** (non-recursive).
-* - Valid inputs: `string`, `number`, `null`, `undefined`.
-* - `BigInt` will be converted to `number`.
-* - Other values → coerced into `undefined`.
-* - Invalid values can be **removed** (`removeInvalidValueNumber: true`) or **kept** (`false`).
-* -------------------------------------------------------
-* * **⚠️ Note:** _For recursive / nested arrays, use `toNumberDeep` instead._
-* -------------------------------------------------------
-*
+* **Converts a flat array of strings, numbers, nulls, or undefineds into numbers.**
+* - **Behavior:**
+*    - Only supports **flat arrays** (non-recursive).
+*    - Valid inputs: `string`, `number`, `null`, `undefined`.
+*    - `BigInt` will be converted to `number`.
+*    - Other values → coerced into `undefined`.
+*    - Invalid values can be **removed** (`removeInvalidValueNumber: true`) or **kept** (`false`).
+* - **ℹ️ Note:**
+*    - _For recursive / nested arrays, use **{@link toNumberDeep | `toNumberDeep`}** instead._
 * @template T Element type of the input array.
-* @template RemoveInvalidValue Whether invalid values should be removed (`true`) or kept (`false`).
-*
-* @param {Array<T> | readonly T[] | null | undefined} [array]
-* The array to convert. Returns `undefined` if not an array.
-*
-* @param {ToNumberArrayUnRecursiveOptions<RemoveInvalidValue>} [options]
-* Options controlling conversion behavior. Defaults to `{ removeInvalidValueNumber: true }`.
-*
-* @returns {ToNumberArrayUnRecursiveReturn<NormalizeInput<T>, RemoveInvalidValue>}
-*
+* @template R Whether invalid values should be removed (`true`) or kept (`false`).
+* @param {Array<T> | readonly T[] | null | undefined} [array] The array to convert. Returns `undefined` if not an array.
+* @param {ToNumberArrayUnRecursiveOptions<RemoveInvalidValue>} [options] Options controlling conversion behavior. Defaults to `{ removeInvalidValueNumber: true }`.
+* @returns {ToNumberArrayUnRecursiveReturn<NormalizeInput<T>, RemoveInvalidValue>} A new array of string representations, with invalid values optionally removed.
 * @example
 * ```ts
 * toNumberArrayUnRecursive(['1', 2, '3']);
 * // ➔ [1, 2, 3]
-*
 * toNumberArrayUnRecursive([1, null, undefined, 'abc']);
 * // ➔ [1]
-*
 * toNumberArrayUnRecursive(['1', null, undefined, 'abc'], {
 *   removeInvalidValueNumber: false
 * });
 * // ➔ [1, null, undefined, undefined]
-*
 * toNumberArrayUnRecursive(null);      // ➔ undefined
 * toNumberArrayUnRecursive(undefined); // ➔ undefined
 * toNumberArrayUnRecursive(1);         // ➔ undefined
 * ```
 */
 declare function toNumberArrayUnRecursive(array?:null|undefined,options?:ToNumberArrayUnRecursiveOptions<boolean>):undefined;declare function toNumberArrayUnRecursive(array?:Array<never>,options?:ToNumberArrayUnRecursiveOptions<boolean>):[];declare function toNumberArrayUnRecursive<T,R extends boolean=true>(array?:Array<T>|readonly T[]|null,options?:ToNumberArrayUnRecursiveOptions<R>):ToNumberArrayUnRecursiveReturn<NormalizeInputToNumberArrayUnRecursive<T>,R>;declare function toNumberArrayUnRecursive<T=unknown>(array?:T,options?:ToNumberArrayUnRecursiveOptions<boolean>):undefined;
-/**
-* Union of primitive types that can be safely converted to string.
-*/
+/** Union of primitive types that can be safely converted to string. */
 type AllowedToString=string|number|boolean|bigint;
-/**
-* Checks whether `T` contains any type that is allowed for conversion to string.
+/** Checks whether `T` contains any type that is allowed for conversion to string.
 *
 * - Returns `true` if `T` contains `string`, `number`, `boolean`, or `bigint`.
 * - Otherwise returns `false`.
@@ -303,157 +230,134 @@ type AllowedToString=string|number|boolean|bigint;
 * @template T Input type to check.
 */
 type HasAllowed<T>=[Extract<T,AllowedToString>] extends [never]?false:true;
-/**
-* Checks whether `T` contains any non-nullish value that is disallowed for conversion.
+/** Checks whether `T` contains any non-nullish value that is disallowed for conversion.
 *
-* - Disallowed non-nullish types include objects, arrays, symbols, functions, etc.
+* - Disallowed non-nullish types include `objects`, `arrays`, `symbols`, `functions`, `etc`.
 * - Returns `true` if such types exist, otherwise `false`.
-*
 * @template T Input type to check.
 */
 type HasDisallowedNonNullish<T>=[Exclude<T,AllowedToString|Nullish>] extends [never]?false:true;
-/**
-* Computes the resulting type of `toStringArrayUnRecursive` based on input type `T` and option `R`.
+/** Computes the resulting type of `toStringArrayUnRecursive` based on input type `T` and option `R`.
 *
+* **Behavior:**
+*   - If `R = true` (`removeInvalidValue = true`):
+*     - If `T` contains any allowed values → `string[]`.
+*     - If `T` contains only nullish or disallowed types → `[]`.
+*
+*   - If `R = false` (`removeInvalidValue = false`):
+*     - Include `string` if `T` has allowed values.
+*     - Include `undefined` if `T` has disallowed non-nullish values.
+*     - Preserve `null` and `undefined` from original `T`.
 * @template T Input element type.
 * @template R Flag indicating whether invalid values should be removed (`true`) or kept (`false`).
-*
-* - If `R = true` (`removeInvalidValue = true`):
-*   - If `T` contains any allowed values → `string[]`.
-*   - If `T` contains only nullish or disallowed types → `[]`.
-*
-* - If `R = false` (`removeInvalidValue = false`):
-*   - Include `string` if `T` has allowed values.
-*   - Include `undefined` if `T` has disallowed non-nullish values.
-*   - Preserve `null` and `undefined` from original `T`.
 */
 type ToStringArrayUnRecursiveReturn<T,R extends boolean>=R extends true?HasAllowed<T>extends true?string[]:[]:Array<(HasAllowed<T>extends true?string:never)|(HasDisallowedNonNullish<T>extends true?undefined:never)|KeepNull<T>|KeepUndef<T>>;
-/**
-* Options object for `toStringArrayUnRecursive`.
+/** Options object for `toStringArrayUnRecursive`.
 *
 * @template T Flag indicating whether invalid values should be removed.
 */
 type ToStringArrayUnRecursiveOptions<T extends boolean>={
-/**
-* If true, removes invalid values (`null` and `undefined`) from the output, defaultValue: `true`.
+/** If true, removes invalid values (`null` and `undefined`) from the output, defaultValue: `true`.
 *
 * @default true
 */
 removeInvalidValue?:T;};
 /** ---------------------------------------------
-* * ***Converts all values in a flat array into string representations.***
+* * ***Utility: `toStringArrayUnRecursive`.***
 * ---------------------------------------------
-*
-* - Only processes **flat arrays** (non-recursive).
-* - Supports input values: `string`, `number`, `bigint`, `boolean`, `null`, `undefined`.
-* - Invalid values (`null` and `undefined`) can be **removed** or **kept** depending on the option.
-* - Other unsupported types will be converted to `undefined` (and removed if `removeInvalidValue=true`).
-* ---------------------------------------------
-* * **⚠️ Note:** _For recursive / nested arrays, use `toStringDeep` instead._
-* ---------------------------------------------
-*
-* @template RemoveInvalidValue
-* @param {Array<string | number | bigint | boolean | null | undefined> | null | undefined} [array]
-* The flat array to transform. Returns `undefined` if not an array.
-*
-* @param {ToStringArrayUnRecursiveOptions<RemoveInvalidValue>} [options]
-* Options object to control transformation behavior.
-*
-* @param {RemoveInvalidValue extends true ? boolean : boolean} [options.removeInvalidValue=true]
-* Whether to remove invalid values (`null`, `undefined`, or unsupported types). Default: `true`.
-*
-* @returns {RemoveInvalidValue extends true
-*   ? string[]
-*   : (string | null | undefined)[]}
-* A new array of string representations, with invalid values optionally removed.
-*
+* **Converts all values in a flat array into string representations.**
+* - **Behavior:**
+*    - Only processes **flat arrays** (non-recursive).
+*    - Supports input values: `string`, `number`, `bigint`, `boolean`,
+*      `null`, `undefined`.
+*    - Invalid values (`null` and `undefined`) can be **removed** or **kept**
+*      depending on the option.
+*    - Other unsupported types will be converted to `undefined` (and removed
+*      if `removeInvalidValue=true`).
+* - **ℹ️ Note:**
+*    - _For recursive / nested arrays, use **{@link toStringDeep | `toStringDeep`}** instead._
+* @template T Element type of the input array.
+* @template R Whether invalid values should be removed (`true`) or kept (`false`).
+* @param {Array<string | number | bigint | boolean | null | undefined> | null | undefined} [array] The flat array to transform. Returns `undefined` if not an array.
+* @param {ToStringArrayUnRecursiveOptions<RemoveInvalidValue>} [options] Options object to control transformation behavior.
+* @param {RemoveInvalidValue extends true ? boolean : boolean} [options.removeInvalidValue=true] Whether to remove invalid values (`null`, `undefined`, or unsupported types). Default: `true`.
+* @returns {RemoveInvalidValue extends true ? string[] : (string | null | undefined)[]} A new array of string representations, with invalid values optionally removed.
 * @example
 * ```ts
 * // Convert numbers and strings
 * toStringArrayUnRecursive([1, 2, '3']);
 * // ➔ ['1', '2', '3']
-*
 * // Remove null and undefined
 * toStringArrayUnRecursive([1, null, undefined, 'abc'], {
 *   removeInvalidValue: true
 * });
 * // ➔ ['1', 'abc']
-*
 * // Keep null and undefined
 * toStringArrayUnRecursive([1, null, undefined, 'abc'], {
 *   removeInvalidValue: false
 * });
 * // ➔ ['1', null, undefined, 'abc']
-*
 * // Convert boolean and bigint
 * toStringArrayUnRecursive([true, false, 10n]);
 * // ➔ ['true', 'false', '10']
-*
 * // Not an array → returns undefined
 * toStringArrayUnRecursive(null);
 * // ➔ undefined
-*
 * toStringArrayUnRecursive(undefined);
 * // ➔ undefined
-*
 * toStringArrayUnRecursive(1);
 * // ➔ undefined
-*
 * toStringArrayUnRecursive("string");
 * // ➔ undefined
 * ```
 */
 declare function toStringArrayUnRecursive(array?:undefined|null,options?:ToStringArrayUnRecursiveOptions<boolean>):undefined;declare function toStringArrayUnRecursive(array?:Array<never>,options?:ToStringArrayUnRecursiveOptions<boolean>):[];declare function toStringArrayUnRecursive<T,R extends boolean=true>(array?:Array<T>|readonly T[]|null,options?:ToStringArrayUnRecursiveOptions<R>):ToStringArrayUnRecursiveReturn<T,R>;declare function toStringArrayUnRecursive<T=unknown>(array?:T,options?:ToStringArrayUnRecursiveOptions<boolean>):undefined;
 /** ---------------------------------
-* * ***Converts a given value into a boolean (strict).***
-* ---------------------------------
-*
-* This is stricter than normal JS coercion:
-* - `null` and `undefined` return `false`.
-* - Empty strings return `false`, non-empty strings return `true`.
-* - Numbers: `0` is `false`, others `true`.
-* - Booleans returned as-is.
-* - Arrays: `[]` is `false`, non-empty is `true`.
-* - Objects: `{}` is `false`, object with keys is `true`.
-*
-* @param {unknown} [value] - The value to be converted.
+* * ***Utility: `toBooleanContent`.***
+* ---------------------------------------------
+* **Converts a given value into a boolean (***strict***).**
+* - **This is stricter than normal JS coercion:**
+*    - `null` and `undefined` return `false`.
+*    - Empty strings return `false`, non-empty strings return `true`.
+*    - Numbers: `0` is `false`, others `true`.
+*    - Booleans returned as-is.
+*    - Arrays: `[]` is `false`, non-empty is `true`.
+*    - Objects: `{}` is `false`, object with keys is `true`.
+* @param {*} [value] - The value to be converted.
 * @returns {boolean} `true` if the value is considered non-empty, otherwise `false`.
-*
 * @example
-* toBooleanContent(null);     // ➔ false
-* toBooleanContent("");       // ➔ false
-* toBooleanContent("  ");     // ➔ false
-* toBooleanContent(" asd ");  // ➔ true
-* toBooleanContent("abc");    // ➔ true
-* toBooleanContent(0);        // ➔ false
-* toBooleanContent(42);       // ➔ true
-* toBooleanContent(NaN);      // ➔ true
-* toBooleanContent([]);       // ➔ false
-* toBooleanContent([1]);      // ➔ true
-* toBooleanContent({});       // ➔ false
-* toBooleanContent({ a: 1 }); // ➔ true
+* toBooleanContent(null);      // ➔ false
+* toBooleanContent(undefined); // ➔ false
+* toBooleanContent("");        // ➔ false
+* toBooleanContent("  ");      // ➔ false
+* toBooleanContent("abc");     // ➔ true
+* toBooleanContent(" asd ");   // ➔ true
+* toBooleanContent(0);         // ➔ false
+* toBooleanContent(42);        // ➔ true
+* toBooleanContent(NaN);       // ➔ true
+* toBooleanContent([]);        // ➔ false
+* toBooleanContent([1]);       // ➔ true
+* toBooleanContent({});        // ➔ false
+* toBooleanContent({ a: 1 });  // ➔ true
 * toBooleanContent({[Symbol("key")]: 123}); // ➔ false
 */
-declare const toBooleanContent:(value?:unknown)=>boolean;
+declare const toBooleanContent:(value:unknown)=>boolean;
 /** -------------------------------------------------
-* * ***Recursively checks if value is "non-empty".***
-* -------------------------------------------------
-*
-* This function does a deep inspection to determine if the input
-* contains any meaningful / non-empty value. It is stricter than
-* JavaScript's normal truthy checks because it looks *inside*
-* nested arrays & objects.
-*
-* Rules:
-* - `null` and `undefined` return `false`
-* - Empty strings `""` return `false`
-* - `0` returns `false`
-* - Empty arrays `[]` or empty objects `{}` return `false`
-* - Checks deeply nested arrays/objects — if any value inside is "non-empty", returns `true`
-*
-* @param {unknown} [value] - The value to check.
+* * ***Utility: `toBooleanContentDeep`.***
+* ---------------------------------------------
+* **This function does a deep inspection to determine if the input
+* contains any meaningful / non-empty value.**
+* @description
+* It is stricter than JavaScript's normal truthy checks because it looks *inside*
+* nested arrays & objects (recursively checks).
+* - **Rules:**
+*    - `null` and `undefined` return `false`
+*    - Empty strings `""` return `false`
+*    - `0` returns `false`
+*    - Empty arrays `[]` or empty objects `{}` return `false`
+*    - Checks deeply nested arrays/objects — if any value inside is "non-empty", returns `true`
+* @param {*} [value] - The value to check.
 * @returns {boolean} `true` if the value or anything nested inside is non-empty, otherwise `false`.
-*
 * @example
 * toBooleanContentDeep(null);          // ➔ false
 * toBooleanContentDeep("");            // ➔ false
@@ -473,7 +377,7 @@ declare const toBooleanContent:(value?:unknown)=>boolean;
 * toBooleanContentDeep({ a: { b: "x" }}); // ➔ true
 * toBooleanContentDeep({[Symbol("key")]: 123}); // ➔false
 */
-declare const toBooleanContentDeep:(value?:unknown)=>boolean;type ToBooleanExplicitOptions={
+declare const toBooleanContentDeep:(value:unknown)=>boolean;type ToBooleanExplicitOptions={
 /** Whether string comparison ignores case, _defaultValue: `false`_.
 *
 * @default false
@@ -490,89 +394,71 @@ trimString?:boolean;
 */
 includeIndeterminate?:boolean;};
 /** ---------------------------------
-* * ***Converts a value into a strict boolean.***
-* ---------------------------------
-*
-* It supports various common string representations of truthy values,
-* including `"true"`, `"on"`, `"yes"`, `"1"`, the number `1`, the boolean `true`,
-* and optionally the string `"indeterminate"` if enabled.
-*
-* Any other value, including `undefined`, `null`, `false`, `0`, and
-* unrecognized strings will return `false`.
-*
-* Supports optional `caseInsensitive` and `trimString` to customize string normalization.
-*
-* @param {unknown} [value] - The value to convert.
-* @param {Object} [options] - Options for conversion behavior.
-* @param {boolean} [options.caseInsensitive=false] - Whether string comparison ignores case. Default: `false`.
-* @param {boolean} [options.trimString=true] - Whether to trim whitespace before comparison. Default: `true`.
-* @param {boolean} [options.includeIndeterminate=false] - If `true`, the string `"indeterminate"` is considered a truthy value. Defaults to `false`.
+* * ***Utility: `toBooleanExplicit`.***
+* ---------------------------------------------
+* **Converts a value into a strict boolean.**
+* - **Behavior:**
+*    - It supports various common string representations of truthy values,
+*      including `"true"`, `"on"`, `"yes"`, `"1"`, the number `1`, the boolean `true`,
+*      and optionally the string `"indeterminate"` if enabled.
+* - **ℹ️ Note:**
+*    - Any other value, including `undefined`, `null`, `false`, `0`, and
+*      unrecognized strings will return `false`.
+*    - Supports optional `caseInsensitive` and `trimString` to customize
+*      string normalization.
+* @param {*} [value] - The value to convert.
+* @param {ToBooleanExplicitOptions} [options] - Options for conversion behavior.
+* @param {ToBooleanExplicitOptions["caseInsensitive"]} [options.caseInsensitive=false] - Whether string comparison ignores case, default: `false`.
+* @param {ToBooleanExplicitOptions["trimString"]} [options.trimString=true] - Whether to trim whitespace before comparison, default: `true`.
+* @param {ToBooleanExplicitOptions["includeIndeterminate"]} [options.includeIndeterminate=false] - If `true`, the string `"indeterminate"` is considered a truthy value, defaults to `false`.
 * @returns {boolean} `true` if the value matches a truthy representation, otherwise `false`.
 * @throws {TypeError} Throws if any option provided is not a boolean.
-*
 * @example
-*
 * toBooleanExplicit(1);
 * // ➔ true
-*
 * toBooleanExplicit(true);
 * // ➔ true
-*
 * toBooleanExplicit("on");
 * // ➔ true
-*
 * toBooleanExplicit("1");
 * // ➔ true
-*
 * toBooleanExplicit(0);
 * // ➔ false
-*
 * toBooleanExplicit("off");
 * // ➔ false
-*
 * toBooleanExplicit("Yes");
 * // ➔ false (caseInsensitive is false by default)
-*
 * toBooleanExplicit(" yes ");
 * // ➔ true (whitespace trimmed by default)
-*
 * toBooleanExplicit("YES", { caseInsensitive: true });
 * // ➔ true
-*
 * toBooleanExplicit("YES", { caseInsensitive: false });
 * // ➔ false
-*
 * toBooleanExplicit(" YES ", { trimString: false });
 * // ➔ false (whitespace not trimmed)
-*
 * toBooleanExplicit(" YES ", { trimString: true, caseInsensitive: true });
 * // ➔ true
-*
 * toBooleanExplicit(" YES ", { trimString: true, caseInsensitive: false });
 * // ➔ false
-*
 * toBooleanExplicit("indeterminate");
 * // ➔ false (default)
-*
 * toBooleanExplicit("indeterminate", { includeIndeterminate: true });
 * // ➔ true
 */
-declare const toBooleanExplicit:(value?:unknown,options?:ToBooleanExplicitOptions)=>boolean;
+declare const toBooleanExplicit:(value:unknown,options?:ToBooleanExplicitOptions)=>boolean;
 /** ---------------------------------
-* * ***Converts a given value into a boolean (loose).***
-* ---------------------------------
-*
-* This follows JavaScript's typical truthy/falsy rules with some tweaks:
-* - `null` and `undefined` return `false`.
-* - Empty strings return `false`, non-empty strings return `true`.
-* - Numbers: `0` is `false`, others `true`.
-* - Booleans returned as-is.
-* - Arrays: `[]` is `false`, non-empty is `true`.
-* - Other objects: uses `Boolean(value)`, so `{}` is `true`.
-*
-* @param {unknown} [value] - The value to be converted.
+* * ***Utility: `toBooleanLoose`.***
+* ---------------------------------------------
+* **Converts a given value into a boolean (loose).**
+* - **This follows JavaScript's typical truthy/falsy rules with some tweaks:**
+*    - `null` and `undefined` return `false`.
+*    - Empty strings return `false`, non-empty strings return `true`.
+*    - Numbers: `0` is `false`, others `true`.
+*    - Booleans returned as-is.
+*    - Arrays: `[]` is `false`, non-empty is `true`.
+*    - Other objects: uses `Boolean(value)`, so `{}` is `true`.
+* @param {*} [value] - The value to be converted.
 * @returns {boolean} `true` if the value is truthy, otherwise `false`.
-*
 * @example
 * toBooleanLoose(null);     // ➔ false
 * toBooleanLoose("");       // ➔ false
@@ -584,125 +470,105 @@ declare const toBooleanExplicit:(value?:unknown,options?:ToBooleanExplicitOption
 * toBooleanLoose({});       // ➔ true
 * toBooleanLoose({ a: 1 }); // ➔ true
 */
-declare const toBooleanLoose:(value?:unknown)=>boolean;
+declare const toBooleanLoose:(value:unknown)=>boolean;
 /** -------------------------------------------------------------
-* * ***Parses a human-friendly currency string into a JavaScript number.***
-* -------------------------------------------------------------
-*
-* - Supports multi-locale formats:
-*    - US:           `"15,000.10"`       ➔ `15300.10`
-*    - Swiss:        `"15'000.10"`       ➔ `15300.10`
-*    - French:       `"15 000,10"`       ➔ `15300.10`
-*    - Indian:       `"1,23,456.78"`     ➔ `123456.78`
-*    - European:     `"151.000,10"`      ➔ `151300.10`
-*    - Compact:      `"15300000,10"`     ➔ `15300000.10`
-*
-* - Features:
-*    - Strips symbols automatically: `"Rp"`, `"$"`, `"EUR"`, etc.
-*    - Handles bracket negatives:    `"(15.000,10)"` ➔ `-15300.10`
+* * ***Utility: `parseCurrencyString`.***
+* ---------------------------------------------
+* **Parses a human-friendly currency string into a JavaScript number.**
+* - **Supports multi-locale formats:**
+*    - ***US:***       `"15,000.10"`   ➔ `15300.10`.
+*    - ***Swiss:***    `"15'000.10"`   ➔ `15300.10`.
+*    - ***French:***   `"15 000,10"`   ➔ `15300.10`.
+*    - ***Indian:***   `"1,23,456.78"` ➔ `123456.78`.
+*    - ***European:*** `"151.000,10"`  ➔ `151300.10`.
+*    - ***Compact:***  `"15300000,10"` ➔ `15300000.10`.
+* - **Features:**
+*    - Strips symbols automatically: `"Rp"`, `"$"`, `"EUR"`, `etc`.
+*    - Handles bracket negatives: `"(15.000,10)"` ➔ `-15300.10`.
 *    - Normalizes decimal separator (last dot or comma).
 *    - Detects non-breaking spaces (`\u00A0`, `\u202F`) often in European data.
 *    - Fallback to `0` for empty, invalid, or non-numeric strings.
-*
-* - #### How it parses internally:
-*   1. Removes all characters except digits, `.`, `,`, `'`,  `space`, `\u00A0`, `\u202F`.
-*   2. Detects bracket (...) as negative.
-*   3. If Indian style (`1,23,456`) detected by multiple ,\d{2}, removes all commas.
-*   4. Otherwise:
-*      - If multiple dots & no commas ➔ thousands: removes all `.`.
-*      - If multiple commas & no dots ➔ thousands: removes all `,`.
-*      - If mixed, treats last `,` or `.` as decimal.
-*   5. Converts final decimal to `.` for JS float.
-*
-* - Gotchas:
-*   - If both `.` and `,` are present, last occurrence is used as decimal.
-*   - For strings like `"1.121.234,56"` ➔ decimal is `,`.
-*   - For `"1,121,234.56"` ➔ decimal is `.`.
-*   - For `"15300000,2121"` ➔ decimal becomes `.` internally.
-*
-* @param {string} input Any messy currency string, may contain:
-*   - currency symbols (`Rp`,`$`, `CHF`, `EUR`)
-*
-*   - thousands separators (`.`, `,`, `'`,  `space`, `\u00A0`, `\u202F`)
-*   - various decimal formats (`,` or `.`)
-*   - bracket negative: `"(15.000,10)"`
-*
+* - **How it parses internally:**
+*      1. Removes all characters except digits, `.`, `,`, `'`,  `space`,
+*         `\u00A0`, `\u202F`.
+*      2. Detects bracket (...) as negative.
+*      3. If Indian style (`1,23,456`) detected by multiple ,`\d{2}`, removes all commas.
+*      4. Otherwise:
+*         - If multiple dots & no commas ➔ thousands: removes all `.`.
+*         - If multiple commas & no dots ➔ thousands: removes all `,`.
+*         - If mixed, treats last `,` or `.` as decimal.
+*      5. Converts final decimal to `.` for JS float.
+* - **Gotchas:**
+*    - If both `.` and `,` are present, last occurrence is used as decimal.
+*    - For strings like `"1.121.234,56"` ➔ decimal is `,`.
+*    - For `"1,121,234.56"` ➔ decimal is `.`.
+*    - For `"15300000,2121"` ➔ decimal becomes `.` internally.
+* - **ℹ️ Note:**
+*      - You can use this function as a first step to **sanitize currency inputs**
+*        before storing into database or doing math.
+*      - Always pair this with your formatter for consistent output display.
+* @param {string|null|undefined} input Any messy currency string, may contain:
+*   - Currency symbols (`Rp`,`$`, `CHF`, `EUR`).
+*   - Thousands separators (`.`, `,`, `'`,  `space`, `\u00A0`, `\u202F`).
+*   - Various decimal formats (`,` or `.`).
+*   - Bracket negative: `"(15.000,10)"`.
 * @returns {number}
 *   JavaScript float representation.
 *   Will return `0` for invalid, empty, or non-string input.
-*
-* ***⚠️ Notes:***
-*   - You can use this function as a first step to **sanitize currency inputs**
-*     before storing into database or doing math.
-*   - Always pair this with your formatter for consistent output display.
-*
 * @example
 * ```ts
 * parseCurrencyString("Rp 15.300.000,21");
 * // ➔ 15300000.21
-*
 * parseCurrencyString("15 300 000,21");
 * // ➔ 15300000.21
-*
 * parseCurrencyString("CHF 15'300'000.21");
 * // ➔ 15300000.21
-*
 * parseCurrencyString("$15,300,000.21");
 * // ➔ 15300000.21
-*
 * parseCurrencyString("(15.000,10)");
 * // ➔ -15000.10
-*
 * parseCurrencyString("1,23,456.78");
 * // ➔ 123456.78
-*
 * parseCurrencyString("15300000,2121");
 * // ➔ 15300000.2121
-*
 * parseCurrencyString("USD 15 300 000.21");
 * // ➔ 15300000.21
-*
 * parseCurrencyString("");
 * // ➔ 0
-*
 * parseCurrencyString("abc");
 * // ➔ 0
 * ```
 */
-declare const parseCurrencyString:(input?:string|null)=>number;
+declare const parseCurrencyString:(input:string|null|undefined)=>number;
 /** ----------------------------------------------------------
-* * ***Converts a value from a string to its corresponding JavaScript primitive type.***
-* ----------------------------------------------------------
-*
-* - Supported conversions for string inputs (case-insensitive, trimmed):
-*    - `"true"`      ➔ `true` (***boolean***).
-*    - `"false"`     ➔ `false` (***boolean***).
-*    - `"null"`      ➔ `null`.
-*    - `"yes"`       ➔ `true` (***boolean***).
-*    - `"no"`        ➔ `false` (***boolean***).
-*    - `"nan"`       ➔ `NaN` (***number***).
-*    - `"undefined"` ➔ `undefined`.
-*
-* - Numeric strings with optional thousands separators (e.g. `"3,567,890.14"`) ➔ ***`number`***.
+* * ***Utility: `convertType`.***
+* ---------------------------------------------
+* **Converts a value from a string to its corresponding JavaScript primitive type.**
+* - **Supported conversions for string inputs (case-insensitive, trimmed):**
+*    - `"true"`           ➔ `true` (***boolean***).
+*    - `"false"`          ➔ `false` (***boolean***).
+*    - `"null"`           ➔ `null` (***null***).
+*    - `"yes"`            ➔ `true` (***boolean***).
+*    - `"no"`             ➔ `false` (***boolean***).
+*    - `"nan"` or `"NaN"` ➔ `NaN` (***number***).
+*    - `"undefined"`      ➔ `undefined` (***undefined***).
+* - Numeric strings with optional thousands separators (e.g. `"3,567,890.14"`) ➔ `3567890.14` ***as a `number` type***.
 * - Strings containing only whitespace are converted to empty string `""`.
-*
 * - Non-string inputs are returned unchanged.
 * - Strings not matching any special case are trimmed and returned as-is.
-*
-* @param {unknown} value - The value to convert, usually a string or other type.
-* @returns {unknown} The converted JavaScript primitive (***`boolean`***, ***`number`***, ***`null`***, ***`undefined`***, ***`NaN`***) or the original value if no conversion applies.
-*
+* @param {*} value - The value to convert, usually a string or other type.
+* @returns {*} The converted JavaScript primitive (***`boolean`***, ***`number`***, ***`null`***, ***`undefined`***, ***`NaN`***) or the original value if no conversion applies.
 * @example
-* convertType("true")          // ➔ true
-* convertType(" 42 ")          // ➔ 42
-* convertType("FALSE")         // ➔ false
-* convertType(" null ")        // ➔ null
-* convertType("   ")           // ➔ ""
-* convertType(" Hello World ") // ➔ "Hello World"
-* convertType("NaN")           // ➔ NaN
-* convertType(100)             // ➔ 100
-* convertType(NaN)             // ➔ NaN
-* convertType({})              // ➔ {}
+* convertType("true");          // ➔ true
+* convertType(" 42 ");          // ➔ 42
+* convertType("FALSE");         // ➔ false
+* convertType(" null ");        // ➔ null
+* convertType("   ");           // ➔ ""
+* convertType(" Hello World "); // ➔ "Hello World"
+* convertType("NaN");           // ➔ NaN
+* convertType(100);             // ➔ 100
+* convertType(NaN);             // ➔ NaN
+* convertType({});              // ➔ {}
 */
 declare const convertType:(value:unknown)=>unknown;type NonJsonParsableType=Omit<Exclude<unknown,string|null|undefined>,string>;type Contains<T,U>=[Extract<T,U>] extends [never]?false:true;type UnknownValue={undefined:true;};type SafeJsonParseResult<TData,T>=IfNotExtends<T,NonJsonParsableType>extends true?T extends never?undefined:T extends void?undefined:T extends number?undefined:Contains<T,string>extends true?Contains<T,null & string>extends true?TData|null|undefined:TData|undefined:IfExtends<T,null>extends true?null:IfNotExtends<T,NonJsonParsableType>extends true?TData|null|undefined:undefined:Contains<T,string>extends true?IsAny<T>extends true?TData|undefined|null:TData|undefined:undefined;
 /** --------------------------------------------------
@@ -783,28 +649,24 @@ onError?:(error:Error)=>void;
 */
 checkSymbols?:boolean;};
 /** --------------------------------------------------
-* * ***Cleans parsed JSON data based on provided options.***
-* --------------------------------------------------
-*
+* * ***Utility: `cleanParsedData`.***
+* ---------------------------------------------
+* **Cleans parsed JSON data based on provided options.**
 * @template T - Expected output type.
-* @param {unknown} data - The parsed JSON data.
-* @param {ParseParsedDataOptions} options - Cleaning options.
-* @returns {T | undefined}-The cleaned data.
-*
-* ***⚠️ Notice:*** _If data is JSON string, we recommend use **`safeJsonParse`** for more safe._
-*
-* ***⚠️ Note:*** _If using `convertDates`, result may contain Date objects. You may need type assertions in strict TypeScript settings._
-*
+* @param {*} data - The parsed JSON data.
+* @param {ParseParsedDataOptions} [options] - Cleaning options.
+* @returns {T | null | undefined} The cleaned data.
+* - ***⚠️ Notice:*** _If data is JSON string, we recommend use **{@link safeJsonParse | `safeJsonParse`}** for more safe._
+* - ***⚠️ Note:*** _If using **`convertDates`** **options**, result may contain Date objects, you may need type assertions in strict TypeScript settings._
 * @example
 * ```ts
-* // Convert numbers and remove nulls
+* // 1: Convert numbers and remove nulls
 * const result = cleanParsedData({ age: "25", name: null }, {
 *    convertNumbers: true,
 *    removeNulls: true
 * });
 * console.log(result); // ➔ { age: 25 }
-*
-* // Convert boolean strings
+* // 2: Convert boolean strings
 * const result = cleanParsedData({ isActive: "true" }, {
 *    convertBooleans: true
 * });
@@ -813,61 +675,78 @@ checkSymbols?:boolean;};
 */
 declare const cleanParsedData:<T=unknown>(data:T,options?:ParseParsedDataOptions)=>T|undefined|null;
 /** --------------------------------------------------
-* * ***Parses custom date formats like "DD/MM/YYYY" or "MM/DD/YYYY".***
-* --------------------------------------------------
-*
+* * ***Utility: `parseCustomDate`.***
+* ---------------------------------------------
+* **Parses custom date formats like "DD/MM/YYYY" or "MM/DD/YYYY".**
 * @param {string} dateString - Date string to parse.
 * @param {string} format - Date format to match.
-* @returns {Date | null} - Returns a Date object if valid, otherwise null.
+* @returns {Date | null} Returns a `Date` object if valid, otherwise `null`.
+* @throws {TypeError} Throw an type-error if `dateString` **(first parameter)** and `format` **(second parameter)** is not a string or empty-string.
+* @example
+* // Valid: European format (DD/MM/YYYY)
+* const date1 = parseCustomDate("03/09/2025", "DD/MM/YYYY");
+* console.log(date1); // ➔ Date { Wed Sep 03 2025 ... }
+*
+* // Valid: US format (MM/DD/YYYY)
+* const date2 = parseCustomDate("09/03/2025", "MM/DD/YYYY");
+* console.log(date2); // ➔ Date { Wed Sep 03 2025 ... }
+*
+* // Invalid: wrong format
+* const date3 = parseCustomDate("2025-09-03", "DD/MM/YYYY");
+* console.log(date3); // ➔ null
+*
+* // Invalid: non-date string
+* const date4 = parseCustomDate("hello", "DD/MM/YYYY");
+* console.log(date4); // ➔ null
+*
+* // Throws: wrong parameter types or empty-string
+* parseCustomDate(123, "DD/MM/YYYY");
+* // ➔ TypeError: Parameter `dateString` and `format` must be of type `string`...
 */
 declare const parseCustomDate:(dateString:string,format:string)=>Date|null;
 /** --------------------------------------------------
-* * ***Safely parses JSON while handling errors and applying transformations.***
-* --------------------------------------------------
-*
-* - ✅ **Supports generics** to ensure accurate return type inference.
+* * ***Utility: `safeJsonParse`.***
+* ---------------------------------------------
+* **Safely parses JSON while handling errors and applying transformations.**
+* - **Supports generics** to ensure accurate return type inference.
 *    - Always provide both `<TData, TInput>` for best results.
-*    - ***Scroll down for full generic behavior explanation.***
-* - ✅ Automatically parses valid JSON strings into `objects`, `arrays`, `numbers`, etc.
-* - ✅ Supports data transformation via options (e.g., convert strings to `numbers`, `booleans`, or `dates`).
-* - ✅ Returns:
+*    - ℹ️ ***Scroll down for full generic behavior explanation.***
+* - Automatically parses valid JSON strings into `objects`, `arrays`, `numbers`, etc.
+* - Supports data transformation via options (e.g., convert strings to `numbers`, `booleans`, or `dates`).
+* - **Returns:**
 *    1. `null` ➔ if input is explicitly `null`.
 *    2. `undefined` ➔ if input is `undefined`, not a `string`, or if parsing fails.
 *    3. Parsed and cleaned result (`TData`) ➔ if input is a valid JSON string.
-*
-* ⚠️ **JSON.stringify note**: _If the input JSON string was created using `JSON.stringify()`, any properties with
-*    `undefined` values would have been automatically removed or converted to `null` depending on the serializer, example:_
-*    ```ts
-*    JSON.stringify({ a: undefined, b: 1 }); // ➔ '{"b":1}'
-*    JSON.parse('{"a": undefined, "b": 1}')  // ❌ invalid JSON
-*    ```
-*    _Therefore, if you see `undefined` in raw input, it will likely throw unless pre-cleaned or replaced with `null`._
-*
-*    ```ts
-*    safeJsonParse('{"name": "John", "score": undefined}');
-*    // result ➔ { name: "John", score: null } <- because `undefined` is not valid JSON, gets replaced to null.
-*    ```
-*
-* ℹ️ **Additionally,** this function normalizes single quotes (`'`) to double quotes (`"`) before parsing,
-*    so JSON strings using single quotes will be converted to valid JSON format, example:
-*    ```ts
-*    safeJsonParse("{'name': 'John', 'age': 30}");
-*    // result ➔ { name: "John", age: 30 }
-*
-*    safeJsonParse("{'string\\'s': 'abc', \"quote's\": 'It\\'s awesome!', 'aNumber\\'s': 123, 'keyWith\\'Backslash\\'s': 'value\\'s'}");
-*    // result ➔ { "string's": "abc", "quote's": "It's awesome!", "aNumber's": 123, "keyWith'Backslash's": "value's" }
-*    ```
+* - ⚠️ **JSON.stringify note**:
+*    - _If the input JSON string was created using `JSON.stringify()`, any properties with `undefined`
+*      values would have been automatically removed or converted to `null` depending on the serializer, example:_
+*      ```ts
+*      JSON.stringify({ a: undefined, b: 1 }); // ➔ '{"b":1}'
+*      JSON.parse('{"a": undefined, "b": 1}')  // ❌ invalid JSON
+*      ```
+*      _Therefore, if you see `undefined` in raw input, it will likely throw unless pre-cleaned or replaced with `null`._
+*
+*      ```ts
+*      safeJsonParse('{"name": "John", "score": undefined}');
+*      // result ➔ { name: "John", score: null } <- because `undefined` is not valid JSON, gets replaced to null.
+*      ```
+* - ℹ️ **Additionally:**
+*    - This function normalizes single quotes (`'`) to double quotes (`"`) before parsing,
+*      so JSON strings using single quotes will be converted to valid JSON format, example:
+*      ```ts
+*      safeJsonParse("{'name': 'John', 'age': 30}");
+*      // result ➔ { name: "John", age: 30 }
+*
+*      safeJsonParse("{'string\\'s': 'abc', \"quote's\": 'It\\'s awesome!', 'aNumber\\'s': 123, 'keyWith\\'Backslash\\'s': 'value\\'s'}");
+*      // result ➔ { "string's": "abc", "quote's": "It's awesome!", "aNumber's": 123, "keyWith'Backslash's": "value's" }
+*      ```
 * @template TData - The expected output type after parsing and cleaning.
 * @template TInput - The input value type, used for advanced type inference and return typing.
-*
 * @param {TInput} [value] - The JSON string or value to parse.
 * @param {ParseParsedDataOptions} [options] - Options to clean, convert types, enable strict mode,
 *   support custom date formats, enable logging, or handle errors via callback.
-*
 * @returns {SafeJsonParseResult<TData, TInput>} Parsed and optionally cleaned result, or `null`/`undefined`.
-*
 * @throws {TypeError} If `options` is provided but not a valid object.
-*
 * @example
 * 1. ***Basic parse with number & boolean conversion:***
 *  ```ts
@@ -990,25 +869,19 @@ declare const parseCustomDate:(dateString:string,format:string)=>Date|null;
 */
 declare function safeJsonParse<TData extends Record<string,any>=Record<string,unknown>,TInput extends UnknownValue=UnknownValue>(value:TInput,options?:ParseParsedDataOptions):IsAny<TInput>extends true?TData|null|undefined:undefined;declare function safeJsonParse<TData extends Record<string,any>=Record<string,unknown>,TInput extends string|null|undefined|unknown=undefined>(value:TInput,options?:ParseParsedDataOptions):SafeJsonParseResult<TData,TInput>;
 /** ----------------------------------------------------------
-* * ***Extracts digits from a string or number input.***
-* ----------------------------------------------------------
-*
-* Converts the input to a string, trims whitespace, and removes any characters
-* that are not digits (`0-9`).
-*
-* Returns the cleaned numeric value as a `number`.
-*
-* If the input is a `null`, `undefined`, results in no digits, or not a `string` or `number`,
-* it safely returns `0`.
-*
-* @param {string | number | null | undefined} [value]
+* * ***Utility: `extractDigits`.***
+* ---------------------------------------------
+* **Extracts digits from a string or number input.**
+* - **Behavior:**
+*    - Converts the input to a string, trims whitespace, and removes any characters that are not digits (`0-9`).
+*    - Returns the cleaned numeric value as a `number`.
+*    - If the input is a `null`, `undefined`, results in no digits, or not a `string` (or empty-string) or `number`, it safely return `0`.
+* @param {*} [value]
 *    The value to process.
 *    - Accepts a string, number, `null`, or `undefined`.
-*
 * @returns {number}
 *    - The numeric value after extracting digits.
 *    - Returns `0` if input is invalid or contains no digits.
-*
 * @example
 * extractDigits(12345);       // ➔ 12345
 * extractDigits("9A8B7C6X1"); // ➔ 98761
@@ -1021,19 +894,18 @@ declare function safeJsonParse<TData extends Record<string,any>=Record<string,un
 * extractDigits(-Infinity);   // ➔ 0
 * extractDigits({});          // ➔ 0
 * extractDigits([]);          // ➔ 0
+* extractDigits("");          // ➔ 0
+* extractDigits(" ");         // ➔ 0
 * extractDigits("abc");       // ➔ 0
 * extractDigits("   00a  ");  // ➔ 0
 */
 declare const extractDigits:(value:unknown)=>number;type Prev=[never,NumberRangeUnion<1,30>];type DotPath<T,Prefix extends string="",Depth extends number=NumberRangeUnion<1,30>>=Depth extends never?never:T extends(infer U)[]?U extends object?DotPath<U,`${Prefix}`,Prev[Depth]>:never:T extends object?{[K in Extract<keyof T,string>]:T[K] extends object?DotPath<T[K],`${Prefix}${K}.`,Prev[Depth]>|`${Prefix}${K}`:`${Prefix}${K}`;}[Extract<keyof T,string>]:never;type ConfigRemoveObjectPaths<T>={
-/**
-* The dot-notation path to the property that should be removed.
+/** The dot-notation path to the property that should be removed.
 * Can target deeply nested properties (e.g., `"left.data.sensitive"`).
 *
 * This is resolved relative to the root object `T`, and supports
-* any valid {@link DotPath} path within it.
-*
+* any valid **{@link DotPath | `DotPath`}** path within it.
 * @type {DotPath<T>}
-*
 * @example
 * const obj = {
 *   left: { data: { sensitive: "secret", id: 1 } },
@@ -1052,15 +924,12 @@ declare const extractDigits:(value:unknown)=>number;type Prev=[never,NumberRange
 * // };
 */
 key:DotPath<T>;
-/**
-* When `true`, removes the specified property from **all matching nested levels**,
-* including occurrences inside arrays. Defaults to `false` for single-level removal.
+/** When `true`, removes the specified property from **all matching nested levels**,
+* including occurrences inside arrays, defaults to `false` for single-level removal.
 *
 * Useful if the target property might appear multiple times across different
 * branches or array elements.
-*
 * @default false
-*
 * @example
 * const obj = {
 *   items: [
@@ -1083,46 +952,39 @@ key:DotPath<T>;
 */
 deep?:boolean;};type KeysToRemove<T,K extends readonly ConfigRemoveObjectPaths<T>[]>=K[number] extends{key:infer Key;}?(Key extends string?Key:never):never;type RemoveNested<T,K extends string>=T extends Array<infer U>?RemoveNested<U,K>[]:T extends object?K extends`${infer Head}.${infer Rest}`?Head extends keyof T?{[P in keyof T]:P extends Head?RemoveNested<T[P],Rest>:T[P];}:T:SafeRemove<T,K>:T;type SafeRemove<T,K extends string>=K extends keyof T?Omit<T,K>:T;type ChangeNeverArrayToArrayDeep<T>=T extends never[]?[]:T extends Array<infer U>?ChangeNeverArrayToArrayDeep<U>[]:T extends object?{[K in keyof T]:ChangeNeverArrayToArrayDeep<T[K]>;}:T;type ResultRemoveObjectPaths<T,K extends readonly ConfigRemoveObjectPaths<T>[]>=Prettify<RemoveNested<ChangeNeverArrayToArrayDeep<T>,KeysToRemove<T,K>>,{recursive:true;}>extends never?T:Prettify<RemoveNested<ChangeNeverArrayToArrayDeep<T>,KeysToRemove<T,K>>,{recursive:true;}>;
 /** ------------------------------------------------------------------------
-* * ***Deletes multiple keys (shallow or deeply nested) from an object.***
+* * ***Utility: `removeObjectPaths`.***
 * ------------------------------------------------------------------------
-*
-* - Features:
+* **Deletes multiple keys (shallow or deeply nested) from an object.**
+* - **Features:**
 *    - Removes one or more keys from an object based on their paths (supports dot notation for nested properties).
 *    - Can delete deeply from all matching nested levels (even inside arrays) when `deep: true`.
 *    - By default does **not mutate** the original object. Clones it first.
 *   Set `deepClone = false` to mutate in place (useful for performance on large data).
 *    - Ensures type safety on `key` paths via `DotPath<T>`, reducing accidental invalid paths.
-*
-* - Behavior:
+* - **Behavior:**
 *    - When `deep: false` (default), only deletes the direct property at the specified path.
 *    - When `deep: true`, searches deeply and recursively deletes the key from all levels,
 *   including inside arrays of objects (applies the *same* path repeatedly).
 *    - Skips deletion if the specified path does not exist — no error is thrown.
-*
-* - Edge Handling:
+* - **Edge Handling:**
 *    - If `object` is `null` or not an object, returns an empty object.
 *    - If `keysToDelete` is not an array of `{ key, deep? }` objects, throws a `TypeError`.
 *    - Ignores invalid intermediate paths (will skip those branches without throwing).
-*
 * @template T - The shape of the input object, used for type-safe dot paths.
-*
-* @param {T} object - The object to remove keys from. Must be an object or will return `{}`.
-* @param {Array<{ key: DotPath<T>, deep?: boolean }>} keysToDelete
+* @param {Record<string, unknown>} object - The object to remove keys from. Must be an object or will return `{}`.
+* @param {ConfigRemoveObjectPaths<T>[]} keysToDelete
 *   An array of instructions:
 *   - `key`: A string path using dot notation (e.g. `"user.profile.name"`).
 *   - `deep`: If `true`, will recursively remove all instances of the key path at any depth, defaultValue: `false`.
-* @param {boolean} [deepClone=true]
+* @param {boolean|undefined} [deepClone=true]
 *   Whether to deep clone the original object before modifying.
 *   - `true` (default): returns a *new object* with the specified keys removed.
 *   - `false`: modifies the original object in place and returns it.
-*
 * @returns {Partial<T>}
 *   - A new object with specified keys removed if `deepClone` is `true`.
 *   - The *same mutated object* if `deepClone` is `false`.
-*
 * @throws {TypeError}
 *   - If `keysToDelete` is not an array of `{ key, deep? }` objects.
-*
 * @example
 * // Shallow deletion
 * removeObjectPaths(
@@ -1131,7 +993,6 @@ deep?:boolean;};type KeysToRemove<T,K extends readonly ConfigRemoveObjectPaths<T
 * );
 * // ➔ { a: 1, c: { d: 3 } }
 *
-* @example
 * // Nested deletion (shallow, removes only exact path)
 * removeObjectPaths(
 *   { user: { profile: { name: "Alice", age: 30 } } },
@@ -1139,7 +1000,6 @@ deep?:boolean;};type KeysToRemove<T,K extends readonly ConfigRemoveObjectPaths<T
 * );
 * // ➔ { user: { profile: { name: "Alice" } } }
 *
-* @example
 * // Deep deletion (recursively removes key from all levels and arrays)
 * removeObjectPaths(
 *   { items: [{ price: 10 }, { price: 20, details: { price: 30 } }] },
@@ -1147,30 +1007,26 @@ deep?:boolean;};type KeysToRemove<T,K extends readonly ConfigRemoveObjectPaths<T
 * );
 * // ➔ { items: [{}, { details: {} }] }
 *
-* @example
 * // Without cloning: mutates original object
 * const obj = { x: 1, y: 2 };
 * removeObjectPaths(obj, [{ key: "y" }], false);
 * console.log(obj); // ➔ { x: 1 }
 *
-* @example
 * // No matching path — returns unchanged object
 * removeObjectPaths({}, [{ key: "a" }]);
 * // ➔ {}
 *
-* @example
 * // 🚫 Invalid usage — `keysToDelete` is not an array
 * removeObjectPaths({}, "a");
 * // ➔ throws TypeError
 *
-* @example
 * // 🚫 Invalid usage — missing `key` property in array element
 * removeObjectPaths({}, [{ deep: true }]);
 * // ➔ throws TypeError
 */
 declare function removeObjectPaths<T extends Record<string,unknown>,K extends ConfigRemoveObjectPaths<T>[]>(object:T,keysToDelete:K,deepClone?:boolean):ResultRemoveObjectPaths<T,K>;
 /** -------------------------------------------------
-* * ***Options for `safeStableStringify`.***
+* * ***Options for **{@link safeStableStringify | `safeStableStringify`}**.***
 * -------------------------------------------------
 */
 type SafeStableStringifyOptions={
@@ -1199,56 +1055,50 @@ sortArray?:boolean;
 */
 pretty?:boolean;};
 /** --------------------------------------------
-* * ***Safely converts a JavaScript value into a stable, JSON-compatible string.***
-* --------------------------------------------
-*
-* This function is an enhanced version of `JSON.stringify` with additional guarantees:
-*
-* - Features:
-*    - Recursively sorts object keys **only if** `sortKeys` is `true` (default: `true`), to ensure stable key order.
-*      - If `sortKeys` is `false`, preserves the original insertion order of object keys.
-*    - Optionally sorts array primitive values **only if** `sortArray` is `true` (default: `false`).
-*    - Only primitive values in arrays are sorted.
-*    - Objects and nested arrays keep their original position and are appended after sorted primitives.
-*    - If `sortArray` is `false`, arrays retain their original order.
-* - Converts JavaScript special values for JSON safety:
-*    - `undefined`, `NaN`, `Infinity`, `-Infinity` ➔ `null`
-*    - `BigInt` ➔ string (JSON does not support BigInt)
-* - Converts boxed primitives box into their primitive equivalents:
-*    - `new Number(42)` ➔ `Number(42)` ➔ `42`.
-*    - `new String("hi")` ➔ `String("hi")` ➔ `"hi"`.
-*    - `new Boolean(true)` ➔ `Boolean(true)` ➔ `true`.
-* - Functions and Symbols are removed.
-* - Circular references are replaced with the string `"[Circular]"`.
-* - Serializes:
-*    - `Date` ➔ ISO string (`date.toISOString()`)
-*    - `Set` ➔ `{ set: [values...] }` (values are recursively processed)
-*    - `Map` ➔ `{ map: [ [key, value], ... ] }` (values are recursively processed)
-*
-* - Compared to `JSON.stringify`, this ensures **stable output**:
-*    - Same object structure always produces the same string.
-*    - Useful for deep equality checks, hashing, caching keys, or snapshot tests.
-*
-* @param {unknown} value
-* -  Any JavaScript value to serialize. Can be:
+* * ***Utility: `safeStableStringify`.***
+* ---------------------------------------------
+* **Safely converts a JavaScript value into a stable, JSON-compatible string.**
+* - **This function is an enhanced version of `JSON.stringify` with additional guarantees:**
+*    - ***Features:***
+*        - Recursively sorts object keys **only if** `sortKeys` is `true` (default: `true`), to ensure stable
+*          key order.
+*          - If `sortKeys` is `false`, preserves the original insertion order of object keys.
+*        - Optionally sorts array primitive values **only if** `sortArray` is `true` (default: `false`).
+*        - Only primitive values in arrays are sorted.
+*        - Objects and nested arrays keep their original position and are appended after sorted primitives.
+*        - If `sortArray` is `false`, arrays retain their original order.
+*        - Converts JavaScript special values for JSON safety:
+*            - `undefined`, `NaN`, `Infinity`, `-Infinity` ➔ `null`
+*            - `BigInt` ➔ string (JSON does not support BigInt)
+*        - Converts boxed primitives box into their primitive equivalents:
+*            - `new Number(42)` ➔ `Number(42)` ➔ `42`.
+*            - `new String("hi")` ➔ `String("hi")` ➔ `"hi"`.
+*            - `new Boolean(true)` ➔ `Boolean(true)` ➔ `true`.
+*        - Functions and Symbols are removed.
+*        - Circular references are replaced with the string `"[Circular]"`.
+*        - Serializes:
+*            - `Date` ➔ ISO string (`date.toISOString()`)
+*            - `Set` ➔ `{ set: [values...] }` (values are recursively processed)
+*            - `Map` ➔ `{ map: [ [key, value], ... ] }` (values are recursively processed)
+*        - Compared to `JSON.stringify`, this ensures **stable output**:
+*            - Same object structure always produces the same string.
+*            - Useful for deep equality checks, hashing, caching keys, or snapshot tests.
+* @param {*} value
+* -  Any JavaScript value to serialize, can be:
 *    - Primitives (`number`, `string`, `boolean`, `bigint`, `null`, `undefined`)
 *    - Boxed primitives (`new Number()`, `new String()`, `new Boolean()`)
 *    - Arrays, plain objects, nested structures
 *    - Date, Map, Set
 *    - Circular structures
-*
 * @param {SafeStableStringifyOptions} [options]
 * - Configuration options for `safeStableStringify`:
-*    - `sortKeys` (boolean) – Whether to sort object keys alphabetically (recursively). Default: `true`.
-*    - `sortArray` (boolean) – Whether to sort primitive values inside arrays. Default: `false`.
-*    - `pretty` (boolean) – Whether to pretty-print JSON output with 2-space indentation. Default: `false`.
-*
+*    - `sortKeys` (boolean) – Whether to sort object keys alphabetically (recursively), default: `true`.
+*    - `sortArray` (boolean) – Whether to sort primitive values inside arrays, default: `false`.
+*    - `pretty` (boolean) – Whether to pretty-print JSON output with 2-space indentation, default: `false`.
 * @returns {string}
 *   A stable JSON string representation of the input value.
-*
 * @throws {TypeError}
 *   Throws if `sortKeys`, `sortArray`, or `pretty` are not strictly boolean.
-*
 * @example
 * ```ts
 * // Basic object key sorting
@@ -1320,89 +1170,60 @@ pretty?:boolean;};
 *
 * // Complex nested sortArray with objects
 * const arr = [9, 7, [4, 2, 3], { z: [5, 1, 6] }];
-* safeStableStringify(arr, { sortArray:true, sortKeys:true });
+* safeStableStringify(arr, { sortArray: true, sortKeys: true });
 * // ➔ '[7,9,[2,3,4],{"z":[1,5,6]}]'
 * ```
 */
 declare const safeStableStringify:(value:unknown,options?:SafeStableStringifyOptions)=>string;
 /** ----------------------------------------------------------
-* * ***Recursively converts a value into a string based on the `forceToString` option.***
-* ----------------------------------------------------------
-*
-* - `"stringOrNumber"`: Converts strings and numbers to strings.
-* - `"primitives"`: Converts all primitives (number, string, boolean, bigint, undefined, null, NaN) to strings.
-* - `"all"`: Converts everything, including symbols, functions, Dates, RegExp, Maps, Sets, Errors, Promises,
+* * ***Utility: `toStringDeepForce`.***
+* ---------------------------------------------
+* **Recursively converts a value into a string based on the `forceToString` options.**
+* - **Rules `forceToString` options:**
+*    - `"stringOrNumber"`: Converts strings and numbers to strings.
+*    - `"primitives"`: Converts all primitives (number, string, boolean, bigint, undefined, null, NaN) to strings.
+*    - `"all"`: Converts everything, including symbols, functions, Dates, RegExp, Maps, Sets, Errors, Promises,
 *   and deeply all object properties, to strings.
-* - `false` (default): Leaves everything unchanged.
-*
-* Special behaviors:
-* - `NaN` ➔ `"NaN"` only in `"primitives"` or `"all"` mode.
-* - `Date` ➔ ISO string only in `"all"` mode.
-* - `RegExp` ➔ Source string (e.g. `/abc/i`) only in `"all"` mode.
-* - `Symbol` ➔ `Symbol(description)` string only in `"all"` mode.
-* - `Map` ➔ Array of [key, value] pairs with keys/values stringified deeply (only in `"all"` mode).
-* - `Set` ➔ Array of values stringified deeply (only in `"all"` mode).
-* - `Function` ➔ Source code string (e.g. `"() => 1"`) only in `"all"` mode.
-* - `Error`, `Promise` ➔ Stringified via `.toString()` only in `"all"` mode.
-*
-*
-* @param {unknown} value - The value to process. Can be anything: primitive, array, object, function, etc.
+*    - `false`: Leaves everything unchanged.
+* - **Special behaviors:**
+*    - `NaN` ➔ `"NaN"` only in `"primitives"` or `"all"` mode.
+*    - `Date` ➔ ISO string only in `"all"` mode.
+*    - `RegExp` ➔ Source string (e.g. `/abc/i`) only in `"all"` mode.
+*    - `Symbol` ➔ `Symbol(description)` string only in `"all"` mode.
+*    - `Map` ➔ Array of [key, value] pairs with keys/values stringified deeply (only in `"all"` mode).
+*    - `Set` ➔ Array of values stringified deeply (only in `"all"` mode).
+*    - `Function` ➔ Source code string (e.g. `"() => 1"`) only in `"all"` mode.
+*    - `Error`, `Promise` ➔ Stringified via `.toString()` only in `"all"` mode.
+* @param {*} value - The value to process. Can be anything: primitive, array, object, function, etc.
 * @param {false | "stringOrNumber" | "primitives" | "all"} forceToString - The mode of string conversion.
 * @returns {unknown} A new value with the conversion applied based on `forceToString`.
-*
 * @example
 * toStringDeepForce(42, "stringOrNumber");
 * // ➔ "42"
-*
-* @example
 * toStringDeepForce(true, "primitives");
 * // ➔ "true"
-*
-* @example
 * toStringDeepForce(null, "primitives");
 * // ➔ "null"
-*
-* @example
 * toStringDeepForce(Symbol("x"), "all");
 * // ➔ "Symbol(x)"
-*
-* @example
 * toStringDeepForce({ a: 1, b: [2, NaN] }, "primitives");
 * // ➔ { a: "1", b: ["2", "NaN"] }
-*
-* @example
 * toStringDeepForce(new Date("2025-01-01"), "all");
 * // ➔ "2025-01-01T00:00:00.000Z"
-*
-* @example
 * toStringDeepForce(() => 1, "all");
 * // ➔ "() => 1"
-*
-* @example
 * toStringDeepForce(/abc/i, "all");
 * // ➔ "/abc/i"
-*
-* @example
 * toStringDeepForce(new Map([["a", 1], ["b", 2]]), "all");
 * // ➔ [["a", "1"], ["b", "2"]]
-*
-* @example
 * toStringDeepForce(new Set([1, 2, 3]), "all");
 * // ➔ ["1", "2", "3"]
-*
-* @example
 * toStringDeepForce(new Error("Oops"), "all");
 * // ➔ "Error: Oops"
-*
-* @example
 * toStringDeepForce(Promise.resolve(1), "all");
 * // ➔ "[object Promise]"
-*
-* @example
 * toStringDeepForce({ func: () => 123 }, "all");
 * // ➔ { func: "() => 123" }
-*
-* @example
 * toStringDeepForce([1, "a", { b: 2 }], false);
 * // ➔ [1, "a", { b: 2 }]
 */
@@ -1463,62 +1284,47 @@ removeEmptyObjects?:RemoveEmptyObjects;
 */
 removeEmptyArrays?:RemoveEmptyArrays;};
 /** --------------------------------------------------
-* * ***Converts deeply nested arrays, objects, buffers, sets, maps, or typed arrays into numbers while preserving structure.***
-* --------------------------------------------------
-*
-* Features:
-* - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`, empty-string, non-numeric strings, and functions.
-* - Recursively processes nested objects, arrays, buffers, sets, maps, and typed arrays.
-* - Converts numeric strings to numbers (e.g., `"3.5"` ➔ `3.5`).
-* - Keeps empty objects `{}` unless `removeEmptyObjects: true`.
-* - Keeps empty arrays `[]` unless `removeEmptyArrays: true`.
-* - Buffers and TypedArrays are converted into arrays of numbers.
-* - Date objects are converted into their timestamp (`number`).
-*
+* * ***Utility: `toNumberDeep`.***
+* ---------------------------------------------------
+* **Converts deeply nested arrays, objects, buffers, sets, maps, or typed arrays into numbers while preserving structure.**
+* - **Features:**
+*    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`, empty-string, non-numeric strings, and functions.
+*    - Recursively processes nested objects, arrays, buffers, sets, maps, and typed arrays.
+*    - Converts numeric strings to numbers (e.g., `"3.5"` ➔ `3.5`).
+*    - Keeps empty objects `{}` unless `removeEmptyObjects: true`.
+*    - Keeps empty arrays `[]` unless `removeEmptyArrays: true`.
+*    - Buffers and TypedArrays are converted into arrays of numbers.
+*    - Date objects are converted into their timestamp (`number`).
 * @template T - The input type.
 * @template RemoveEmptyObjects - Whether to remove empty objects.
 * @template RemoveEmptyArrays - Whether to remove empty arrays.
-*
-* @param {T} input - The input value to convert.
+* @param {*} input - The input value to convert.
 * @param {ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>} [options] - Conversion options.
-* @returns {ConvertedDeepNumber<T, RemoveEmptyObjects, RemoveEmptyArrays>} The converted value.
-*   - `undefined` if the input is entirely empty or filtered out by options.
-*
+* @returns {ConvertedDeepNumber<T, RemoveEmptyObjects, RemoveEmptyArrays>|undefined} The converted value, return `undefined` if the input is entirely empty or filtered out by options.
 * @example
 * ```ts
 * toNumberDeep("123");
 * // ➔ 123
-*
 * toNumberDeep("abc");
 * // ➔ undefined
-*
 * toNumberDeep([NaN, "10", "xyz"]);
 * // ➔ [10]
-*
 * toNumberDeep({ a: "1", b: [null, "2"] });
 * // ➔ { a: 1, b: [2] }
-*
 * toNumberDeep(Buffer.from([0, 1, 2]));
 * // ➔ [0, 1, 2]
-*
 * toNumberDeep(new Set(["1", "2"]));
 * // ➔ [1, 2]
-*
 * toNumberDeep(new Map([["a", "1"], ["b", "2"]]));
 * // ➔ [["a", 1], ["b", 2]]
-*
 * toNumberDeep(new Int16Array([1, 2, 3]));
 * // ➔ [1, 2, 3]
-*
 * toNumberDeep(new Date("2025-08-16T00:00:00Z"));
 * // ➔ 1755552000000
-*
 * toNumberDeep({ a: {}, b: [] }, { removeEmptyObjects: true });
 * // ➔ { b: [] }
-*
 * toNumberDeep({ a: {}, b: [] }, { removeEmptyArrays: true });
 * // ➔ { a: {} }
-*
 * toNumberDeep({ x: {}, y: [], z: [{ a: {}, b: [] }] }, {
 *    removeEmptyObjects: true, removeEmptyArrays: true
 * });
@@ -1571,28 +1377,25 @@ removeEmptyObjects?:RemoveEmptyObjects;
 */
 removeEmptyArrays?:RemoveEmptyArrays;};
 /** --------------------------------------------------
-* * ***Converts all values in an array, object, Set, Map, or deeply nested structure to string.***
-* --------------------------------------------------
-*
-* Features:
-* - Converts numbers and strings to string (e.g., `123` ➔ `"123"`).
-* - Converts Date to ISO string (`Date ➔ string`).
-* - Converts RegExp to string (e.g., `/abc/ ➔ "/abc/"`).
-* - Converts Buffer, TypedArray, Set, Map, and arrays recursively to arrays of strings.
-* - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.
-* - Removes unsupported types like functions, symbols, and BigInt.
-* - Recursively processes nested objects, arrays, Sets, and Maps.
-* - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.
-*
+* * ***Utility: `toStringDeep`.***
+* ---------------------------------------------------
+* **Converts all values in an array, object, Set, Map, or deeply nested structure to string.**
+* - **Features:**
+*    - Converts numbers and strings to string (e.g., `123` ➔ `"123"`).
+*    - Converts Date to ISO string (`Date ➔ string`).
+*    - Converts RegExp to string (e.g., `/abc/ ➔ "/abc/"`).
+*    - Converts Buffer, TypedArray, Set, Map, and arrays recursively to arrays of strings.
+*    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.
+*    - Removes unsupported types like functions, symbols, and BigInt.
+*    - Recursively processes nested objects, arrays, Sets, and Maps.
+*    - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.
 * @template T - The input data type (primitive, object, array, Set, Map, or any nested combination).
 * @template RemoveEmptyObjects - If `true`, empty objects `{}` will be removed recursively.
-* @template RemoveEmptyArrays - If `true`, empty arrays `[]` will be removed recursively (including arrays nested in objects/arrays/Sets/Maps).
-*
-* @param {T} input - The data to convert.
+* @template RemoveEmptyArrays - If `true`, empty arrays `[]` will be removed recursively (including arrays nested in `objects` / `arrays` / `Sets` / `Maps`).
+* @param {*} input - The data to convert.
 * @param {ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>} [options] - Conversion options.
-* @returns {ConvertedDeepString<T, RemoveEmptyObjects, RemoveEmptyArrays>}
+* @returns {ConvertedDeepString<T, RemoveEmptyObjects, RemoveEmptyArrays>|undefined}
 * The transformed data, or `undefined` if the entire structure becomes empty after processing.
-*
 * @example
 * ```ts
 * // Simple array conversion
@@ -1630,4 +1433,4 @@ removeEmptyArrays?:RemoveEmptyArrays;};
 * // ➔ undefined
 * ```
 */
-declare function toStringDeep(input?:null|undefined,options?:ToStringDeepOptions<boolean,boolean>):undefined;declare function toStringDeep<T,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>(input:T,options?:ToStringDeepOptions<RemoveEmptyObjects,RemoveEmptyArrays>):ConvertedDeepString<T,RemoveEmptyObjects,RemoveEmptyArrays>;export{cleanParsedData,convertType,dedupeArray,extractDigits,filterNilArray,filterNullArray,parseCurrencyString,parseCustomDate,removeObjectPaths,safeJsonParse,safeStableStringify,toBooleanContent,toBooleanContentDeep,toBooleanExplicit,toBooleanLoose,toNumberArrayUnRecursive,toNumberDeep,toStringArrayUnRecursive,toStringDeep,toStringDeepForce};
+declare function toStringDeep(input?:null|undefined,options?:ToStringDeepOptions<boolean,boolean>):undefined;declare function toStringDeep<T,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>(input:T,options?:ToStringDeepOptions<RemoveEmptyObjects,RemoveEmptyArrays>):ConvertedDeepString<T,RemoveEmptyObjects,RemoveEmptyArrays>;export{cleanParsedData,convertType,dedupeArray,extractDigits,filterNilArray,parseCurrencyString,parseCustomDate,removeObjectPaths,safeJsonParse,safeStableStringify,toBooleanContent,toBooleanContentDeep,toBooleanExplicit,toBooleanLoose,toNumberArrayUnRecursive,toNumberDeep,toStringArrayUnRecursive,toStringDeep,toStringDeepForce};