@rzl-zone/utils-js 2.0.1 → 3.0.0-beta.0

package/dist/conversions/index.d.ts

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