@rzl-zone/utils-js 3.2.6-beta.0 → 3.3.1

package/dist/conversions/index.d.ts

@@ -1,144 +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{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***
- * ----------------------------------------------------------
- */
-type ElementOf<A extends readonly unknown[]>=A extends readonly(infer U)[]?U:never;
-/** ----------------------------------------------------------
- * * ***Compute `FilterNilArray`***
- * ----------------------------------------------------------
- *
- * for a tuple/array A by using the element type (without null|undefined).
- *
- */
-type FilterNilArrayFromTuple<A extends readonly unknown[]>=FilterNilArray<ExcludeNil<ElementOf<A>>>;
-/** ----------------------------------------------------------
- * ***Preserve `mutability`: if A is mutable (extends unknown[]), keep B; otherwise make B readonly***. */
-type PreserveMutability<A extends readonly unknown[],B>=A extends unknown[]?B:Readonly<B>;type IsDeepEmptyArray<T>=T extends readonly []?true:T extends readonly(infer U)[]?IsDeepEmptyArray<U>:false;type FilterNilRecursive<T>=T extends readonly(infer U)[]?T extends(infer U)[]?FilterNilRecursive<ExcludeEmptyArray<U>>[]:readonly FilterNilRecursive<ExcludeEmptyArray<U>>[]:Exclude<T,null|undefined>;type ExcludeEmptyArray<T>=T extends []?never:T;type NormalizerArrays<T>=NormalizeEmptyArraysRecursive<RemoveEmptyArrayElements<FilterNilRecursive<T[]>>>;type FilterNilArray<T>=IsDeepEmptyArray<NormalizerArrays<T>>extends true?[]:FixNeverArrayRecursive<NormalizerArrays<T>>;type ResUnFTN<Force extends false|"stringOrNumber"|"primitives"|"all"=false>=Force extends"all"?Array<unknown[]|Record<string,unknown>|string>:Force extends"stringOrNumber"?Array<string|boolean|bigint|symbol|null|undefined|Record<string,unknown>|AnyFunction|unknown[]|Date|RegExp|Map<unknown,unknown>|Set<unknown>|Promise<unknown>>:Force extends"primitives"?Array<string|symbol|Record<string,unknown>|AnyFunction|unknown[]|Date|RegExp|Map<unknown,unknown>|Set<unknown>|Promise<unknown>>:Force extends false?Array<string|number|bigint|boolean|symbol|RegExp|Record<string,unknown>|AnyFunction|Date|Map<unknown,unknown>|Set<unknown>|Promise<unknown>|unknown[]|null|undefined>:unknown[];type ResFTN<Force extends false|"stringOrNumber"|"primitives"|"all"=false>=Force extends"all"?Array<string|Record<string,unknown>>:Force extends"stringOrNumber"?Array<string|boolean|bigint|symbol|null|undefined|Record<string,unknown>|AnyFunction|Date|RegExp|Promise<unknown>>:Force extends"primitives"?Array<string|symbol|RegExp|Record<string,unknown>|AnyFunction|Date|Promise<unknown>>:Force extends false?Array<string|number|bigint|boolean|symbol|RegExp|Record<string,unknown>|AnyFunction|Date|Promise<unknown>|null|undefined>:unknown[];type DedupeResult<Force extends ForceToStringOptions=false,FTN extends boolean=false>=FTN extends false?ResUnFTN<Force>:ResFTN<Force>;type ForceToStringOptions=false|"stringOrNumber"|"primitives"|"all";type DedupeArrayOptions<F extends ForceToStringOptions,Fl extends boolean>={
-/** Enables string conversion for comparison, default is `false`.
- *
- * @default false
- * @type {ForceToStringOptions}
- */
-forceToString?:F;
-/** If true, deeply flattens arrays, Maps, and Sets before deduplication, default is `false`.
- *
- * @default false
- */
-flatten?:Fl;};
-/** ----------------------------------------------------------
- * * ***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):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[];
-/** ----------------------------------------------------------
- * * ***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 {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"]
- * dedupeArray([true, "true", false, undefined], {
- *    forceToString: "primitives"
- * }); // ➔ ["true", "false", "undefined"]
- * dedupeArray([1, "1", { a: 1 }], {
- *    forceToString: "all"
- * }); // ➔ ["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"]
- * 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"]
- * dedupeArray([/abc/, /abc/], {
- *    forceToString: "all"
- * }); // ➔ ["/abc/"]
- * dedupeArray([new Map(), new Set(), new Error("err")], {
- *    forceToString: "all"
- * }); // ➔ ["[object Map]", "[object Set]", "Error: err"]
- * dedupeArray([Promise.resolve(1), Promise.resolve(1)], {
- *    forceToString: "all"
- * }); // ➔ ["[object Promise]"]
- * dedupeArray([{ a: 1 }, { a: 1 }, { a: 2 }], {
- *    forceToString: "primitives"
- * }); // ➔ [{ a: "1" }, { a: "2" }]
- * dedupeArray([{ a: { b: 1 } }, { a: { b: 1 } }], {
- *    forceToString: "all"
- * }); // ➔ [{ a: { b: "1" } }]
- * dedupeArray("not an array");
- * // ➔ Throws TypeError
- * dedupeArray([1, 2, 3], {
- *    forceToString: "invalid"
- * }); // ➔ 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>;
+import{h as Nullish,a as KeepNull,b as KeepUndef}from'../nils-CO8zLHSB.js';import{A as AnyFunction,P as Prettify,T as TypedArray,W as WebApiObjects,j as IntlObjects}from'../prettify-3o8_Kw6b.js';import{N as NormalizeEmptyArraysRecursive,R as RemoveEmptyArrayElements,F as FixNeverArrayRecursive}from'../arrays-normalize-recursive-BqmVuFlD.js';import{I as IsAny}from'../any-v4TsK9ES.js';import{i as IfNotExtends,I as IfExtends,E as Extends}from'../extends-DtdRjDyU.js';import{N as NumberRangeUnion}from'../NumberRangeUnion-B6bhM2s7.js';import{O as OrArr,a as AndArr}from'../or-C6qzKt2I.js';import'../if-ChM35c_q.js';import'../never-D89PbPh5.js';type NormalizeInputToNumberArrayUnRecursive<T>=T extends string|bigint|boolean|number|Nullish?T:HasNonNumberLikeNonNullish<T>;
 /** Detects whether `T` contains any number-like type (`string | number | bigint`).
  *
  * @template T Input type.
@@ -159,13 +19,16 @@ type HasString<T>=[Extract<T,string>] extends [never]?false:true;
  * @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 {@link toNumberArrayUnRecursive|`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 `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:
@@ -177,7 +40,9 @@ type HasNonNumberLikeNonNullish<T>=[ Exclude<T,string|bigint|number|Nullish>] ex
  *
  */
 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 for {@link toNumberArrayUnRecursive|`toNumberArrayUnRecursive`}.***
+ * -------------------------------------------------------
  *
  * @template T Flag indicating whether invalid values should be removed.
  */
@@ -195,14 +60,14 @@ removeInvalidValueNumber?:T;};
  *    - Only supports **flat arrays** (non-recursive).
  *    - Valid inputs: `string`, `number`, `null`, `undefined`.
  *    - `BigInt` will be converted to `number`.
