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

package/dist/conversions/index.d.ts

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