@rzl-zone/utils-js 3.12.0 → 3.12.1-beta.1

package/dist/index-B6tawc8L.d.cts

@@ -0,0 +1,1716 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-beta.1`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+
+import { AndArr, AnyFunction, Extends, FixNeverArrayRecursive, IfExtends, IfNotExtends, IntlObjects, IsAny, KeepNull, KeepUndef, NormalizeEmptyArraysRecursive, Nullish, NumberRangeUnion, OrArr, Prettify, RemoveEmptyArrayElements, TypedArray, WebApiObjects } from "@rzl-zone/ts-types-plus";
+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`.
+*/
+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`.
+*/
+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`.
+*/
+type HasNonNumberLikeNonNullish<T> = [Exclude<T, string | bigint | number | Nullish>] extends [never] ? false : true;
+/** -------------------------------------------------------
+* * ***Computes the return type of {@link toNumberArrayUnRecursive|`toNumberArrayUnRecursive`}
+*   based on input type `T` and option `R`.***
+* -------------------------------------------------------
+*
+* **Behavior:**
+* - If `R = true` (`removeInvalidValueNumber: true`):
+*    - If `T` is only `null | undefined` ➔ returns `[]`.
+*    - If `T` contains number-like (`string | number | bigint`) ➔ returns `number[]`.
+*    - Otherwise ➔ returns `[]`.
+* - If `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 for {@link toNumberArrayUnRecursive|`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
+  */
+  removeInvalidValueNumber?: T;
+};
+/** -------------------------------------------------------
+* * ***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 ***`toNumberDeep` utility function*** 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 to control transformation behavior, defaults to `{ removeInvalidValueNumber: true }`.
+* @returns {ToNumberArrayUnRecursiveReturn<NormalizeInput<T>, RemoveInvalidValue>} A new array of string representations, with invalid values optionally removed.
+* @example
+* ```ts
+* 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. */
+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.
+*/
+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.
+*/
+type HasDisallowedNonNullish<T> = [Exclude<T, AllowedToString | Nullish>] extends [never] ? false : true;
+/** -------------------------------------------------------
+* * ***Computes the return type of {@link toStringArrayUnRecursive|`toStringArrayUnRecursive`}
+*   based on input type `T` and option `R`.***
+* -------------------------------------------------------
+*
+* **Behavior:**
+*   - If `R = true` (`removeInvalidValue = true`):
+*     - If `T` contains any allowed values ➔ `string[]`.
+*     - If `T` contains only nullish or disallowed types ➔ `[]`.
+*
+*   - If `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 for {@link toStringArrayUnRecursive|`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
+  */
+  removeInvalidValue?: T;
+};
+/** ---------------------------------------------
+* * ***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 ***`toStringDeep` utility function*** 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 array to convert, returns `undefined` if not an array.
+* @param {ToStringArrayUnRecursiveOptions<RemoveInvalidValue>} [options] - Options to control transformation behavior, defaults to `{ removeInvalidValue: true }`.
+* @param {RemoveInvalidValue extends true ? boolean : boolean} [options.removeInvalidValue=true] Whether to remove invalid values (`null`, `undefined`, or unsupported types), default: `true`.
+* @returns {RemoveInvalidValue extends true ? string[] : (string | null | undefined)[]} A new array of string representations, with invalid values optionally removed.
+* @example
+* ```ts
+* // 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;
+type ResUnFTN<Force extends false | "stringOrNumber" | "primitives" | "all" = false> = Force extends "all" ? Array<unknown[] | Record<string, unknown> | string> : Force extends "stringOrNumber" ? Array<string | boolean | bigint | symbol | null | undefined | Record<string, unknown> | AnyFunction | unknown[] | Date | RegExp | Map<unknown, unknown> | Set<unknown> | Promise<unknown>> : Force extends "primitives" ? Array<string | symbol | Record<string, unknown> | AnyFunction | unknown[] | Date | RegExp | Map<unknown, unknown> | Set<unknown> | Promise<unknown>> : Force extends false ? Array<string | number | bigint | boolean | symbol | RegExp | Record<string, unknown> | AnyFunction | Date | Map<unknown, unknown> | Set<unknown> | Promise<unknown> | unknown[] | null | undefined> : unknown[];
+type ResFTN<Force extends false | "stringOrNumber" | "primitives" | "all" = false> = Force extends "all" ? Array<string | Record<string, unknown>> : Force extends "stringOrNumber" ? Array<string | boolean | bigint | symbol | null | undefined | Record<string, unknown> | AnyFunction | Date | RegExp | Promise<unknown>> : Force extends "primitives" ? Array<string | symbol | RegExp | Record<string, unknown> | AnyFunction | Date | Promise<unknown>> : Force extends false ? Array<string | number | bigint | boolean | symbol | RegExp | Record<string, unknown> | AnyFunction | Date | Promise<unknown> | null | undefined> : unknown[];
+type DedupeResult<Force extends ForceToStringOptions = false, FTN extends boolean = false> = FTN extends false ? ResUnFTN<Force> : ResFTN<Force>;
+type ForceToStringOptions = false | "stringOrNumber" | "primitives" | "all";
+type DedupeArrayOptions<F extends ForceToStringOptions, Fl extends boolean> = {
+  /** Enables string conversion for comparison, default is `false`.
+  *
+  * @default false
+  * @type {ForceToStringOptions}
+  */
+  forceToString?: F;
+  /** If true, deeply flattens `Arrays`, `Maps`, and `Sets` before deduplication, default is `false`.
+  *
+  * @default false
+  */
+  flatten?: Fl;
+};
+/** ----------------------------------------------------------
+* * ***Utility: `dedupeArray`.***
+* ---------------------------------------------
+* **Deduplicates values in an array (with optional flattening and deep stringification).**
+* - Supports various modes for converting values to strings before deduplication:
+*    - `"stringOrNumber"`: Converts strings and numbers to strings.
+*    - `"primitives"`: Converts all primitives (string, number, boolean, bigint, null, undefined, NaN) to strings.
+*    - `"all"`: Converts all values (primitives, objects, Maps, Sets, Symbols, RegExp, Dates, Errors, Promises, functions)
+*   to strings, including nested object properties.
+*    - `false` (default): No conversion applied.
+* - Options:
+*    - `forceToString`: Enables string conversion for comparison, default is `false`.
+*    - `flatten`: If true, deeply flattens arrays, Maps, and Sets before deduplication, default is `false`.
+* @template ForceToString - `forceToString` mode.
+* @template Flattening - `flatten` mode.
+* @param {unknown[]} inputArray - The array to deduplicate, can be deeply nested and contain any mix of types.
+* @param {DedupeArrayOptions<ForceToString, Flattening>|undefined} [options] - Options to control string conversion.
+* @returns {DedupeResult<ForceToString, Flattening>} Deduplicated array with optional transformations.
+* @throws **{@link TypeError | `TypeError`}** if the input is not an array, or options is not an object, or if `forceToString` is invalid.
+* @example
+* ```ts
+* dedupeArray(["apple", "banana", "apple"]);
+* // ➔ ["apple", "banana"]
+* dedupeArray([[1, 2], [1, 2]], { flatten: true });
+* // ➔ [1, 2]
+* dedupeArray([new Set([1, 2]), new Set([2, 3])], { flatten: true });
+* // ➔ [1, 2, 3]
+* dedupeArray([1, "1", 2, "2"], {
+*    forceToString: "stringOrNumber"
+* }); // ➔ ["1", "2"]
+* dedupeArray([true, "true", false, undefined], {
+*    forceToString: "primitives"
+* }); // ➔ ["true", "false", "undefined"]
+* dedupeArray([1, "1", { a: 1 }], {
+*    forceToString: "all"
+* }); // ➔ ["1", { a: "1" }]
+* dedupeArray([1, 1, [2, 2, [3, 3]]]);
+* // ➔ [1, [2, [3]]]
+* dedupeArray([null, undefined, null]);
+* // ➔ [null, undefined]
+* dedupeArray([[], [[]], [[[]]], [[]], [[[]]]]);
+* // ➔ [[], [[]], [[[]]]]
+* const fn = () => 1;
+* dedupeArray([fn, fn, () => 1]);
+* // ➔ [fn, () => 1] cause: ref () => 1 and fn is different but ref const `fn` and `fn` is same ref.
+* dedupeArray([Symbol("x"), Symbol("x")]);
+* // ➔ [Symbol("x")] (symbols are same by identity, so dedupe
+* dedupeArray([NaN, NaN, 1, "1"]);
+* // ➔ [NaN, 1, "1"]
+* dedupeArray([NaN, NaN, 1, "1"], {
+*    forceToString: "primitives"
+* }); // ➔ ["NaN", "1"]
+* dedupeArray([new Date("2025-01-01"), new Date("2025-01-01")]);
+* // ➔ [Date("2025-01-01")] (same time, deduped)
+* dedupeArray([new Date("2025-01-01"), new Date("2025-01-01")], {
+*    forceToString: "all"
+* }); // ➔ ["2025-01-01T00:00:00.000Z"]
+* dedupeArray([/abc/, /abc/], {
+*    forceToString: "all"
+* }); // ➔ ["/abc/"]
+* dedupeArray([new Map(), new Set(), new Error("err")], {
+*    forceToString: "all"
+* }); // ➔ ["[object Map]", "[object Set]", "Error: err"]
+* dedupeArray([Promise.resolve(1), Promise.resolve(1)], {
+*    forceToString: "all"
+* }); // ➔ ["[object Promise]"]
+* dedupeArray([{ a: 1 }, { a: 1 }, { a: 2 }], {
+*    forceToString: "primitives"
+* }); // ➔ [{ a: "1" }, { a: "2" }]
+* dedupeArray([{ a: { b: 1 } }, { a: { b: 1 } }], {
+*    forceToString: "all"
+* }); // ➔ [{ a: { b: "1" } }]
+* dedupeArray("not an array");
+* // ➔ Throws TypeError
+* dedupeArray([1, 2, 3], {
+*    forceToString: "invalid"
+* }); // ➔ Throws TypeError
+* ```
+*/
+declare const dedupeArray: <ForceToString extends ForceToStringOptions = false, Flattening extends boolean = false>(inputArray: unknown[], options?: DedupeArrayOptions<ForceToString, Flattening>) => DedupeResult<ForceToString, Flattening>;
+type ExcludeNil<T> = Exclude<T, null | undefined>;
+/** ----------------------------------------------------------
+*  * ***Element extractor***
+* ----------------------------------------------------------
+*/
+type ElementOf<A extends readonly unknown[]> = A extends readonly (infer U)[] ? U : never;
+/** ----------------------------------------------------------
+* * ***Compute `FilterNilArray`***
+* ----------------------------------------------------------
+*
+* for a tuple/array A by using the element type (without null|undefined).
+*/
+type FilterNilArrayFromTuple<A extends readonly unknown[]> = FilterNilArray<ExcludeNil<ElementOf<A>>>;
+/** ----------------------------------------------------------
+* ***Preserve `mutability`: if A is mutable (extends unknown[]), keep B; otherwise make B readonly***.
+*/
+type PreserveMutability<A extends readonly unknown[], B> = A extends unknown[] ? B : Readonly<B>;
+type IsDeepEmptyArray<T> = T extends readonly [] ? true : T extends readonly (infer U)[] ? IsDeepEmptyArray<U> : false;
+type FilterNilRecursive<T> = T extends readonly (infer U)[] ? T extends (infer U)[] ? FilterNilRecursive<ExcludeEmptyArray<U>>[] : readonly FilterNilRecursive<ExcludeEmptyArray<U>>[] : Exclude<T, null | undefined>;
+type ExcludeEmptyArray<T> = T extends [] ? never : T;
+type NormalizerArrays<T> = NormalizeEmptyArraysRecursive<RemoveEmptyArrayElements<FilterNilRecursive<T[]>>>;
+type FilterNilArray<T> = IsDeepEmptyArray<NormalizerArrays<T>> extends true ? [] : FixNeverArrayRecursive<NormalizerArrays<T>>;
+/** ----------------------------------------------------------
+* * ***Utility: `filterNilArray`.***
+* ---------------------------------------------
+* **Removes `null` and `undefined` values from an array, including nested arrays.**
+* - **Behavior:**
+*    - Returns `undefined` if the input is explicitly `undefined` or `null`.
+*    - Returns `[]` if input is empty or all elements are removed after filtering.
+*    - Recursively filters nested arrays while preserving structure.
+*    - Ensures proper type inference for safer downstream operations.
+* @template A - The type of elements in the array.
+* @param {T[]|null|undefined} input - The array to be filtered.
+* @returns {T[] | undefined} A new array with `null` and `undefined` values removed,
+* or `undefined` if the input is explicitly `undefined` or `null`.
+* @example
+* ```ts
+* filterNilArray([1, null, 2, undefined, 3]);
+* // ➔ [1, 2, 3]
+* filterNilArray([null, undefined]);
+* // ➔ []
+* filterNilArray(undefined);
+* // ➔ undefined
+* filterNilArray(null);
+* // ➔ undefined
+* filterNilArray([]); // or
+* filterNilArray([[[]]]); // or
+* filterNilArray([[[],undefined,null]]);
+* // ➔ []
+* filterNilArray([1, [null, 2, [undefined, 3]]]);
+* // ➔ [1, [2, [3]]]
+* ```
+*/
+declare function filterNilArray(input: null | undefined): undefined;
+declare function filterNilArray<A extends readonly unknown[]>(input: A): PreserveMutability<A, FilterNilArrayFromTuple<A>>;
+declare function filterNilArray<A extends readonly unknown[]>(input: A | null | undefined): PreserveMutability<A, FilterNilArrayFromTuple<A>> | undefined;
+declare function filterNilArray<A>(input: (A | null | undefined)[] | null | undefined): FilterNilArray<A> | undefined;
+declare function filterNilArray(input: readonly unknown[] | null | undefined): unknown[] | undefined;
+declare function filterNilArray(input: unknown[]): unknown[];
+/** --------------------------------------------
+* * ***Utility: `toBooleanContent`.***
+* ---------------------------------------------
+* **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} Return `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;
+/** -------------------------------------------------
+* * ***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} Return `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
+  */
+  caseInsensitive?: boolean;
+  /** Whether to trim whitespace before comparison, _defaultValue: `true`_.
+  *
+  * @default true
+  */
+  trimString?: boolean;
+  /** Whether to consider the string `"indeterminate"` as `true`, _defaultValue: `false`_.
+  *
+  * @default false
+  */
+  includeIndeterminate?: 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} Return `true` if the value matches a truthy representation, otherwise `false`.
+* @throws **{@link TypeError | `TypeError`}** 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: `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} Return `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: `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;
+/** ----------------------------------------------------------
+* * ***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;
+/** --------------------------------------------------
+* * ***Options for cleaning and transforming parsed JSON data.***
+* --------------------------------------------------
+*
+* Type Options Validation for Function: {@link cleanParsedData | `cleanParsedData`}, {@link parseCustomDate | `parseCustomDate`} and {@link safeJsonParse | `safeJsonParse`}.
+*/
+type ParseParsedDataOptions = {
+  /** --------------------------------------------------
+  * * ***Convert numeric strings to numbers (e.g., `"42"` ➔ `42`), defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  convertNumbers?: boolean;
+  /** --------------------------------------------------
+  * * ***Convert numeric strings `"NaN"` to `NaN` (e.g., `"NaN"` ➔ `NaN`), defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  convertNaN?: boolean;
+  /** --------------------------------------------------
+  * * ***Convert `"true"` / `"false"` strings to boolean values, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  convertBooleans?: boolean;
+  /** --------------------------------------------------
+  * * ***Convert valid date strings into `Date` objects, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  convertDates?: boolean;
+  /** --------------------------------------------------
+  * * ***Custom date formats to be parsed (e.g., `["DD/MM/YYYY", "MM/DD/YYYY"]`), defaultValue: `[]`.***
+  * --------------------------------------------------
+  *
+  * @default []
+  */
+  customDateFormats?: string[];
+  /** --------------------------------------------------
+  * * ***Remove `null` values from objects and arrays, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  removeNulls?: boolean;
+  /** --------------------------------------------------
+  * * ***Remove `undefined` values from objects and arrays, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * - ***Behavior:***
+  *    - `false` (**default**): replaces `undefined` with `null`.
+  *    - `true`: removes keys with `undefined` values.
+  *
+  * @default false
+  */
+  removeUndefined?: boolean;
+  /** --------------------------------------------------
+  * * ***Remove empty objects `{}` from the final output, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  removeEmptyObjects?: boolean;
+  /** --------------------------------------------------
+  * * ***Remove empty arrays `[]` from the final output, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  removeEmptyArrays?: boolean;
+  /** --------------------------------------------------
+  * * ***Removes values that do not match selected conversions, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  strictMode?: boolean;
+  /** --------------------------------------------------
+  * * ***Enable error logging if JSON parsing fails, defaultValue: `false`.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  loggingOnFail?: boolean;
+  /** --------------------------------------------------
+  * * ***Custom error handler function.***
+  * --------------------------------------------------
+  *
+  * - ***Behavior:***
+  *    - If provided, it will be called with the error.
+  *    - If not provided, defaults to `undefined` in type, but internally a no-op function is used.
+  *
+  * @param error - Error instance thrown during fail on execution.
+  * @default undefined
+  */
+  onError?: (error: Error) => void;
+  /** --------------------------------------------------
+  * * ***Whether to check symbol properties when checking empty objects.***
+  * --------------------------------------------------
+  *
+  * @default false
+  */
+  checkSymbols?: boolean;
+};
+/** --------------------------------------------------
+* * ***Utility: `cleanParsedData`.***
+* ---------------------------------------------
+* **Cleans parsed JSON data based on provided options.**
+* @template T - Expected output type.
+* @param {*} data - The parsed JSON data.
+* @param {ParseParsedDataOptions} [options] - The cleaning options.
+* @returns {T | null | undefined} The cleaned data.
+* - ***⚠️ Notice:*** _If data is JSON string, we recommend use ***`safeJsonParse` utility function*** 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;
+/** --------------------------------------------------
+* * ***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 **{@link TypeError | `TypeError`}** 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;
+type NonJsonParsableType = Omit<Exclude<unknown, string | null | undefined>, string>;
+type Contains<T, U> = [Extract<T, U>] extends [never] ? false : true;
+/**
+* ***The value type for the overload function {@link safeJsonParse | `safeJsonParse`}.***
+*/
+type UnknownValue = {
+  undefined: true;
+};
+/**
+* ***The narrows type result for {@link safeJsonParse | `safeJsonParse`}.***
+*/
+type SafeJsonParseResult<TData, T> = IfNotExtends<T, NonJsonParsableType> extends true ? T extends never ? undefined : T extends void ? undefined : T extends number ? undefined : Contains<T, string> extends true ? Contains<T, null & string> extends true ? TData | null | undefined : TData | undefined : IfExtends<T, null> extends true ? null : IfNotExtends<T, NonJsonParsableType> extends true ? TData | null | undefined : undefined : Contains<T, string> extends true ? IsAny<T> extends true ? TData | undefined | null : TData | undefined : undefined;
+/** --------------------------------------------------
+* * ***Utility: `safeJsonParse`.***
+* ---------------------------------------------
+* **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 **{@link TypeError | `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>;
+/** ----------------------------------------------------------
+* * ***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 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;
+/**
+* ***Types options for {@link removeObjectPaths | `removeObjectPaths`}.***
+*/
+type ConfigRemoveObjectPaths<T> = {
+  /** ------------------------------------------------------------------------
+  * * ***The dot-notation path to the property that should be removed.
+  * Can target deeply nested properties (e.g., `"left.data.sensitive"`).***
+  * ------------------------------------------------------------------------
+  * **This is resolved relative to the root object `T`, and supports
+  * any valid **{@link DotPath | `DotPath`}** path within it.**
+  *
+  * @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" } },
+  * //   ]
+  * // };
+  */
+  deep?: boolean;
+};
+/**
+* ***Narrows types result for {@link removeObjectPaths | `removeObjectPaths`}.***
+*/
+type ResultRemoveObjectPaths<T, K extends readonly ConfigRemoveObjectPaths<T>[]> = Prettify<RemoveNested<ChangeNeverArrayToArrayDeep<T>, KeysToRemove<T, K>>, {
+  recursive: true;
+}> extends never ? T : Prettify<RemoveNested<ChangeNeverArrayToArrayDeep<T>, KeysToRemove<T, K>>, {
+  recursive: true;
+}>;
+/** ------------------------------------------------------------------------
+* * ***Utility: `removeObjectPaths`.***
+* ------------------------------------------------------------------------
+* **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 **{@link TypeError | `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>;
+/** -------------------------------------------------
+* * ***Type 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
+  */
+  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
+  */
+  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
+  */
+  pretty?: boolean;
+  /** -------------------------------------------------
+  * * ***Preserve `undefined` values instead of converting them to `null`.***
+  * -------------------------------------------------
+  * **Controls how the internal `deepProcess` step rewrites values
+  * **before** the final `JSON.stringify` call.**
+  * - **Default (`false`):**
+  *     * Every `undefined` value (object properties **and** array elements)
+  *       is replaced with `null` **before** serialization, because this happens
+  *       first, the key is **not removed** by `JSON.stringify`.
+  * - **`true`** – Leaves `undefined` untouched so the final
+  *   `JSON.stringify` call behaves natively:
+  *     * Object properties with `undefined` are **removed**.
+  *     * Array elements that are `undefined` become `null`.
+  * @default false
+  * @example
+  * // ✅ keepUndefined = true: behaves like native JSON.stringify
+  * safeStableStringify({ a: undefined }, { keepUndefined: true });
+  * // ➔ '{}' // key removed
+  *
+  * // ✅ Default (false): convert undefined to null, key kept
+  * safeStableStringify({ a: undefined });
+  * // ➔ '{"a":null}' // key present, value null
+  *
+  * // Arrays
+  * safeStableStringify([undefined]);
+  * // ➔ '[null]' // same, but via pre-replacement
+  * safeStableStringify([undefined], { keepUndefined: true });
+  * // ➔ '[null]' // element becomes null
+  */
+  keepUndefined?: boolean;
+};
+/** --------------------------------------------
+* * ***Utility: `safeStableStringify`.***
+* ---------------------------------------------
+* **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.
+*        - Controls how `undefined` is handled **before** the final `JSON.stringify` call, by `keepUndefined`
+*          options, default: `false`.
+*            - **false**: All `undefined` values (object properties and array elements) are replaced
+*            with `null`, so object keys remain.
+*            - **true**: Leaves `undefined` values as-is, and handling by native `JSON.stringify` then:
+*               1. Removes object properties that are `undefined`.
+*               2. Converts `undefined` array elements to `null`.
+*            - Use `true` when you need native removal of keys or to preserve sparse arrays
+*              exactly as `JSON.stringify` would.
+* @param {*} value
+*  ***Any JavaScript value to serialize, can be:***
+*    - Primitives (`number`, `string`, `boolean`, `bigint`, `null`, `undefined`).
+*    - Boxed primitives (`new Number()`, `new String()`, `new Boolean()`).
+*    - Arrays, plain objects, nested structures.
+*    - Date, Map, Set.
+*    - Circular structures.
+* @param {SafeStableStringifyOptions} [options]
+*   ***Configuration options for `safeStableStringify`:***
+*    - `keepUndefined` (boolean) – Control how `undefined` is handled **before** the final `JSON.stringify`
+*       call, default: `false`.
+*    - `sortKeys` (boolean) – Whether to sort object keys alphabetically (recursively), default: `true`.
+*    - `sortArray` (boolean) – Whether to sort primitive values inside arrays, default: `false`.
+*    - `pretty` (boolean) – Whether to pretty-print JSON output with 2-space indentation, default: `false`.
+* @returns {string}
+*   A stable JSON string representation of the input value.
+* @throws **{@link TypeError | `TypeError`}** 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]'
+*
+* // keepUndefined = true (native removal of keys)
+* safeStableStringify({ a: undefined }, { keepUndefined: true });
+* // ➔ '{}'   // key `a` is removed, like native JSON.stringify
+*
+* // Default keepUndefined = false (convert to null, keep key)
+* safeStableStringify({ a: undefined });
+* // ➔ '{"a":null}'
+*
+* // Nested object + sortArray=true
+* safeStableStringify({ z: [3, 1, 2], x: { d: 4, c: 3 } }, {
+*    sortKeys:true,
+*    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 (keepUndefined = false or keepUndefined = true)
+* 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;
+/** ----------------------------------------------------------
+* * 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.
+* ----------------------------------------------------------
+*/
+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 Date | boolean | Boolean ? number : T extends string | String | Number | number | `${number}` ? number | undefined : AndArr<[Extends<RemoveEmptyArrays, true>, Extends<T, undefined[]>]> extends true ? never : T extends readonly (infer E)[] ? OrArr<[Extends<RemoveEmptyArrays, true>, AndArr<[Extends<RemoveEmptyArrays, true>, Extends<IsRoot, true>]>]> extends true ? FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<E, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>, RemoveEmptyArrays>[] | undefined : FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<E, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>[], RemoveEmptyArrays> : T extends Set<infer V> ? AndArr<[Extends<RemoveEmptyArrays, true>]> extends true ? FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<V, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>[], RemoveEmptyArrays> : FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<V, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>[], RemoveEmptyArrays> : T extends Map<infer K, infer V> ? FixNeverArray$1<[Exclude<ConvertedDeepNumberInternal<K, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>, Exclude<ConvertedDeepNumberInternal<V, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>][], RemoveEmptyArrays> : T extends Buffer ? FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<string, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>[], RemoveEmptyArrays> : T extends TypedArray ? FixNeverArray$1<Exclude<ConvertedDeepNumberInternal<string, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>, undefined>[], RemoveEmptyArrays> : T extends Record<PropertyKey, unknown> ? _ConvertedObjectInternal$1<T, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> : never;
+/** ----------------------------------------------------------
+* * Internal object conversion utility.
+* * Removes empty objects/arrays based on flags.
+* ----------------------------------------------------------
+*/
+type _ConvertedObjectInternal$1<O extends Record<PropertyKey, unknown> | string | number, RemoveEmptyObjects extends boolean, RemoveEmptyArrays extends boolean, IsRoot extends boolean> = { [K in keyof O as Exclude<ConvertedDeepNumberInternal<O[K], RemoveEmptyObjects, RemoveEmptyArrays, false>, undefined> extends infer Convert ? [Convert] extends [never] ? never : undefined extends ConvertedDeepNumberInternal<O[K], RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> ? never : RemoveEmptyArrays extends true ? Convert extends readonly unknown[] ? [Convert] extends [[]] ? never : K : K : K : never]: Exclude<ConvertedDeepNumberInternal<O[K], RemoveEmptyObjects, RemoveEmptyArrays, false>, undefined> } & { [K in keyof O as Exclude<ConvertedDeepNumberInternal<O[K], RemoveEmptyObjects, RemoveEmptyArrays, false>, undefined> extends infer Convert ? [Convert] extends [never] ? never : undefined extends ConvertedDeepNumberInternal<O[K], RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> ? RemoveEmptyArrays extends true ? Convert extends readonly unknown[] ? [Convert] extends [[]] ? never : K : K : K : never : never]?: Exclude<ConvertedDeepNumberInternal<O[K], RemoveEmptyObjects, RemoveEmptyArrays, false>, undefined> } extends infer M ? RemoveEmptyObjects extends true ? keyof M extends never ? IsRoot extends true ? {} : never : _ProcessedObject$1<M, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> : Simplify$1<M> : never;
+type AllPropsAreNumber$1<O> = { [K in keyof O]: O[K] extends number | Number ? true : O[K] extends Record<string, unknown> ? AllPropsAreNumber$1<O[K]> : false }[keyof O] extends false ? false : true;
+type _ProcessedObject$1<M, RemoveEmptyObjects extends boolean, RemoveEmptyArrays extends boolean, IsRoot extends boolean> = M extends unknown[] ? ConvertedDeepNumberInternal<M, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> : Prettify<Simplify$1<{ [K in keyof M]: M[K] extends Record<string, unknown> ? AllPropsAreNumber$1<M[K]> extends true ? { [ChildKey in keyof M[K]]: M[K][ChildKey] extends number | Number ? M[K][ChildKey] | undefined : _ProcessedObject$1<M[K][ChildKey], RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> } | undefined : AndArr<[Extends<RemoveEmptyArrays, true>, Extends<RemoveEmptyObjects, true>]> extends true ? { [ChildKey in keyof M[K]]: _ProcessChild$1<M[K][ChildKey], RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> } | undefined : { [ChildKey in keyof M[K]]: _ProcessChild$1<M[K][ChildKey], RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> } : M[K] extends unknown[] ? ConvertedDeepNumberInternal<M[K], RemoveEmptyObjects, RemoveEmptyArrays, false> : _ProcessedObject$1<M[K], RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> }>, {
+  recursive: true;
+}>;
+type _ProcessChild$1<T, RemoveEmptyObjects extends boolean, RemoveEmptyArrays extends boolean, IsRoot extends boolean> = T extends number | number[] ? ConvertedDeepNumberInternal<T, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> : T extends Record<string, unknown> ? _ProcessedObject$1<T, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot> : _ProcessedObject$1<T, RemoveEmptyObjects, RemoveEmptyArrays, IsRoot>;
+/** ----------------------------------------------------------
+* * Public type: Deeply converts numbers/strings to `number | undefined`,
+* * applies empty object/array removal, preserves special types.
+* ----------------------------------------------------------
+*
+* **Narrows types result for {@link toNumberDeep | `toNumberDeep`}.***
+*/
+type ConvertedDeepNumber<T, RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = [unknown] extends [T] ? unknown : FixNeverArray$1<ConvertedDeepNumberInternal<T, RemoveEmptyObjects, RemoveEmptyArrays, true>, RemoveEmptyArrays>;
+/**
+* ***Types options for {@link toNumberDeep | `toNumberDeep`}.***
+*/
+type ToNumberDeepOptions<RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = {
+  /** Whether to remove empty objects (`{}`) from the result.
+  *
+  * - `true` ➔ remove empty objects recursively.
+  * - `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
+  */
+  removeEmptyArrays?: RemoveEmptyArrays;
+};
+/** --------------------------------------------------
+* * ***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)` ➔ `.valueOf()` ➔ `"123"` ➔ `Number("123")` ➔ `123`.
+*        - `new String("123")` ➔ `.valueOf()` ➔ `"123"` ➔ `Number("123")` ➔ `123`.
+*        - `new String(true)` ➔ `.valueOf()` ➔ `"true"` ➔ `Number(true)` ➔ `1`.
+*        - `new String(false)` ➔ `.valueOf()` ➔ `"false"` ➔ `Number(false)` ➔ `0`.
+*        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:
+*          - `new String("hi")` ➔ `.valueOf()` ➔ `"hi"` ➔ `Number("hi")` ➔ `NaN` ***(remove)***.
+*          - `new String(()=>{})` ➔ `.valueOf()` ➔ `"()=>{}"` ➔ `Number("()=>{}")` ➔ `NaN` ***(remove)***.
+*      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to number:
+*        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `Number(true)` ➔ `1`.
+*        - `new Boolean(false)` ➔ `.valueOf()` ➔ `false` ➔ `Number(false)` ➔ `0`.
+*        - Special behavior JS of new Boolean, return `false` **(convert to number: `0`)**
+*          for `false`, (`0` / `-0`), `""` (empty-string),
+*          `null`, `undefined`, `NaN`, otherwise `true` **(convert to number: `1`)**.
+*      - For `new Number`:
+*        - `new Number(42)` ➔ `.valueOf()` ➔ `42`.
+*        - `new Number("42")` ➔ `.valueOf()` ➔ `42`.
+*        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number).
+*        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:
+*          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+*          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+*          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.
+*          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.
+*    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.
+*    - Removes `empty-string`, `non-numeric strings`.
+*    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.
+*    - Removes `unsupported` types like `functions` , `RegExp`, `symbols`, and `BigInt`.
+*    - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.
+* @template T - The input type.
+* @template RemoveEmptyObjects - Whether to remove empty objects.
+* @template RemoveEmptyArrays - Whether to remove empty arrays.
+* @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 ? OrArr<[Extends<T, undefined>, Extends<undefined, T>]> extends true ? undefined : never : [] : T;
+/** ----------------------------------------------------------
+* * 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 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 : _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.
+* ----------------------------------------------------------
+* ***Narrows types result for {@link toStringDeep | `toStringDeep`}.***
+*/
+type ConvertedDeepString<T, RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = [unknown] extends [T] ? unknown : FixNeverArray<Simplify<ConvertedDeepStringInternal<T, RemoveEmptyObjects, RemoveEmptyArrays, true>>, RemoveEmptyArrays>;
+/**
+* ***Types options for {@link toStringDeep | `toStringDeep`}.***
+*/
+type ToStringDeepOptions<RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = {
+  /** Whether to remove empty objects (`{}`) from the result.
+  *
+  * - `true` ➔ remove empty objects recursively.
+  * - `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
+  */
+  removeEmptyArrays?: RemoveEmptyArrays;
+};
+/** --------------------------------------------------
+* * ***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")` ➔ `.valueOf()` ➔ `"hi"`.
+*        - `new String(true)` ➔ `.valueOf()` ➔ `"true"`.
+*      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:
+*        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `"true"`.
+*        - Special behavior JS of new Boolean, return `false` **(convert to string: `"false"`)**
+*          for `false`, (`0` / `-0`), `""` (empty-string), `null`, `undefined`, `NaN`, otherwise
+*          `true` **(convert to string: `"true"`)**.
+*      - For `new Number`:
+*        - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `"42"`.
+*        - `new Number("42")` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `"42"`.
+*        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `"0"`.
+*        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:
+*          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+*          - `new Number("abc")` ➔ `.valueOf()` ➔ `NaN`  ***(remove)***.
+*          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.
+*          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.
+*          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.
+*    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.
+*    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.
+*    - Removes `unsupported` types like `functions`, `symbols`, and `BigInt`.
+*    - 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>;
+/** ----------------------------------------------------------
+* * ***Utility: `toStringDeepForce`.***
+* ---------------------------------------------
+* **Recursively converts a value into a string based on the `forceToString` options.**
+* - **Rules `forceToString` options:**
+*    - `"stringOrNumber"`: Converts strings and numbers to strings.
+*    - `"primitives"`: Converts all primitives (number, string, boolean, bigint, undefined, null, NaN) to strings.
+*    - `"all"`: Converts everything, including symbols, functions, Dates, RegExp, Maps, Sets, Errors, Promises,
+*       boxed primitives box (new Number, new String, new Boolean), and deeply all object properties, to strings.
+*    - `false`: Leaves everything unchanged.
+* - **Special behaviors:**
+*    - `NaN` ➔ `"NaN"` only in `"primitives"` or `"all"` mode.
+*    - `Date` ➔ ISO string only in `"all"` mode.
+*    -  ***Primitives Boxed*** (`new Number`, `new String`, `new Boolean`):
+*       - For `new String` we convert everything to string (behavior JS of new String):
+*         - `new String("hi")` ➔ `.valueOf()` ➔ `"hi"`.
+*         - `new String(true)` ➔ `.valueOf()` ➔ `"true"`.
+*       - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:
+*         - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `"true"`.
+*         - Special behavior JS of new Boolean, return `false` **(convert to string: `"false"`)**
+*           for `false`, (`0` / `-0`), `""` (empty-string), `null`, `undefined`, `NaN`, otherwise
+*           `true` **(convert to string: `"true"`)**.
+*       - For `new Number`:
+*         - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `"42"`.
+*         - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `"NaN"`.
+*         - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `"0"`.
+*         - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `"NaN"`.
+*         - `new Number(Infinity)` ➔ `Infinity` ➔ `Infinity` ➔ `Infinity.toString()` ➔ `"Infinity"`.
+*         - `new Number(-Infinity)` ➔ `-Infinity` ➔ `-Infinity` ➔ `-Infinity.toString()` ➔ `"-Infinity"`.
+*    - `RegExp` ➔ Source string (e.g. `/abc/i`) only in `"all"` mode.
+*    - `Symbol` ➔ `Symbol(description)` string only in `"all"` mode.
+*    - `Map` ➔ Array of [key, value] pairs with keys/values stringified deeply (only in `"all"` mode).
+*    - `Set` ➔ Array of values stringified deeply (only in `"all"` mode).
+*    - `Function` ➔ Source code string (e.g. `"() => 1"`) only in `"all"` mode.
+*    - `Error`, `Promise` ➔ Stringified via `.toString()` only in `"all"` mode.
+* @param {*} value
+* * ***The value to process.***
+*    - ***Can be anything:***
+*        - `primitive`.
+*        - `array`.
+*        - `object`.
+*        - `function`.
+*        - `etc`.
+* @param {false | "stringOrNumber" | "primitives" | "all"} forceToString - ***The mode of string conversion.***
+* @returns {unknown} A new value with the conversion applied based on `forceToString`.
+* @example
+* toStringDeepForce(42, "stringOrNumber");
+* // ➔ "42"
+* toStringDeepForce(true, "primitives");
+* // ➔ "true"
+* toStringDeepForce(null, "primitives");
+* // ➔ "null"
+* toStringDeepForce(Symbol("x"), "all");
+* // ➔ "Symbol(x)"
+* toStringDeepForce(new String("hi"), "all");
+* // ➔ "hi"
+* toStringDeepForce(new Number(42), "all");
+* // ➔ "42"
+* toStringDeepForce(new Boolean(true), "all");
+* // ➔ "true"
+* toStringDeepForce({ a: 1, b: [2, NaN] }, "primitives");
+* // ➔ { a: "1", b: ["2", "NaN"] }
+* toStringDeepForce(new Date("2025-01-01"), "all");
+* // ➔ "2025-01-01T00:00:00.000Z"
+* toStringDeepForce(() => 1, "all");
+* // ➔ "() => 1"
+* toStringDeepForce(/abc/i, "all");
+* // ➔ "/abc/i"
+* toStringDeepForce(new Map([["a", 1], ["b", 2]]), "all");
+* // ➔ [["a", "1"], ["b", "2"]]
+* toStringDeepForce(new Set([1, 2, 3]), "all");
+* // ➔ ["1", "2", "3"]
+* toStringDeepForce(new Error("Oops"), "all");
+* // ➔ "Error: Oops"
+* toStringDeepForce(Promise.resolve(1), "all");
+* // ➔ "[object Promise]"
+* toStringDeepForce({ func: () => 123 }, "all");
+* // ➔ { func: "() => 123" }
+* toStringDeepForce([1, "a", { b: 2 }], false);
+* // ➔ [1, "a", { b: 2 }]
+*/
+declare function toStringDeepForce<T>(value: unknown, forceToString: false | "stringOrNumber" | "primitives" | "all"): T;
+export { dedupeArray as _, removeObjectPaths as a, parseCustomDate as c, parseCurrencyString as d, toBooleanLoose as f, filterNilArray as g, toBooleanContent as h, safeStableStringify as i, cleanParsedData as l, toBooleanContentDeep as m, toStringDeep as n, extractDigits as o, toBooleanExplicit as p, toNumberDeep as r, safeJsonParse as s, toStringDeepForce as t, convertType as u, toStringArrayUnRecursive as v, toNumberArrayUnRecursive as y };