- *    - Other values → coerced into `undefined`.
+ *    - 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 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 }`.
+ * @template T - Element type of the input array.
+ * @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 to control transformation behavior, defaults to `{ removeInvalidValueNumber: true }`.
  * @returns {ToNumberArrayUnRecursiveReturn<NormalizeInput<T>, RemoveInvalidValue>} A new array of string representations, with invalid values optionally removed.
  * @example
  * ```ts
@@ -237,12 +102,15 @@ type HasAllowed<T>=[Extract<T,AllowedToString>] extends [never]?false:true;
  * @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 return type of {@link toStringArrayUnRecursive|`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 `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.
@@ -252,7 +120,9 @@ type HasDisallowedNonNullish<T>=[Exclude<T,AllowedToString|Nullish>] extends [ne
  * @template R Flag indicating whether invalid values should be removed (`true`) or kept (`false`).
  */
 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 for {@link toStringArrayUnRecursive|`toStringArrayUnRecursive`}.***
+ * -------------------------------------------------------
  *
  * @template T Flag indicating whether invalid values should be removed.
  */
@@ -276,11 +146,11 @@ removeInvalidValue?:T;};
  *      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`.
+ * @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 array to convert, returns `undefined` if not an array.
+ * @param {ToStringArrayUnRecursiveOptions<RemoveInvalidValue>} [options] - Options to control transformation behavior, defaults to `{ removeInvalidValue: true }`.
+ * @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
@@ -300,7 +170,7 @@ removeInvalidValue?:T;};
  * // Convert boolean and bigint
  * toStringArrayUnRecursive([true, false, 10n]);
  * // ➔ ['true', 'false', '10']
- * // Not an array → returns undefined
+ * // Not an array ➔ returns undefined
  * toStringArrayUnRecursive(null);
  * // ➔ undefined
  * toStringArrayUnRecursive(undefined);
@@ -311,7 +181,146 @@ removeInvalidValue?:T;};
  * // ➔ 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;
+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;type ResUnFTN<Force extends false|"stringOrNumber"|"primitives"|"all"=false>=Force extends"all"?Array<unknown[]|Record<string,unknown>|string>:Force extends"stringOrNumber"?Array<string|boolean|bigint|symbol|null|undefined|Record<string,unknown>|AnyFunction|unknown[]|Date|RegExp|Map<unknown,unknown>|Set<unknown>|Promise<unknown>>:Force extends"primitives"?Array<string|symbol|Record<string,unknown>|AnyFunction|unknown[]|Date|RegExp|Map<unknown,unknown>|Set<unknown>|Promise<unknown>>:Force extends false?Array<string|number|bigint|boolean|symbol|RegExp|Record<string,unknown>|AnyFunction|Date|Map<unknown,unknown>|Set<unknown>|Promise<unknown>|unknown[]|null|undefined>:unknown[];type ResFTN<Force extends false|"stringOrNumber"|"primitives"|"all"=false>=Force extends"all"?Array<string|Record<string,unknown>>:Force extends"stringOrNumber"?Array<string|boolean|bigint|symbol|null|undefined|Record<string,unknown>|AnyFunction|Date|RegExp|Promise<unknown>>:Force extends"primitives"?Array<string|symbol|RegExp|Record<string,unknown>|AnyFunction|Date|Promise<unknown>>:Force extends false?Array<string|number|bigint|boolean|symbol|RegExp|Record<string,unknown>|AnyFunction|Date|Promise<unknown>|null|undefined>:unknown[];type DedupeResult<Force extends ForceToStringOptions=false,FTN extends boolean=false>=FTN extends false?ResUnFTN<Force>:ResFTN<Force>;type ForceToStringOptions=false|"stringOrNumber"|"primitives"|"all";type DedupeArrayOptions<F extends ForceToStringOptions,Fl extends boolean>={
+/** Enables string conversion for comparison, default is `false`.
+ *
+ * @default false
+ * @type {ForceToStringOptions}
+ */
+forceToString?:F;
+/** If true, deeply flattens `Arrays`, `Maps`, and `Sets` before deduplication, default is `false`.
+ *
+ * @default false
+ */
+flatten?:Fl;};
+/** ----------------------------------------------------------
+ * * ***Utility: `dedupeArray`.***
+ * ---------------------------------------------
+ * **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 {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"]
+ * dedupeArray([true, "true", false, undefined], {
+ *    forceToString: "primitives"
+ * }); // ➔ ["true", "false", "undefined"]
+ * dedupeArray([1, "1", { a: 1 }], {
+ *    forceToString: "all"
+ * }); // ➔ ["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"]
+ * 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"]
+ * dedupeArray([/abc/, /abc/], {
+ *    forceToString: "all"
+ * }); // ➔ ["/abc/"]
+ * dedupeArray([new Map(), new Set(), new Error("err")], {
+ *    forceToString: "all"
+ * }); // ➔ ["[object Map]", "[object Set]", "Error: err"]
+ * dedupeArray([Promise.resolve(1), Promise.resolve(1)], {
+ *    forceToString: "all"
+ * }); // ➔ ["[object Promise]"]
+ * dedupeArray([{ a: 1 }, { a: 1 }, { a: 2 }], {
+ *    forceToString: "primitives"
+ * }); // ➔ [{ a: "1" }, { a: "2" }]
+ * dedupeArray([{ a: { b: 1 } }, { a: { b: 1 } }], {
+ *    forceToString: "all"
+ * }); // ➔ [{ a: { b: "1" } }]
+ * dedupeArray("not an array");
+ * // ➔ Throws TypeError
+ * dedupeArray([1, 2, 3], {
+ *    forceToString: "invalid"
+ * }); // ➔ Throws TypeError
+ * ```
+ */
+declare const dedupeArray:<ForceToString extends ForceToStringOptions=false,Flattening extends boolean=false>(inputArray:unknown[],options?:DedupeArrayOptions<ForceToString,Flattening>)=>DedupeResult<ForceToString,Flattening>;type ExcludeNil<T>=Exclude<T,null|undefined>;
+/** ----------------------------------------------------------
+ *  * ***Element extractor***
+ * ----------------------------------------------------------
+ */
+type ElementOf<A extends readonly unknown[]>=A extends readonly(infer U)[]?U:never;
+/** ----------------------------------------------------------
+ * * ***Compute `FilterNilArray`***
+ * ----------------------------------------------------------
+ *
+ * for a tuple/array A by using the element type (without null|undefined).
+ *
+ */
+type FilterNilArrayFromTuple<A extends readonly unknown[]>=FilterNilArray<ExcludeNil<ElementOf<A>>>;
+/** ----------------------------------------------------------
+ * ***Preserve `mutability`: if A is mutable (extends unknown[]), keep B; otherwise make B readonly***. */
+type PreserveMutability<A extends readonly unknown[],B>=A extends unknown[]?B:Readonly<B>;type IsDeepEmptyArray<T>=T extends readonly []?true:T extends readonly(infer U)[]?IsDeepEmptyArray<U>:false;type FilterNilRecursive<T>=T extends readonly(infer U)[]?T extends(infer U)[]?FilterNilRecursive<ExcludeEmptyArray<U>>[]:readonly FilterNilRecursive<ExcludeEmptyArray<U>>[]:Exclude<T,null|undefined>;type ExcludeEmptyArray<T>=T extends []?never:T;type NormalizerArrays<T>=NormalizeEmptyArraysRecursive<RemoveEmptyArrayElements<FilterNilRecursive<T[]>>>;type FilterNilArray<T>=IsDeepEmptyArray<NormalizerArrays<T>>extends true?[]:FixNeverArrayRecursive<NormalizerArrays<T>>;
+/** ----------------------------------------------------------
+ * * ***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):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[];
 /** ---------------------------------
  * * ***Utility: `toBooleanContent`.***
  * ---------------------------------------------
@@ -324,7 +333,7 @@ declare function toStringArrayUnRecursive(array?:undefined|null,options?:ToStrin
  *    - 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`.
+ * @returns {boolean} Return `true` if the value is considered non-empty, otherwise `false`.
  * @example
  * toBooleanContent(null);      // ➔ false
  * toBooleanContent(undefined); // ➔ false
@@ -357,7 +366,7 @@ declare const toBooleanContent:(value:unknown)=>boolean;
  *    - 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`.
+ * @returns {boolean} Return `true` if the value or anything nested inside is non-empty, otherwise `false`.
  * @example
  * toBooleanContentDeep(null);          // ➔ false
  * toBooleanContentDeep("");            // ➔ false
@@ -411,7 +420,7 @@ includeIndeterminate?:boolean;};
  * @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`.
+ * @returns {boolean} Return `true` if the value matches a truthy representation, otherwise `false`.
  * @throws {TypeError} Throws if any option provided is not a boolean.
  * @example
  * toBooleanExplicit(1);
@@ -458,7 +467,7 @@ declare const toBooleanExplicit:(value:unknown,options?:ToBooleanExplicitOptions
  *    - 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`.
+ * @returns {boolean} Return `true` if the value is truthy, otherwise `false`.
  * @example
  * toBooleanLoose(null);     // ➔ false
  * toBooleanLoose("");       // ➔ false
@@ -507,14 +516,13 @@ declare const toBooleanLoose:(value:unknown)=>boolean;
  *      - 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.
+ * @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.
  * @example
  * ```ts
  * parseCurrencyString("Rp 15.300.000,21");
@@ -570,81 +578,111 @@ declare const parseCurrencyString:(input:string|null|undefined)=>number;
  * 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;
+declare const convertType:(value:unknown)=>unknown;
 /** --------------------------------------------------
  * * ***Options for cleaning and transforming parsed JSON data.***
  * --------------------------------------------------
+ *
+ * @private Type Options Validation for Function: {@link cleanParsedData | `cleanParsedData`}, {@link parseCustomDate | `parseCustomDate`} and {@link safeJsonParse | `safeJsonParse`}.
  */
 type ParseParsedDataOptions={
-/** Convert numeric strings to numbers (e.g., `"42"` ➔ `42`), defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Convert numeric strings to numbers (e.g., `"42"` ➔ `42`), defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 convertNumbers?:boolean;
-/** Convert numeric strings "NaN" to NaN (e.g., `"NaN"` ➔ `NaN`), defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Convert numeric strings `"NaN"` to `NaN` (e.g., `"NaN"` ➔ `NaN`), defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 convertNaN?:boolean;
-/** Convert `"true"` / `"false"` strings to boolean values, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Convert `"true"` / `"false"` strings to boolean values, defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 convertBooleans?:boolean;
-/** Convert valid date strings into `Date` objects, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Convert valid date strings into `Date` objects, defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 convertDates?:boolean;
-/** Custom date formats to be parsed (e.g., `["DD/MM/YYYY", "MM/DD/YYYY"]`), defaultValue: `[]`.
+/** --------------------------------------------------
+ * * ***Custom date formats to be parsed (e.g., `["DD/MM/YYYY", "MM/DD/YYYY"]`), defaultValue: `[]`.***
+ * --------------------------------------------------
  *
  * @default []
  */
 customDateFormats?:string[];
-/** Remove `null` values from objects and arrays, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Remove `null` values from objects and arrays, defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 removeNulls?:boolean;
-/** Remove `undefined` values from objects and arrays, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Remove `undefined` values from objects and arrays, defaultValue: `false`.***
+ * --------------------------------------------------
  *
- * - `false` (default): replaces `undefined` with `null`
- * - `true`: removes keys with `undefined` values
+ * - ***Behavior:***
+ *    - `false` (**default**): replaces `undefined` with `null`.
+ *    - `true`: removes keys with `undefined` values.
  *
  * @default false
  */
 removeUndefined?:boolean;
-/** Remove empty objects `{}` from the final output, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Remove empty objects `{}` from the final output, defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 removeEmptyObjects?:boolean;
-/** Remove empty arrays `[]` from the final output, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Remove empty arrays `[]` from the final output, defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 removeEmptyArrays?:boolean;
-/** Strict mode: Removes values that do not match selected conversions, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Removes values that do not match selected conversions, defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 strictMode?:boolean;
-/** Enable error logging if JSON parsing fails, defaultValue: `false`.
+/** --------------------------------------------------
+ * * ***Enable error logging if JSON parsing fails, defaultValue: `false`.***
+ * --------------------------------------------------
  *
  * @default false
  */
 loggingOnFail?:boolean;
-/** Custom error handler function.
- *
- * - If provided, it will be called with the error.
+/** --------------------------------------------------
+ * * ***Custom error handler function.***
+ * --------------------------------------------------
  *
- * - If not provided, defaults to `undefined` in type, but internally a no-op function is used.
+ * - ***Behavior:***
+ *    - If provided, it will be called with the error.
+ *    - If not provided, defaults to `undefined` in type, but internally a no-op function is used.
  *
+ * @param error - Error instance thrown during fail on execution.
  * @default undefined
  */
 onError?:(error:Error)=>void;
-/**
- * Whether to check symbol properties when checking empty objects.
+/** --------------------------------------------------
+ * * ***Whether to check symbol properties when checking empty objects.***
+ * --------------------------------------------------
+ *
  * @default false
  */
 checkSymbols?:boolean;};
@@ -654,7 +692,7 @@ checkSymbols?:boolean;};
  * **Cleans parsed JSON data based on provided options.**
  * @template T - Expected output type.
  * @param {*} data - The parsed JSON data.
