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

package/dist/conversions/index.d.ts

@@ -1,1793 +1,12 @@
 /*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.12.0.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-import { Nullish, KeepNull, KeepUndef, AnyFunction, NormalizeEmptyArraysRecursive, RemoveEmptyArrayElements, FixNeverArrayRecursive, IfNotExtends, IfExtends, IsAny, NumberRangeUnion, Prettify, OrArr, Extends, AndArr, TypedArray, WebApiObjects, IntlObjects } 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.***
- * --------------------------------------------------
- *
- * @private Type Options Validation for Function: {@link cleanParsedData | `cleanParsedData`}, {@link parseCustomDate | `parseCustomDate`} and {@link safeJsonParse | `safeJsonParse`}.
- */
-type ParseParsedDataOptions = {
-    /** --------------------------------------------------
-     * * ***Convert numeric strings to numbers (e.g., `"42"` ➔ `42`), defaultValue: `false`.***
-     * --------------------------------------------------
-     *
-     * @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;
-/** @private ***The value type for the overload function {@link safeJsonParse | `safeJsonParse`}.*** */
-type UnknownValue = {
-    undefined: true;
-};
-/** @private ***The narrows type result for {@link safeJsonParse | `safeJsonParse`}.*** */
-type SafeJsonParseResult<TData, T> = IfNotExtends<T, NonJsonParsableType> extends true ? T extends never ? undefined : T extends void ? undefined : T extends number ? undefined : Contains<T, string> extends true ? Contains<T, null & string> extends true ? TData | null | undefined : TData | undefined : IfExtends<T, null> extends true ? null : IfNotExtends<T, NonJsonParsableType> extends true ? TData | null | undefined : undefined : Contains<T, string> extends true ? IsAny<T> extends true ? TData | undefined | null : TData | undefined : undefined;
-
-/** --------------------------------------------------
- * * ***Utility: `safeJsonParse`.***
- * ---------------------------------------------
- * **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;
-/** @private ***Types options for {@link removeObjectPaths | `removeObjectPaths`}.*** */
-type ConfigRemoveObjectPaths<T> = {
-    /** ------------------------------------------------------------------------
-     * * ***The dot-notation path to the property that should be removed.
-     * Can target deeply nested properties (e.g., `"left.data.sensitive"`).***
-     * ------------------------------------------------------------------------
-     * **This is resolved relative to the root object `T`, and supports
-     * any valid **{@link DotPath | `DotPath`}** path within it.**
-     *
-     * @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;
-};
-/** @private ***Narrows types result for {@link removeObjectPaths | `removeObjectPaths`}.*** */
-type ResultRemoveObjectPaths<T, K extends readonly ConfigRemoveObjectPaths<T>[]> = Prettify<RemoveNested<ChangeNeverArrayToArrayDeep<T>, KeysToRemove<T, K>>, {
-    recursive: true;
-}> extends never ? T : Prettify<RemoveNested<ChangeNeverArrayToArrayDeep<T>, KeysToRemove<T, K>>, {
-    recursive: true;
-}>;
-
-/** ------------------------------------------------------------------------
- * * ***Utility: `removeObjectPaths`.***
- * ------------------------------------------------------------------------
- * **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.
- * ----------------------------------------------------------
- * @private ***Narrows types result for {@link toNumberDeep | `toNumberDeep`}.***
- */
-type ConvertedDeepNumber<T, RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = [unknown] extends [T] ? unknown : FixNeverArray$1<ConvertedDeepNumberInternal<T, RemoveEmptyObjects, RemoveEmptyArrays, true>, RemoveEmptyArrays>;
-/** @private ***Types options for {@link toNumberDeep | `toNumberDeep`}.*** */
-type ToNumberDeepOptions<RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = {
-    /** Whether to remove empty objects (`{}`) from the result.
-     *
-     * - `true` ➔ remove empty objects recursively.
-     * - `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.
- * ----------------------------------------------------------
- * @private ***Narrows types result for {@link toStringDeep | `toStringDeep`}.***
- */
-type ConvertedDeepString<T, RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = [unknown] extends [T] ? unknown : FixNeverArray<Simplify<ConvertedDeepStringInternal<T, RemoveEmptyObjects, RemoveEmptyArrays, true>>, RemoveEmptyArrays>;
-/** @private ***Types options for {@link toStringDeep | `toStringDeep`}.*** */
-type ToStringDeepOptions<RemoveEmptyObjects extends boolean = false, RemoveEmptyArrays extends boolean = false> = {
-    /** Whether to remove empty objects (`{}`) from the result.
-     *
-     * - `true` ➔ remove empty objects recursively.
-     * - `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;
-
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+
+import { _ as dedupeArray, a as removeObjectPaths, c as parseCustomDate, d as parseCurrencyString, f as toBooleanLoose, g as filterNilArray, h as toBooleanContent, i as safeStableStringify, l as cleanParsedData, m as toBooleanContentDeep, n as toStringDeep, o as extractDigits, p as toBooleanExplicit, r as toNumberDeep, s as safeJsonParse, t as toStringDeepForce, u as convertType, v as toStringArrayUnRecursive, y as toNumberArrayUnRecursive } from "../index-DRpOyBSC.js";
 export { cleanParsedData, convertType, dedupeArray, extractDigits, filterNilArray, parseCurrencyString, parseCustomDate, removeObjectPaths, safeJsonParse, safeStableStringify, toBooleanContent, toBooleanContentDeep, toBooleanExplicit, toBooleanLoose, toNumberArrayUnRecursive, toNumberDeep, toStringArrayUnRecursive, toStringDeep, toStringDeepForce };