- * @param {ParseParsedDataOptions} [options] - Cleaning options.
+ * @param {ParseParsedDataOptions} [options] - The 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._
@@ -703,7 +741,11 @@ declare const cleanParsedData:<T=unknown>(data:T,options?:ParseParsedDataOptions
  * parseCustomDate(123, "DD/MM/YYYY");
  * // ➔ TypeError: Parameter `dateString` and `format` must be of type `string`...
  */
-declare const parseCustomDate:(dateString:string,format:string)=>Date|null;
+declare const parseCustomDate:(dateString:string,format:string)=>Date|null;type NonJsonParsableType=Omit<Exclude<unknown,string|null|undefined>,string>;type Contains<T,U>=[Extract<T,U>] extends [never]?false:true;
+/** @private ***The value type for the overload function {@link safeJsonParse | `safeJsonParse`}.*** */
+type UnknownValue={undefined:true;};
+/** @private ***The narrows type result for {@link safeJsonParse | `safeJsonParse`}.*** */
+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;
 /** --------------------------------------------------
  * * ***Utility: `safeJsonParse`.***
  * ---------------------------------------------
@@ -877,11 +919,9 @@ declare function safeJsonParse<TData extends Record<string,any>=Record<string,un
  *    - 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.
+ *    **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.
+ * @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
@@ -899,13 +939,16 @@ declare function safeJsonParse<TData extends Record<string,any>=Record<string,un
  * 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.
- * Can target deeply nested properties (e.g., `"left.data.sensitive"`).
+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 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;
+/** @private ***Types options for {@link removeObjectPaths | `removeObjectPaths`}.*** */
+type ConfigRemoveObjectPaths<T>={
+/** ------------------------------------------------------------------------
+ * * ***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 | `DotPath`}** path within it.**
  *
- * This is resolved relative to the root object `T`, and supports
- * any valid **{@link DotPath | `DotPath`}** path within it.
- * @type {DotPath<T>}
  * @example
  * const obj = {
  *   left: { data: { sensitive: "secret", id: 1 } },
@@ -924,11 +967,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.
- *
- * Useful if the target property might appear multiple times across different
- * branches or array elements.
+/** ------------------------------------------------------------------------
+ * * ***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 = {
@@ -950,7 +994,9 @@ 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;}>;
+deep?:boolean;};
+/** @private ***Narrows types result for {@link removeObjectPaths | `removeObjectPaths`}.*** */
+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;}>;
 /** ------------------------------------------------------------------------
  * * ***Utility: `removeObjectPaths`.***
  * ------------------------------------------------------------------------
@@ -971,13 +1017,13 @@ deep?:boolean;};type KeysToRemove<T,K extends readonly ConfigRemoveObjectPaths<T
  *    - 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 {Record<string, unknown>} object - The object to remove keys from. Must be an object or will return `{}`.
+ * @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:
+ *  ***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|undefined} [deepClone=true]
- *   Whether to deep clone the original object before modifying.
+ *  ***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>}
@@ -1026,11 +1072,13 @@ deep?:boolean;};type KeysToRemove<T,K extends readonly ConfigRemoveObjectPaths<T
  */
 declare function removeObjectPaths<T extends Record<string,unknown>,K extends ConfigRemoveObjectPaths<T>[]>(object:T,keysToDelete:K,deepClone?:boolean):ResultRemoveObjectPaths<T,K>;
 /** -------------------------------------------------
- * * ***Options for **{@link safeStableStringify | `safeStableStringify`}**.***
+ * * ***Type Options for **{@link safeStableStringify | `safeStableStringify`}**.***
  * -------------------------------------------------
  */
 type SafeStableStringifyOptions={
-/** Whether to sort **object keys** alphabetically (recursively).
+/** -------------------------------------------------
+ * * ***Whether to sort **object keys** alphabetically (recursively).***
+ * -------------------------------------------------
  *
  * - `true` (default): object keys are sorted to ensure stable output.
  * - `false`: preserves original insertion order of keys.
@@ -1038,7 +1086,9 @@ type SafeStableStringifyOptions={
  * @default true
  */
 sortKeys?:boolean;
-/** Whether to sort **primitive values inside arrays**.
+/** -------------------------------------------------
+ * * ***Whether to sort **primitive values inside arrays**.***
+ * -------------------------------------------------
  *
  * - `true`: primitive values in arrays are sorted to ensure stable output.
  * - `false` (default): arrays retain their original order; objects and nested arrays are not reordered.
@@ -1046,14 +1096,46 @@ sortKeys?:boolean;
  * @default false
  */
 sortArray?:boolean;
-/** Whether to pretty-print JSON output with 2-space indentation.
+/** -------------------------------------------------
+ * * ***Whether to pretty-print JSON output with 2-space indentation.***
+ * -------------------------------------------------
  *
  * - `true`: output is formatted with indentation and newlines.
  * - `false` (default): produces compact single-line JSON.
  *
  * @default false
  */
-pretty?:boolean;};
+pretty?:boolean;
+/** -------------------------------------------------
+ * * ***Preserve `undefined` values instead of converting them to `null`.***
+ * -------------------------------------------------
+ * **Controls how the internal `deepProcess` step rewrites values
+ * **before** the final `JSON.stringify` call.**
+ * - **Default (`false`):**
+ *     * Every `undefined` value (object properties **and** array elements)
+ *       is replaced with `null` **before** serialization, because this happens
+ *       first, the key is **not removed** by `JSON.stringify`.
+ * - **`true`** – Leaves `undefined` untouched so the final
+ *   `JSON.stringify` call behaves natively:
+ *     * Object properties with `undefined` are **removed**.
+ *     * Array elements that are `undefined` become `null`.
+ * @default false
+ * @example
+ * // ✅ keepUndefined = true: behaves like native JSON.stringify
+ * safeStableStringify({ a: undefined }, { keepUndefined: true });
+ * // ➔ '{}' // key removed
+ *
+ * // ✅ Default (false): convert undefined to null, key kept
+ * safeStableStringify({ a: undefined });
+ * // ➔ '{"a":null}' // key present, value null
+ *
+ * // Arrays
+ * safeStableStringify([undefined]);
+ * // ➔ '[null]' // same, but via pre-replacement
+ * safeStableStringify([undefined], { keepUndefined: true });
+ * // ➔ '[null]' // element becomes null
+ */
+keepUndefined?:boolean;};
 /** --------------------------------------------
  * * ***Utility: `safeStableStringify`.***
  * ---------------------------------------------
@@ -1068,8 +1150,8 @@ pretty?:boolean;};
  *        - 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)
+ *            - `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"`.
@@ -1077,21 +1159,32 @@ pretty?:boolean;};
  *        - 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)
+ *            - `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.
+ *        - Controls how `undefined` is handled **before** the final `JSON.stringify` call, by `keepUndefined`
+ *          options, default: `false`.
+ *            - **false**: All `undefined` values (object properties and array elements) are replaced
+ *            with `null`, so object keys remain.
+ *            - **true**: Leaves `undefined` values as-is, and handling by native `JSON.stringify` then:
+ *               1. Removes object properties that are `undefined`.
+ *               2. Converts `undefined` array elements to `null`.
+ *            - Use `true` when you need native removal of keys or to preserve sparse arrays
+ *              exactly as `JSON.stringify` would.
  * @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
+ *  ***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`:
+ *   ***Configuration options for `safeStableStringify`:***
+ *    - `keepUndefined` (boolean) – Control how `undefined` is handled **before** the final `JSON.stringify`
+ *       call, 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`.
@@ -1117,6 +1210,14 @@ pretty?:boolean;};
  * });
  * // ➔ '[1,2,3]'
  *
+ * // keepUndefined = true (native removal of keys)
+ * safeStableStringify({ a: undefined }, { keepUndefined: true });
+ * // ➔ '{}'   // key `a` is removed, like native JSON.stringify
+ *
+ * // Default keepUndefined = false (convert to null, keep key)
+ * safeStableStringify({ a: undefined });
+ * // ➔ '{"a":null}'
+ *
  * // Nested object + sortArray=true
  * safeStableStringify({ z: [3, 1, 2], x: { d: 4, c: 3 } }, {
  *    sortKeys:true,
@@ -1158,7 +1259,7 @@ pretty?:boolean;};
  * safeStableStringify({ f: () => {}, s: Symbol("wow") });
  * // ➔ '{}'
  *
- * // undefined, NaN, Infinity convert to null
+ * // undefined, NaN, Infinity convert to null (keepUndefined = false or keepUndefined = true)
  * safeStableStringify([undefined, NaN, Infinity, -Infinity]);
  * // ➔ '[null,null,null,null]'
  *
@@ -1175,64 +1276,11 @@ pretty?:boolean;};
  * ```
  */
 declare const safeStableStringify:(value:unknown,options?:SafeStableStringifyOptions)=>string;
-/** ----------------------------------------------------------
- * * ***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`: 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"
- * toStringDeepForce(true, "primitives");
- * // ➔ "true"
- * toStringDeepForce(null, "primitives");
- * // ➔ "null"
- * toStringDeepForce(Symbol("x"), "all");
- * // ➔ "Symbol(x)"
- * toStringDeepForce({ a: 1, b: [2, NaN] }, "primitives");
- * // ➔ { a: "1", b: ["2", "NaN"] }
- * toStringDeepForce(new Date("2025-01-01"), "all");
- * // ➔ "2025-01-01T00:00:00.000Z"
- * toStringDeepForce(() => 1, "all");
- * // ➔ "() => 1"
- * toStringDeepForce(/abc/i, "all");
- * // ➔ "/abc/i"
- * toStringDeepForce(new Map([["a", 1], ["b", 2]]), "all");
- * // ➔ [["a", "1"], ["b", "2"]]
- * toStringDeepForce(new Set([1, 2, 3]), "all");
- * // ➔ ["1", "2", "3"]
- * toStringDeepForce(new Error("Oops"), "all");
- * // ➔ "Error: Oops"
- * toStringDeepForce(Promise.resolve(1), "all");
- * // ➔ "[object Promise]"
- * toStringDeepForce({ func: () => 123 }, "all");
- * // ➔ { func: "() => 123" }
- * toStringDeepForce([1, "a", { b: 2 }], false);
- * // ➔ [1, "a", { b: 2 }]
- */
-declare function toStringDeepForce(value:unknown,forceToString:false|"stringOrNumber"|"primitives"|"all"):unknown;
 /** ----------------------------------------------------------
  * * Normalize leaked `never[]` into literal empty array `[]`.
  * ----------------------------------------------------------
  */
-type FixNeverArray$1<T>=[T] extends [never[]]?[]:T;
+type FixNeverArray$1<T,RemoveEmptyArrays extends boolean>=[T] extends [never[]]?RemoveEmptyArrays extends true?OrArr<[Extends<T,undefined>,Extends<undefined,T>]>extends true?undefined:never:[]:T;
 /** ----------------------------------------------------------
  * * Simplify object type to remove unnecessary TypeScript wrappers.
  * ----------------------------------------------------------
@@ -1249,24 +1297,22 @@ type Simplify$1<T>=T extends object?{[K in keyof T]:T[K];}:T;
  * @template RemoveEmptyArrays - Whether to remove empty arrays
  * @template IsRoot - Internal flag for root level
  */
-type ConvertedDeepNumberInternal<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=[ T] extends [null|undefined]?IsRoot extends true?undefined:never:T extends number|`${number}`|string?number|undefined:T extends readonly(infer E)[]?FixNeverArray$1<T extends readonly [any,...any[]]?_MapTuple$1<T,RemoveEmptyObjects,RemoveEmptyArrays>:ConvertedDeepNumberInternal<E,RemoveEmptyObjects,RemoveEmptyArrays,false>[]>:T extends Set<infer V>?FixNeverArray$1<ConvertedDeepNumberInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,false>[]>:T extends Map<infer K,infer V>?FixNeverArray$1<[ ConvertedDeepNumberInternal<K,RemoveEmptyObjects,RemoveEmptyArrays,false>,ConvertedDeepNumberInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,false>][]>:T extends Buffer?RemoveEmptyArrays extends true?IsRoot extends true?(number|undefined)[]:never:(number|undefined)[]:T extends TypedArray?FixNeverArray$1<ConvertedDeepNumberInternal<number,RemoveEmptyObjects,RemoveEmptyArrays,false>[]>:T extends Date?_ConvertedObjectInternal$1<number,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:T extends RegExp|WebApiObjects|IntlObjects|{[Symbol.toStringTag]:"Proxy";}|typeof Reflect?RemoveEmptyObjects extends true?IsRoot extends true?{}:never:{}:T extends Record<string|number|symbol,unknown>?_ConvertedObjectInternal$1<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:never;
-/** ----------------------------------------------------------
- * * Recursively map tuples while preserving `never` removals.
- * ----------------------------------------------------------
- */
-type _MapTuple$1<Arr extends readonly unknown[],RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean>=Arr extends readonly [infer H,...infer R]?Exclude<ConvertedDeepNumberInternal<H,RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer H2?[H2] extends [never]?_MapTuple$1<R,RemoveEmptyObjects,RemoveEmptyArrays>:[H2,..._MapTuple$1<R,RemoveEmptyObjects,RemoveEmptyArrays>]:never:[];
+type ConvertedDeepNumberInternal<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=[T] extends [null|undefined]?IsRoot extends true?undefined:never:T extends Date|boolean|Boolean?number:T extends string|String|Number|number|`${number}`?number|undefined:AndArr<[Extends<RemoveEmptyArrays,true>,Extends<T,undefined[]>]>extends true?never:T extends readonly(infer E)[]?OrArr<[ Extends<RemoveEmptyArrays,true>,AndArr<[Extends<RemoveEmptyArrays,true>,Extends<IsRoot,true>]>]>extends true?FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<E,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>,RemoveEmptyArrays>[]|undefined:FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<E,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends Set<infer V>?AndArr<[Extends<RemoveEmptyArrays,true>]>extends true?FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends Map<infer K,infer V>?FixNeverArray$1<[ Exclude<ConvertedDeepNumberInternal<K,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>,Exclude<ConvertedDeepNumberInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>][],RemoveEmptyArrays>:T extends Buffer?FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<string,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends TypedArray?FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<string,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends Record<PropertyKey,unknown>?_ConvertedObjectInternal$1<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:never;
 /** ----------------------------------------------------------
  * * Internal object conversion utility.
  * * Removes empty objects/arrays based on flags.
  * ----------------------------------------------------------
  */
-type _ConvertedObjectInternal$1<O extends Record<string|number|symbol,unknown>|number,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>={[K in keyof O as Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>?never:RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?O[K] extends TypedArray|Set<any>|Map<any,any>?K:never:K:K:K:never]:Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}&{[K in keyof O as Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>?RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?O[K] extends TypedArray|Set<any>|Map<any,any>?K:never:K:K:K:never:never]?:Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}extends infer M?RemoveEmptyObjects extends true?keyof M extends never?IsRoot extends true?{}:never:Simplify$1<M>:Simplify$1<M>:never;
+type _ConvertedObjectInternal$1<O extends Record<PropertyKey,unknown>|string|number,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>={[K in keyof O as Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>?never:RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?never:K:K:K:never]:Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}&{[K in keyof O as Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>?RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?never:K:K:K:never:never]?:Exclude<ConvertedDeepNumberInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}extends infer M?RemoveEmptyObjects extends true?keyof M extends never?IsRoot extends true?{}:never:_ProcessedObject$1<M,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:Simplify$1<M>:never;type AllPropsAreNumber$1<O>={[K in keyof O]:O[K] extends number|Number?true:O[K] extends Record<string,unknown>?AllPropsAreNumber$1<O[K]>:false;}[keyof O] extends false?false:true;type _ProcessedObject$1<M,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=M extends unknown[]?ConvertedDeepNumberInternal<M,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:Prettify<Simplify$1<{[K in keyof M]:M[K] extends Record<string,unknown>?AllPropsAreNumber$1<M[K]>extends true?{[ChildKey in keyof M[K]]:M[K][ChildKey] extends number|Number?M[K][ChildKey]|undefined:_ProcessedObject$1<M[K][ChildKey],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}|undefined:AndArr<[ Extends<RemoveEmptyArrays,true>,Extends<RemoveEmptyObjects,true>]>extends true?{[ChildKey in keyof M[K]]:_ProcessChild$1<M[K][ChildKey],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}|undefined:{[ChildKey in keyof M[K]]:_ProcessChild$1<M[K][ChildKey],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}:M[K] extends unknown[]?ConvertedDeepNumberInternal<M[K],RemoveEmptyObjects,RemoveEmptyArrays,false>:_ProcessedObject$1<M[K],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}>,{recursive:true;}>;type _ProcessChild$1<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=T extends number|number[]?ConvertedDeepNumberInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:T extends Record<string,unknown>?_ProcessedObject$1<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:_ProcessedObject$1<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;
 /** ----------------------------------------------------------
  * * Public type: Deeply converts numbers/strings to `number | undefined`,
  * * applies empty object/array removal, preserves special types.
  * ----------------------------------------------------------
+ * @private ***Narrows types result for {@link toNumberDeep | `toNumberDeep`}.***
  */
-type ConvertedDeepNumber<T,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>=[unknown] extends [T]?unknown:FixNeverArray$1<ConvertedDeepNumberInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,true>>;type ToNumberDeepOptions<RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>={
+type ConvertedDeepNumber<T,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>=[unknown] extends [T]?unknown:FixNeverArray$1<ConvertedDeepNumberInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,true>,RemoveEmptyArrays>;
+/** @private ***Types options for {@link toNumberDeep | `toNumberDeep`}.*** */
+type ToNumberDeepOptions<RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>={
 /** Whether to remove empty objects (`{}`) from the result.
  *
  * - `true` ➔ remove empty objects recursively.
@@ -1288,13 +1334,45 @@ 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`).
+ *    - Converts numeric strings, number to numbers:
+ *      - `3.5` ➔ `3.5`.
+ *      - `"3.5"` ➔ `3.5`.
+ *    - Converts boolean to number:
+ *      - `true` ➔ `1`.
+ *      - `false` ➔ `0`.
+ *    - Converts Date to getTime (timestamp) `Date ➔ number`, if invalid Date value will return `0`:
+ *      - `new Date("invalid")` ➔ `0`.
+ *      - `new Date("11-09-2025 22:04:11")` ➔ `1762700651000`.
+ *    - Converts `Buffer`, `TypedArray`, `Set`, `Map`, and `arrays` recursively to `arrays of numbers`.
+ *    - Converts boxed primitives box into their primitive equivalents then convert to number:
+ *      - For `new String` we convert everything to number (behavior JS of new String):
+ *        - `new String(123)` ➔ `.valueOf()` ➔ `"123"` ➔ `Number("123")` ➔ `123`.
+ *        - `new String("123")` ➔ `.valueOf()` ➔ `"123"` ➔ `Number("123")` ➔ `123`.
+ *        - `new String(true)` ➔ `.valueOf()` ➔ `"true"` ➔ `Number(true)` ➔ `1`.
+ *        - `new String(false)` ➔ `.valueOf()` ➔ `"false"` ➔ `Number(false)` ➔ `0`.
+ *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:
+ *          - `new String("hi")` ➔ `.valueOf()` ➔ `"hi"` ➔ `Number("hi")` ➔ `NaN` ***(remove)***.
+ *          - `new String(()=>{})` ➔ `.valueOf()` ➔ `"()=>{}"` ➔ `Number("()=>{}")` ➔ `NaN` ***(remove)***.
+ *      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to number:
+ *        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `Number(true)` ➔ `1`.
+ *        - `new Boolean(false)` ➔ `.valueOf()` ➔ `false` ➔ `Number(false)` ➔ `0`.
+ *        - Special behavior JS of new Boolean, return `false` **(convert to number: `0`)**
+ *          for `false`, (`0` / `-0`), `""` (empty-string),
+ *          `null`, `undefined`, `NaN`, otherwise `true` **(convert to number: `1`)**.
+ *      - For `new Number`:
+ *        - `new Number(42)` ➔ `.valueOf()` ➔ `42`.
+ *        - `new Number("42")` ➔ `.valueOf()` ➔ `42`.
+ *        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number).
+ *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:
+ *          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+ *          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+ *          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.
+ *          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.
+ *    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.
+ *    - Removes `empty-string`, `non-numeric strings`.
+ *    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.
+ *    - Removes `unsupported` types like `functions` , `RegExp`, `symbols`, and `BigInt`.
+ *    - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.
  * @template T - The input type.
  * @template RemoveEmptyObjects - Whether to remove empty objects.
  * @template RemoveEmptyArrays - Whether to remove empty arrays.
@@ -1335,7 +1413,7 @@ declare function toNumberDeep(input?:null|undefined,options?:ToNumberDeepOptions
 /** ----------------------------------------------------------
  * * Normalize leaked `never[]` into literal empty array `[]`.
  * ---------------------------------------------------------- */
-type FixNeverArray<T,RemoveEmptyArrays extends boolean>=[T] extends [never[]]?RemoveEmptyArrays extends true?T extends undefined?undefined:never:[]:T;
+type FixNeverArray<T,RemoveEmptyArrays extends boolean>=[T] extends [never[]]?RemoveEmptyArrays extends true?OrArr<[Extends<T,undefined>,Extends<undefined,T>]>extends true?undefined:never:[]:T;
 /** ----------------------------------------------------------
  * * Simplify object type to remove unnecessary TypeScript wrappers.
  * ---------------------------------------------------------- */
@@ -1345,21 +1423,21 @@ type Simplify<T>=T extends object?{[K in keyof T]:T[K];}:T;
  * * recursively handling arrays, tuples, Sets, Maps, TypedArrays,
  * * Buffer, and objects. Special types like Date remain unchanged.
  * ---------------------------------------------------------- */
-type ConvertedDeepStringInternal<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=[T] extends [null|undefined]?IsRoot extends true?undefined:never:T extends number|string|Date|RegExp|WebApiObjects|IntlObjects|{[Symbol.toStringTag]:"Proxy";}|typeof Reflect?string:T extends readonly(infer E)[]?FixNeverArray<T extends readonly [any,...any[]]?_MapTuple<T,RemoveEmptyObjects,RemoveEmptyArrays>:ConvertedDeepStringInternal<E,RemoveEmptyObjects,RemoveEmptyArrays,false>[],RemoveEmptyArrays>:T extends Set<infer V>?FixNeverArray<ConvertedDeepStringInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,false>[],RemoveEmptyArrays>:T extends Map<infer K,infer V>?FixNeverArray<[ ConvertedDeepStringInternal<K,RemoveEmptyObjects,RemoveEmptyArrays,false>,ConvertedDeepStringInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,false>][],RemoveEmptyArrays>:T extends Buffer?FixNeverArray<ConvertedDeepStringInternal<string,RemoveEmptyObjects,RemoveEmptyArrays,false>[],RemoveEmptyArrays>:T extends TypedArray?FixNeverArray<ConvertedDeepStringInternal<string,RemoveEmptyObjects,RemoveEmptyArrays,false>[],RemoveEmptyArrays>:T extends Record<string|number|symbol,unknown>?_ConvertedObjectInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:never;
-/** ----------------------------------------------------------
- * * Remove undefined and keep only items for tuples
- * ---------------------------------------------------------- */
-type _MapTuple<Arr extends readonly unknown[],RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean>=Arr extends readonly [infer H,...infer R]?Exclude<ConvertedDeepStringInternal<H,RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer H2?[H2] extends [never]?_MapTuple<R,RemoveEmptyObjects,RemoveEmptyArrays>:[H2,..._MapTuple<R,RemoveEmptyObjects,RemoveEmptyArrays>]:never:[];
+type ConvertedDeepStringInternal<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=[T] extends [null|undefined]?IsRoot extends true?undefined:never:T extends string|boolean|String|Boolean|Date|RegExp|WebApiObjects|IntlObjects|{[Symbol.toStringTag]:"Proxy";}|typeof Reflect?string:T extends Number|number|`${number}`?string|undefined:AndArr<[Extends<RemoveEmptyArrays,true>,Extends<T,undefined[]>]>extends true?never:T extends readonly(infer E)[]?OrArr<[ Extends<RemoveEmptyArrays,true>,AndArr<[Extends<RemoveEmptyArrays,true>,Extends<IsRoot,true>]>]>extends true?FixNeverArray<Exclude<ConvertedDeepStringInternal<E,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>,RemoveEmptyArrays>[]|undefined:FixNeverArray<Exclude<ConvertedDeepStringInternal<E,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends Set<infer V>?AndArr<[Extends<RemoveEmptyArrays,true>]>extends true?FixNeverArray<Exclude<ConvertedDeepStringInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>,RemoveEmptyArrays>:FixNeverArray<Exclude<ConvertedDeepStringInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends Map<infer K,infer V>?FixNeverArray<[ Exclude<ConvertedDeepStringInternal<K,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>,Exclude<ConvertedDeepStringInternal<V,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>][],RemoveEmptyArrays>:T extends Buffer?FixNeverArray<Exclude<ConvertedDeepStringInternal<string,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends TypedArray?FixNeverArray<Exclude<ConvertedDeepStringInternal<string,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>,undefined>[],RemoveEmptyArrays>:T extends Record<PropertyKey,unknown>?_ConvertedObjectInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:never;
 /** ----------------------------------------------------------
  * * Internal object conversion utility.
  * * Removes empty objects/arrays based on flags.
  * ---------------------------------------------------------- */
-type _ConvertedObjectInternal<O extends Record<string|number|symbol,unknown>|string,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>={[K in keyof O as Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>?never:RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?never:K:K:K:never]:Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}&{[K in keyof O as Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>?RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?never:K:K:K:never:never]?:Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}extends infer M?RemoveEmptyObjects extends true?keyof M extends never?IsRoot extends true?{}:never:Simplify<M>:Simplify<M>:never;
+type _ConvertedObjectInternal<O extends Record<string|number|symbol,unknown>|string,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>={[K in keyof O as Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>?never:RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?never:K:K:K:never]:Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}&{[K in keyof O as Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>extends infer Convert?[Convert] extends [never]?never:undefined extends ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>?RemoveEmptyArrays extends true?Convert extends readonly unknown[]?[Convert] extends [[]]?never:K:K:K:never:never]?:Exclude<ConvertedDeepStringInternal<O[K],RemoveEmptyObjects,RemoveEmptyArrays,false>,undefined>;}extends infer M?RemoveEmptyObjects extends true?keyof M extends never?IsRoot extends true?{}:never:_ProcessedObject<M,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:Simplify<M>:never;type AllPropsAreNumber<O>={[K in keyof O]:O[K] extends number|Number?true:O[K] extends Record<string,unknown>?AllPropsAreNumber<O[K]>:false;}[keyof O] extends false?false:true;type _ProcessedObject<M,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=M extends unknown[]?ConvertedDeepStringInternal<M,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:Prettify<Simplify<{[K in keyof M]:M[K] extends Record<string,unknown>?AllPropsAreNumber<M[K]>extends true?{[ChildKey in keyof M[K]]:M[K][ChildKey] extends number|Number?M[K][ChildKey]|undefined:_ProcessedObject<M[K][ChildKey],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}|undefined:AndArr<[ Extends<RemoveEmptyArrays,true>,Extends<RemoveEmptyObjects,true>]>extends true?{[ChildKey in keyof M[K]]:_ProcessChild<M[K][ChildKey],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}|undefined:{[ChildKey in keyof M[K]]:_ProcessChild<M[K][ChildKey],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}:M[K] extends unknown[]?ConvertedDeepStringInternal<M[K],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:_ProcessedObject<M[K],RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;}>,{recursive:true;}>;type _ProcessChild<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean,IsRoot extends boolean>=T extends number|Number[]?ConvertedDeepStringInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:T extends Record<string,unknown>?_ProcessedObject<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>:_ProcessedObject<T,RemoveEmptyObjects,RemoveEmptyArrays,IsRoot>;
 /** ----------------------------------------------------------
  * * Public type: Deeply converts numbers/strings to `string`,
  * * applies empty object/array removal, preserves special types.
- * ---------------------------------------------------------- */
-type ConvertedDeepString<T,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>=[unknown] extends [T]?unknown:FixNeverArray<Simplify<ConvertedDeepStringInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,true>>,RemoveEmptyArrays>;type ToStringDeepOptions<RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>={
+ * ----------------------------------------------------------
+ * @private ***Narrows types result for {@link toStringDeep | `toStringDeep`}.***
+ */
+type ConvertedDeepString<T,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>=[unknown] extends [T]?unknown:FixNeverArray<Simplify<ConvertedDeepStringInternal<T,RemoveEmptyObjects,RemoveEmptyArrays,true>>,RemoveEmptyArrays>;
+/** @private ***Types options for {@link toStringDeep | `toStringDeep`}.*** */
+type ToStringDeepOptions<RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>={
 /** Whether to remove empty objects (`{}`) from the result.
  *
  * - `true` ➔ remove empty objects recursively.
@@ -1381,15 +1459,39 @@ 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 numbers and strings to string:
+ *      - `3.5` ➔ `"3.5"`.
+ *      - `"3.5"` ➔ `"3.5"`.
+ *    - Converts boolean to string:
+ *      - `true` ➔ `"true"`.
+ *      - `false` ➔ `"false"`.
  *    - 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.
+ *    - Converts `Buffer`, `TypedArray`, `Set`, `Map`, and `arrays` recursively to `arrays of strings`.
+ *    - Converts boxed primitives box into their primitive equivalents then convert to string:
+ *      - For `new String` we convert everything to string (behavior JS of new String):
+ *        - `new String("hi")` ➔ `.valueOf()` ➔ `"hi"`.
+ *        - `new String(true)` ➔ `.valueOf()` ➔ `"true"`.
+ *      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:
+ *        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `"true"`.
+ *        - Special behavior JS of new Boolean, return `false` **(convert to string: `"false"`)**
+ *          for `false`, (`0` / `-0`), `""` (empty-string), `null`, `undefined`, `NaN`, otherwise
+ *          `true` **(convert to string: `"true"`)**.
+ *      - For `new Number`:
+ *        - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `"42"`.
+ *        - `new Number("42")` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `"42"`.
+ *        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `"0"`.
+ *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:
+ *          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+ *          - `new Number("abc")` ➔ `.valueOf()` ➔ `NaN`  ***(remove)***.
+ *          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+ *          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.
+ *          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.
+ *    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.
  *    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.
- *    - Removes unsupported types like functions, symbols, and BigInt.
- *    - Recursively processes nested objects, arrays, Sets, and Maps.
+ *    - Removes `unsupported` types like `functions`, `symbols`, and `BigInt`.
  *    - 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 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 {*} input - The data to convert.
@@ -1402,13 +1504,23 @@ removeEmptyArrays?:RemoveEmptyArrays;};
  * toStringDeep([1, "2", 3]);
  * // ➔ ["1", "2", "3"]
  *
+ * // Simple top-level conversion
+ * toStringDeep(123);
+ * // ➔ "123"
+ * toStringDeep("123");
+ * // ➔ "123"
+ * toStringDeep(true);
+ * // ➔ "true"
+ * toStringDeep(false);
+ * // ➔ "false"
+ *
  * // Nested arrays
- * toStringDeep([1, ["2", [3, [null, "4"]]]]);
- * // ➔ ["1", ["2", ["3", ["4"]]]]
+ * toStringDeep([1, ["2", [3, [null, "4", true, false]]]]);
+ * // ➔ ["1", ["2", ["3", ["4", "true", "false"]]]]
  *
  * // Object with nested values
- * toStringDeep({ a: 1, b: "2", c: { d: 3, e: null } });
- * // ➔ { a: "1", b: "2", c: { d: "3" } }
+ * toStringDeep({ a: 1, b: "2", c: { d: 3, e: null, f: true, g: false } });
+ * // ➔ { a: "1", b: "2", c: { d: "3", f: "true", g: "false" } }
  *
  * // Removing empty objects
  * toStringDeep({ a: {}, b: "1" }, { removeEmptyObjects: true });
@@ -1433,4 +1545,86 @@ 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,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>;
+/** ----------------------------------------------------------
+ * * ***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,
+ *       boxed primitives box (new Number, new String, new Boolean), and deeply all object properties, to strings.
+ *    - `false`: Leaves everything unchanged.
+ * - **Special behaviors:**
+ *    - `NaN` ➔ `"NaN"` only in `"primitives"` or `"all"` mode.
+ *    - `Date` ➔ ISO string only in `"all"` mode.
+ *    -  ***Primitives Boxed*** (`new Number`, `new String`, `new Boolean`):
+ *       - For `new String` we convert everything to string (behavior JS of new String):
+ *         - `new String("hi")` ➔ `.valueOf()` ➔ `"hi"`.
+ *         - `new String(true)` ➔ `.valueOf()` ➔ `"true"`.
+ *       - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:
+ *         - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `"true"`.
+ *         - Special behavior JS of new Boolean, return `false` **(convert to string: `"false"`)**
+ *           for `false`, (`0` / `-0`), `""` (empty-string), `null`, `undefined`, `NaN`, otherwise
+ *           `true` **(convert to string: `"true"`)**.
+ *       - For `new Number`:
+ *         - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `"42"`.
+ *         - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `"NaN"`.
+ *         - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `"0"`.
+ *         - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `"NaN"`.
+ *         - `new Number(Infinity)` ➔ `Infinity` ➔ `Infinity` ➔ `Infinity.toString()` ➔ `"Infinity"`.
+ *         - `new Number(-Infinity)` ➔ `-Infinity` ➔ `-Infinity` ➔ `-Infinity.toString()` ➔ `"-Infinity"`.
+ *    - `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"
+ * toStringDeepForce(true, "primitives");
+ * // ➔ "true"
+ * toStringDeepForce(null, "primitives");
+ * // ➔ "null"
+ * toStringDeepForce(Symbol("x"), "all");
+ * // ➔ "Symbol(x)"
+ * toStringDeepForce(new String("hi"), "all");
+ * // ➔ "hi"
+ * toStringDeepForce(new Number(42), "all");
+ * // ➔ "42"
+ * toStringDeepForce(new Boolean(true), "all");
+ * // ➔ "true"
+ * toStringDeepForce({ a: 1, b: [2, NaN] }, "primitives");
+ * // ➔ { a: "1", b: ["2", "NaN"] }
+ * toStringDeepForce(new Date("2025-01-01"), "all");
+ * // ➔ "2025-01-01T00:00:00.000Z"
+ * toStringDeepForce(() => 1, "all");
+ * // ➔ "() => 1"
+ * toStringDeepForce(/abc/i, "all");
+ * // ➔ "/abc/i"
+ * toStringDeepForce(new Map([["a", 1], ["b", 2]]), "all");
+ * // ➔ [["a", "1"], ["b", "2"]]
+ * toStringDeepForce(new Set([1, 2, 3]), "all");
+ * // ➔ ["1", "2", "3"]
+ * toStringDeepForce(new Error("Oops"), "all");
+ * // ➔ "Error: Oops"
+ * toStringDeepForce(Promise.resolve(1), "all");
+ * // ➔ "[object Promise]"
+ * toStringDeepForce({ func: () => 123 }, "all");
+ * // ➔ { func: "() => 123" }
+ * toStringDeepForce([1, "a", { b: 2 }], false);
+ * // ➔ [1, "a", { b: 2 }]
+ */
+declare function toStringDeepForce<T>(value:unknown,forceToString:false|"stringOrNumber"|"primitives"|"all"):T;export{cleanParsedData,convertType,dedupeArray,extractDigits,filterNilArray,parseCurrencyString,parseCustomDate,removeObjectPaths,safeJsonParse,safeStableStringify,toBooleanContent,toBooleanContentDeep,toBooleanExplicit,toBooleanLoose,toNumberArrayUnRecursive,toNumberDeep,toStringArrayUnRecursive,toStringDeep,toStringDeepForce};