@rzl-zone/utils-js 2.1.0 → 3.0.1-beta.0

package/dist/index.d.ts

@@ -1,4334 +1 @@
-import{FormatOptions}from 'date-fns';import{Locale}from 'date-fns/locale';type If<Condition,IfTrue=true,IfFalse=false>=Condition extends true ? IfTrue:IfFalse;type Not<T extends boolean>=T extends true ? false:true;type Extends<T,Base>=[T] extends [Base] ? true:false;type NotExtends<T,Base>=Not<Extends<T,Base>>;type IfExtends<T,Base,IfTrue=true,IfFalse=false>=If<Extends<T,Base>,IfTrue,IfFalse>;type IfNotExtends<T,Base,IfTrue=true,IfFalse=false>=If<NotExtends<T,Base>,IfTrue,IfFalse>;type IsAny<T>=0 extends 1 & T ? true:false;type PrettifyOptions={recursive:boolean;};type Prettify<T,Options extends PrettifyOptions={recursive:false;}>=T extends infer R ?{[K in keyof R]:If<Options["recursive"],Prettify<R[K],Options>,R[K]>;}:never;type OmitStrict<T,K extends keyof T,WithPrettify extends boolean=true,WithPrettifyRecursive extends boolean=true>=WithPrettify extends true ? Prettify<Omit<T,K>,{recursive:WithPrettifyRecursive;}>:WithPrettify extends false ? Omit<T,K>:never;type AnyFunction=(...args:any[])=>any;type TypedArray=Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;type WebApiObjects=URL | URLSearchParams | FormData | Headers | Response | Request | ReadableStream<any>| WritableStream<any>| TransformStream<any,any>| MessageChannel | MessagePort | MessageEvent | Event | CustomEvent | HTMLElement | Node | Document | Window | AbortController | AbortSignal | TextEncoder | TextDecoder | CryptoKey | File | FileList | ImageBitmap | CanvasRenderingContext2D | WebSocket;type IntlObjects=Intl.Collator | Intl.DateTimeFormat | Intl.NumberFormat | Intl.RelativeTimeFormat | Intl.PluralRules | Intl.ListFormat | Intl.Locale;type NodeBuiltins=Buffer;type NonPlainObject=AnyFunction | Array<any>| Date | RegExp | Map<any,any>| Set<any>| WeakMap<any,any>| WeakSet<any>| Error | Promise<any>| ArrayBuffer | DataView | TypedArray | WebApiObjects | IntlObjects | NodeBuiltins | symbol |{[Symbol.toStringTag]:"Proxy";}| typeof Reflect;type Enumerate<N extends number,Acc extends number[]=[]>=Acc["length"] extends N ? Acc[number]:Enumerate<N,[...Acc,Acc["length"]]>;type RangeNumberTo999<From extends number,To extends number>=From extends To ? From:Exclude<Enumerate<To>,Enumerate<From>>extends never ? never:Exclude<Enumerate<To>,Enumerate<From>>| To;
-/** -------------------------------------------------------
- * * ***Asserts that a value is of type `string`.***
- * -------------------------------------------------------
- *
- * Throws a `TypeError` if the value is not a string.
- *
- * @param {unknown} value - The value to check.
- * @param {string | ((actualType: string) => string)} [message]
- *        Optional custom error message. If a function is provided,
- *        it receives the actual type (e.g. "number") and should return a string message.
- * @returns {asserts value is string} Ensures `value` is `string` after this call.
- *
- * @throws {TypeError} If the value is not a string.
- *
- * @example
- * assertIsString("hello"); // ✅ ok
- *
- * @example
- * assertIsString(42); // ❌ throws TypeError: Expected value to be 'string', but got 'number'
- *
- * @example
- * assertIsString(42, "Must be a string!"); // ❌ throws: Must be a string!
- *
- * @example
- * assertIsString(42, (type) => `Expected string but got ${type}`); // ❌ throws: Expected string but got number
- */
-declare const assertIsString:(value:unknown,message?:string |((typeValue:string)=>string))=>asserts value is string;
-/** ---------------------------------------------
- * * ***Converts all values in an array from numbers or other types to strings.***
- * * ***The function can also remove invalid values (null, undefined) based on the options provided.***
- * ---------------------------------
- *
- * * 🚫 Note: This function does NOT support recursive or nested arrays.
- *   It only processes a flat array of values.
- *
- * * Use `toStringDeep` if you want to recursive.
- * ---------------------------------------------
- *
- * @param {Array<string | number | null | undefined>} [array] - The array to be transformed.
- * @param {Object} [options] - The options object that controls the transformation behavior.
- * @param {boolean} [options.removeInvalidValue=true] - If true, removes invalid values (null, undefined) from the result. Default is true.
- * @returns {Array<string | null | undefined>} - A new array with string representations of the values or an array with invalid values removed if specified.
- *
- * @example
- * toStringArrayUnRecursive([1, 2, '3'])
- * // => ['1', '2', '3']
- *
- * @example
- * toStringArrayUnRecursive([1, null, undefined, 'abc'], { removeInvalidValue: true })
- * // => ['1', 'abc']
- *
- * @example
- * toStringArrayUnRecursive([1, null, undefined, 'abc'], { removeInvalidValue: false })
- * // => ['1', null, undefined, 'abc']
- *
- * @example
- * toStringArrayUnRecursive(undefined)
- * // => undefined
- */
-declare function toStringArrayUnRecursive(array?:undefined | null,options?:{
-/** If true, removes invalid values (null, undefined) from the result. Default is true.
-	 * @default true
-	 */
-removeInvalidValue:boolean;}):undefined;declare function toStringArrayUnRecursive(array?:Array<never>,options?:{
-/** If true, removes invalid values (null, undefined) from the result. Default is true.
-	 * @default true
-	 */
-removeInvalidValue:boolean;}):Array<never>;declare function toStringArrayUnRecursive(array?:Array<undefined | null>| Array<null | undefined>,options?:{
-/** If true, removes invalid values (null, undefined) from the result. Default is true.
-	 * @default true
-	 */
-removeInvalidValue:boolean;}):Array<undefined>;declare function toStringArrayUnRecursive<T>(array?:Array<T>,options?:{
-/** If true, removes invalid values (null, undefined) from the result. Default is true.
-	 * @default true
-	 */
-removeInvalidValue:true;}):Array<string>| undefined;declare function toStringArrayUnRecursive<T>(array?:Array<T>,options?:{
-/** If true, removes invalid values (null, undefined) from the result. Default is true.
-	 * @default true
-	 */
-removeInvalidValue:false;}):Array<string | null | undefined>| undefined;
-/** ---------------------------------
- * * ***Converts an array of string values (or values that can be cast to string) to an array of numbers.***
- * * ***Optionally removes invalid values (non-numeric values) based on the provided options.***
- * ---------------------------------
- *
- * * 🚫 Note: This function does NOT support recursive or nested arrays.
- *   It only processes a flat array of values.
- *
- * * Use `toNumbersDeep` if you want to recursive.
- * ---------------------------------
- *
- * @param {Array<string | null | undefined>} [array] - The array of string values (or values convertible to strings) to be transformed into numbers.
- * @param {Object} [options] - Options that affect the conversion behavior.
- * @param {boolean} [options.removeInvalidValueNumber=true] - If true, removes invalid number values (e.g., NaN, undefined) from the result. Default is true.
- * @returns {Array<number | undefined>} - An array of numbers converted from the string values, or an array with invalid values removed if specified.
- */
-declare function toNumberArrayUnRecursive(array?:undefined | null,options?:{
-/** If true, removes invalid number values (e.g., NaN, undefined) from the result. Default is true.
-	 *
-	 * @default true
-	 */
-removeInvalidValueNumber?:boolean;}):undefined;declare function toNumberArrayUnRecursive(array?:Array<never>,options?:{
-/** If true, removes invalid number values (e.g., NaN, undefined) from the result. Default is true.
-	 *
-	 * @default true
-	 */
-removeInvalidValueNumber?:boolean;}):Array<never>;declare function toNumberArrayUnRecursive(array?:Array<undefined | null>| Array<null | undefined>,options?:{
-/** If true, removes invalid number values (e.g., NaN, undefined) from the result. Default is true.
-	 *
-	 * @default true
-	 */
-removeInvalidValueNumber?:boolean;}):Array<undefined>;declare function toNumberArrayUnRecursive<T>(array?:Array<T>,options?:{
-/** If true, removes invalid number values (e.g., NaN, undefined) from the result. Default is true.
-	 *
-	 * @default true
-	 */
-removeInvalidValueNumber?:true;}):Array<number>| undefined;declare function toNumberArrayUnRecursive<T>(array?:Array<T>,options?:{
-/** If true, removes invalid number values (e.g., NaN, undefined) from the result. Default is true.
-	 *
-	 * @default true
-	 */
-removeInvalidValueNumber:false;}):Array<number | undefined>| 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 false | "stringOrNumber" | "primitives" | "all"=false,FTN extends boolean=false>=FTN extends false ? ResUnFTN<Force>:ResFTN<Force>;
-/** ----------------------------------------------------------
- * * ***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
- * filterNullArray([1, null, 2, undefined, 3]);
- * // => [1, 2, 3]
- *
- * @example
- * filterNullArray([null, undefined]);
- * // => []
- *
- * @example
- * filterNullArray(undefined);
- * // => undefined
- * @example
- * filterNullArray(null);
- * // => undefined
- *
- * @example
- * filterNullArray([]);
- * // => []
- *
- * @example
- * filterNullArray([1, [null, 2, [undefined, 3]]]);
- * // => [1, [2, [3]]]
- */
-declare const filterNullArray:<T>(input?:T[] | null)=>T[] | undefined;
-/** ----------------------------------------------------------
- * * ***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 FTS - `forceToString` mode.
- * @template FTN - `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<FTS, FTN>} 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
- * dedupeArray(["apple", "banana", "apple"]);
- * // => ["apple", "banana"]
- *
- * @example
- * dedupeArray([[1, 2], [1, 2]], { flatten: true });
- * // => [1, 2]
- *
- * @example
- * dedupeArray([new Set([1, 2]), new Set([2, 3])], { flatten: true });
- * // => [1, 2, 3]
- *
- * @example
- * dedupeArray([1, "1", 2, "2"], { forceToString: "stringOrNumber" });
- * // => ["1", "2"]
- *
- * @example
- * dedupeArray([true, "true", false, undefined], { forceToString: "primitives" });
- * // => ["true", "false", "undefined"]
- *
- * @example
- * dedupeArray([1, "1", { a: 1 }], { forceToString: "all" });
- * // => ["1", { a: "1" }]
- *
- * @example
- * dedupeArray([1, 1, [2, 2, [3, 3]]]);
- * // => [1, [2, [3]]]
- *
- * @example
- * dedupeArray([null, undefined, null]);
- * // => [null, undefined]
- *
- * @example
- * dedupeArray([[], [[]], [[[]]], [[]], [[[]]]]);
- * // => [[], [[]], [[[]]]]
- *
- * @example
- * 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.
- *
- * @example
- * dedupeArray([Symbol("x"), Symbol("x")]);
- * // => [Symbol("x")] (symbols are same by identity, so dedupe
- *
- * @example
- * dedupeArray([NaN, NaN, 1, "1"]);
- * // => [NaN, 1, "1"]
- *
- * @example
- * dedupeArray([NaN, NaN, 1, "1"], { forceToString: "primitives" });
- * // => ["NaN", "1"]
- *
- * @example
- * dedupeArray([new Date("2025-01-01"), new Date("2025-01-01")]);
- * // => [Date("2025-01-01")] (same time, deduped)
- *
- * @example
- * dedupeArray([new Date("2025-01-01"), new Date("2025-01-01")], { forceToString: "all" });
- * // => ["2025-01-01T00:00:00.000Z"]
- *
- * @example
- * dedupeArray([/abc/, /abc/], { forceToString: "all" });
- * // => ["/abc/"]
- *
- * @example
- * dedupeArray([new Map(), new Set(), new Error("err")], { forceToString: "all" });
- * // => ["[object Map]", "[object Set]", "Error: err"]
- *
- * @example
- * dedupeArray([Promise.resolve(1), Promise.resolve(1)], { forceToString: "all" });
- * // => ["[object Promise]"]
- *
- * @example
- * dedupeArray([{ a: 1 }, { a: 1 }, { a: 2 }], { forceToString: "primitives" });
- * // => [{ a: "1" }, { a: "2" }]
- *
- * @example
- * dedupeArray([{ a: { b: 1 } }, { a: { b: 1 } }], { forceToString: "all" });
- * // => [{ a: { b: "1" } }]
- *
- * @example
- * dedupeArray("not an array");
- * // Throws TypeError
- *
- * @example
- * dedupeArray([1, 2, 3], { forceToString: "invalid" });
- * // Throws TypeError
- */
-declare const dedupeArray:<FTS extends false | "stringOrNumber" | "primitives" | "all"=false,FTN extends boolean=false>(inputArray:unknown[],options?:{
-/** Enables string conversion for comparison, default is `false`.
-	 *
-	 * @default false
-	 */
-forceToString?:FTS;
-/** If true, deeply flattens arrays, Maps, and Sets before deduplication, default is `false`.
-	 *
-	 * @default false
-	 */
-flatten?:FTN;})=>DedupeResult<FTS,FTN>;
-/** ---------------------------------
- * * ***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([]);        // false
- * toBooleanContent([1]);       // true
- * toBooleanContent({});        // false
- * toBooleanContent({ a: 1 });  // true
- */
-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([0, "", null]); // false
- * toBooleanContentDeep([0, "", 5]);    // true
- * toBooleanContentDeep({ a: 0 });      // false
- * toBooleanContentDeep({ a: 1 });      // true
- * toBooleanContentDeep({ a: { b: [] }}); // false
- * toBooleanContentDeep({ a: { b: "x" }}); // true
- */
-declare const toBooleanContentDeep:(value?:unknown)=>boolean;
-/** ---------------------------------
- * * ***Converts a value into a strict boolean.***
- * ---------------------------------
- *
- * This function checks if the input is a valid representation of `true`
- * (e.g., `"true"`, `"on"`, `"yes"`, `"1"`, `1`, `true`, `"indeterminate"`).
- * Any other value, including `undefined` and `null`, 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`.
- * @returns {boolean} `true` if the value matches a truthy representation, otherwise `false`.
- *
- * @example
- * toBooleanExplicit(true) // true
- * toBooleanExplicit("on") // true
- * toBooleanExplicit("Yes") // false
- * toBooleanExplicit(" YES ", { trimString: false }) // false
- * toBooleanExplicit(" YES ", { trimString: true, caseInsensitive: true }) // true
- * toBooleanExplicit(" YES ", { trimString: true, caseInsensitive: false }) // false
- * toBooleanExplicit("yes", { caseInsensitive: false }) // true
- * toBooleanExplicit("1") // true
- * toBooleanExplicit(1) // true
- * toBooleanExplicit(0) // false
- * toBooleanExplicit("off") // false
- */
-declare const toBooleanExplicit:(value?:unknown,options?:{
-/** Whether string comparison ignores case. Default: `false`.
-	 *
-	 * @default false
-	 */
-caseInsensitive?:boolean;
-/** Whether to trim whitespace before comparison. Default: `true`.
-	 *
-	 * @default true
-	 */
-trimString?:boolean;})=>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;
-/** * ----------------------------------------------------------
- * * ***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 `null`, `undefined`, or results in no digits,
- *    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("123abc456"); // ➔ 123456
- * extractDigits("$1,234.56"); // ➔ 123456
- * extractDigits("9A8B7C6");   // ➔ 9876
- * extractDigits("abc");       // ➔ 0
- * extractDigits(undefined);   // ➔ 0
- * extractDigits(null);        // ➔ 0
- * extractDigits(12345);       // ➔ 12345
- * extractDigits("   00a  ");  // ➔ 0
- */
-declare const extractDigits:(value?:string | number | null)=>number;
-/** -------------------------------------------------------------
- * * Parses a human-friendly currency string into a JavaScript number.
- * -------------------------------------------------------------
- *
- * 🚀 Supports multi-locale formats:
- *
- *   - European:     "15.000,10"       ➔ 15300.10
- *   - 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
- *   - 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, ., ,, ', spaces.
- *   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.
- *
- * 📦 Examples of input ➔ output:
- * @example
- * 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
- *
- * @description
- * * Notes:
- *   - 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.
- */
-declare const parseCurrencyString:(input?:string | null)=>number;
-/** ----------------------------------------------------------
- * * ***Converts a value from a string to its natural JavaScript type.***
- * ----------------------------------------------------------
- *
- * ✅ Supported conversions:
- * - `"true"`      → `true`
- * - `"false"`     → `false`
- * - `"null"`      → `null`
- * - `"undefined"` → `undefined`
- * - `"42"`        → `42` (number)
- * - `"3.14"`      → `3.14` (number)
- * - `"3,567,890.14"`      → `3567890.14` (number)
- * - `"   "`       → `""` (trimmed)
- * - Other strings are returned trimmed & lowercased.
- * - Non-string inputs are returned unchanged.
- *
- * @example
- * convertType("true")       // → true
- * convertType(" 42 ")       // → 42
- * convertType("FALSE")      // → false
- * convertType(" null ")     // → null
- * convertType("   ")        // → ""
- * convertType(100)          // → 100
- * convertType({})           // → {}
- *
- * @param {any} value - The value to convert (usually string or unknown type).
- * @returns {any} The converted JavaScript type (boolean, number, null, undefined, or original).
- */
-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;interface CleanParsedDataOptions{
-/** Convert numeric strings to numbers (e.g., `"42"` → `42`).
-	 *
-	 * @default false
-	 */
-convertNumbers?:boolean;
-/** Convert `"true"` / `"false"` strings to boolean values.
-	 *
-	 * @default false
-	 */
-convertBooleans?:boolean;
-/** Convert valid date strings into `Date` objects.
-	 *
-	 * @default false
-	 */
-convertDates?:boolean;
-/** Custom date formats to be parsed (e.g., `["DD/MM/YYYY", "MM/DD/YYYY"]`).
-	 *
-	 * @default []
-	 */
-customDateFormats?:string[];
-/** Remove `null` values from objects and arrays.
-	 *
-	 * @default false
-	 */
-removeNulls?:boolean;
-/**
-	 * Remove `undefined` values from objects and arrays.
-	 *
-	 * - `false` (default): replaces `undefined` with `null`
-	 * - `true`: removes keys with `undefined` values
-	 */
-removeUndefined?:boolean;
-/** Remove empty objects `{}` from the final output.
-	 *
-	 * @default false
-	 */
-removeEmptyObjects?:boolean;
-/** Remove empty arrays `[]` from the final output.
-	 *
-	 * @default false
-	 */
-removeEmptyArrays?:boolean;
-/** Strict mode: Removes values that do not match selected conversions.
-	 *
-	 * @default false
-	 */
-strictMode?:boolean;
-/** Enable error logging if JSON parsing fails.
-	 *
-	 * @default false
-	 */
-loggingOnFail?:boolean;
-/** Custom error handler function.
-	 *
-	 * @default undefined
-	 */
-onError?:(error:unknown)=>void;}
-/** --------------------------------------------------
- * * ***Cleans parsed JSON data based on provided options.***
- * --------------------------------------------------
- *
- * @template T - Expected output type.
- * @param {unknown} data - The parsed JSON data.
- * @param {CleanParsedDataOptions} options - Cleaning options.
- * @returns {T | undefined} - The cleaned data.
- *
- * **Note: If using `convertDates`, result may contain Date objects. You may need type assertions in strict TypeScript settings.**
- *
- * @example
- * // Convert numbers and remove nulls
- * const result = cleanParsedData({ age: "25", name: null }, { convertNumbers: true, removeNulls: true });
- * console.log(result); // Output: { age: 25 }
- *
- * @example
- * // Convert boolean strings
- * const result = cleanParsedData({ isActive: "true" }, { convertBooleans: true });
- * console.log(result); // Output: { isActive: true }
- */
-declare const cleanParsedData:<T=unknown>(data:T,options?:CleanParsedDataOptions)=>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
- *
- *    safeJsonParse('{"name": "John", "score": undefined}');
- *    // result → { name:"John", score:null } ← because `undefined` is not valid JSON, gets replaced
- *    ```
- *    Therefore, if you see `undefined` in raw input, it will likely throw unless pre-cleaned or replaced with `null`.
- * @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 {CleanParsedDataOptions} [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('{"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. ***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 }
- *  ```
- *
- * 4. ***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") }
- *  ```
- *
- * 5. ***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
- *  ```
- *
- * 6. ***Null or non-string input returns null/undefined:***
- *  ```ts
- *    safeJsonParse(null); // → null
- *    safeJsonParse(undefined); // → undefined
- *    safeJsonParse(123); // → undefined
- *  ```
- *
- * 7. ***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?:CleanParsedDataOptions):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?:CleanParsedDataOptions):SafeJsonParseResult<TData,TInput>;type Prev=[never,RangeNumberTo999<1,40>];type DotPath<T,Prefix extends string="",Depth extends number=RangeNumberTo999<1,40>>=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>={key:DotPath<T>;deep?:boolean;};
-/** ------------------------------------------------------------------------
- * * ***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).
- * - 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).
- * - Can delete nested properties safely without throwing even if intermediate objects are missing.
- *
- * 🚀 Edge Handling:
- * - Ignores invalid intermediate objects (will just skip that branch).
- * - If `object` is `null` or not an object, returns an empty object.
- * - Throws if `keysToDelete` is not a proper array of `{ key, deep? }` objects.
- *
- * @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.
- * @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 `object` is not an object.
- *   - 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
- * // 🚫 Invalid usage throws
- * removeObjectPaths(42, [{ key: "a" }]);
- * // => throws TypeError
- */
-declare const removeObjectPaths:<T extends Record<string,unknown>>(object:T,keysToDelete:ConfigRemoveObjectPaths<T>[],deepClone?:boolean)=>Partial<T>;
-/** --------------------------------------------
- * * ***Safely converts a JavaScript value into a stable, JSON-compatible string.***
- * --------------------------------------------
- *
- * Features:
- * - Recursively sorts object keys if `sortKeys` is true, to ensure stable key order.
- * - Optionally sorts array values if `ignoreOrder` is true (only sorts shallow primitives inside arrays).
- * - Removes functions and symbols (they are omitted from the output).
- * - Converts `undefined`, `NaN`, `Infinity`, `-Infinity` to `null`.
- * - Converts `BigInt` to a string (since JSON does not support it).
- * - Handles circular references by replacing them with the string `"[Circular]"`.
- * - Serializes:
- *   - `Date` instances as ISO strings.
- *   - `Map` as `{ map: [ [key, value], ... ] }`.
- *   - `Set` as `{ set: [values...] }`.
- *
- * 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
- *   The value to serialize. Can be primitives, objects, arrays, Maps, Sets, Dates, etc.
- *
- * @param {boolean} [sortKeys=true]
- *   Whether to sort object keys alphabetically (recursively). If `false`, preserves original insertion order.
- *
- * @param {boolean} [ignoreOrder=false]
- *   Whether to sort array primitive values. When `true`:
- *   - Only primitive values in arrays are sorted.
- *   - Objects and nested arrays keep their position and are placed after sorted primitives.
- *   If `false`, arrays retain their original order.
- *
- * @param {boolean} [pretty=false]
- *   If `true`, output is formatted with 2-space indentation and newlines (pretty-printed).
- *   If `false`, produces compact single-line JSON.
- *
- * @returns {string}
- *   A stable JSON string representation of the input value.
- *
- * @throws {TypeError}
- *   Throws if `sortKeys`, `ignoreOrder`, or `pretty` are not strictly boolean.
- *
- * @example
- * // Basic object key sorting
- * safeStableStringify({ b: 2, a: 1 });
- * // => '{"a":1,"b":2}'
- *
- * @example
- * // Disable key sorting (preserve insertion order)
- * safeStableStringify({ b: 2, a: 1 }, false);
- * // => '{"b":2,"a":1}'
- *
- * @example
- * // Sorting arrays
- * safeStableStringify([3, 1, 2], true, true);
- * // => '[1,2,3]'
- *
- * @example
- * // Nested object + ignoreOrder=true
- * safeStableStringify({ z: [3, 1, 2], x: { d: 4, c: 3 } }, true, true);
- * // => '{"x":{"c":3,"d":4},"z":[1,2,3]}'
- *
- * @example
- * // sortKeys=false and ignoreOrder=true
- * safeStableStringify({ z: [3, 1, 2], x: { d: 4, c: 3 } }, false, true);
- * // => '{"z":[1,2,3],"x":{"d":4,"c":3}}'
- *
- * @example
- * // pretty print output
- * safeStableStringify([3, 1, 2], true, true, true);
- * // => `[
- * //   1,
- * //   2,
- * //   3
- * // ]`
- *
- * @example
- * // 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"}'
- *
- * @example
- * // Functions and symbols are removed
- * safeStableStringify({ f: () => {}, s: Symbol("wow") });
- * // => '{}'
- *
- * @example
- * // undefined, NaN, Infinity convert to null
- * safeStableStringify([undefined, NaN, Infinity, -Infinity]);
- * // => '[null,null,null,null]'
- *
- * @example
- * // Circular reference
- * const obj = { name: "A" };
- * obj.self = obj;
- * safeStableStringify(obj);
- * // => '{"name":"A","self":"[Circular]"}'
- *
- * @example
- * // Complex nested ignoreOrder with objects
- * const arr = [9, 7, [4, 2, 3], { z: [5, 1, 6] }];
- * safeStableStringify(arr, true, true);
- * // => '[7,9,[2,3,4],{"z":[1,5,6]}]'
- */
-declare const safeStableStringify:(value:unknown,sortKeys?:boolean,ignoreOrder?:boolean,pretty?:boolean)=>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 const toStringDeepForce:(value:unknown,forceToString:false | "stringOrNumber" | "primitives" | "all")=>unknown;type ConvertedDeepNumber<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean>=T extends null | undefined ? never:T extends number | `${number}` ? number:T extends any[] ? ConvertedDeepNumber<T[number],RemoveEmptyObjects,RemoveEmptyArrays>[]:T extends Record<string,unknown>?{[K in keyof T]:ConvertedDeepNumber<T[K],RemoveEmptyObjects,RemoveEmptyArrays>;}extends infer O ? RemoveEmptyObjects extends true ? keyof O extends never ? never:O:O:never:never;
-/** --------------------------------------------------
- * * ***Converts deeply nested arrays or objects into number while preserving structure.***
- * --------------------------------------------------
- *
- * Features:
- * - ✅ Removes `null`, `undefined`, NaN, Infinity, and non-numeric values.
- * - 🔄 Recursively processes nested objects and arrays.
- * - 🔢 Converts valid number, including decimals (e.g. `"3.5"` → `3.5`).
- * - 🧹 Can remove empty objects `{}` or arrays `[]` based on flags.
- *
- * @template T - The input data type (Array, Object, etc)
- * @template RemoveEmptyObjects - Whether to remove empty objects
- * @template RemoveEmptyArrays - Whether to remove empty arrays
- *
- * @param {T} input - The data to convert
- * @param {boolean} [removeEmptyObjects=false] - Remove empty objects `{}` if `true`
- * @param {boolean} [removeEmptyArrays=false] - Remove empty arrays `[]` if `true`
- *
- * @returns {ConvertedDeepNumber<T, RemoveEmptyObjects, RemoveEmptyArrays> | undefined}
- *          The transformed data, or `undefined` if entirely empty after processing.
- *
- * @example
- * toNumberDeep("123") // → 123
- * toNumberDeep("12.34") // → 12.34
- * toNumberDeep("not number") // → undefined
- *
- * @example
- * toNumberDeep([NaN, Infinity, -Infinity, "10"])
- * // → [10]
- *
- * @example
- * toNumberDeep({ a: {}, b: [] }, false, false)
- * // → { a: {}, b: [] }
- *
- * @example
- * toNumberDeep({ a: {}, b: [] }, true, false)
- * // → { b: [] }
- *
- * @example
- * toNumberDeep({ a: {}, b: [] }, false, true)
- * // → { a: {} }
- *
- * @example
- * toNumberDeep({ a: {}, b: [], c: { d: null } }, true, true)
- * // → {}
- *
- * @example
- * toNumberDeep({
- *   a: "1",
- *   b: {
- *     c: "not num",
- *     d: ["2", "3.5", null, { e: "4.4", f: "invalid" }],
- *   },
- *   g: [],
- * })
- * // → { a: 1, b: { d: [2, 3.5, { e: 4.4 }] }, g: [] }
- *
- * @example
- * toNumberDeep({ x: {}, y: [], z: [{ a: {}, b: [] }] }, false, true)
- * // → { x: {}, z: [{ a: {} }] }
- *
- * @example
- * toNumberDeep({ x: {}, y: [], z: [{ a: {}, b: [] }] }, true, false)
- * // → { y: [], z: [{ b: [] }] }
- *
- * @example
- * toNumberDeep({
- *   x: {},
- *   y: [],
- *   z: [{ a: {}, b: [], c: "3" }, { d: "4.5" }]
- * }, true, true)
- * // → { z: [{ c: 3 }, { d: 4.5 }] }
- *
- * @example
- * toNumberDeep([[[[[["1"]]], null]], "2", "abc"], false, true)
- * // → [[[[[[1]]]]], 2]
- *
- * @example
- * toNumberDeep(["1", {}, [], ["2", {}, []]], true, true)
- * // → [1, [2]]
- *
- * @example
- * toNumberDeep(["1", () => {}, Symbol("wow"), "2"])
- * // → [1, 2]
- *
- * @example
- * toNumberDeep({ a: { b: {} } }, false, true)
- * // → { a: { b: {} } }
- *
- * @example
- * toNumberDeep(["1", { a: {} }], true)
- * // → [1]
- *
- * @example
- * toNumberDeep(["1", { a: {} }], false)
- * // → [1, { a: {} }]
- *
- * @example
- * toNumberDeep(["1", [], { a: [] }], false, false)
- * // → [1, [], { a: [] }]
- */
-declare const toNumberDeep:<T extends unknown,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>(input:T,removeEmptyObjects?:RemoveEmptyObjects,removeEmptyArrays?:RemoveEmptyArrays)=>ConvertedDeepNumber<T,RemoveEmptyObjects,RemoveEmptyArrays>| undefined;type ConvertedDeepString<T,RemoveEmptyObjects extends boolean,RemoveEmptyArrays extends boolean>=T extends null | undefined ? never:T extends number | string ? string:T extends any[] ? ConvertedDeepString<T[number],RemoveEmptyObjects,RemoveEmptyArrays>[]:T extends Record<string,unknown>?{[K in keyof T]:ConvertedDeepString<T[K],RemoveEmptyObjects,RemoveEmptyArrays>;}extends infer O ? RemoveEmptyObjects extends true ? keyof O extends never ? never:O:O:never:never;
-/**
- * --------------------------------------------------
- * * ***Converts all values in an array, object, or deeply nested structure to string.***
- * --------------------------------------------------
- *
- * - ✅ Converts number and string to string format (e.g., `123 → "123"`).
- * - ✅ Keeps existing string as string.
- * - ✅ Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.
- * - ✅ Removes non-primitive types like functions, symbols, and bigints.
- * - ✅ Processes deeply nested arrays and objects.
- * - ✅ Supports removing empty objects `{}` and empty arrays `[]` via flags.
- *
- * @template T - The input data type (array, object, or any nested combination).
- * @template RemoveEmptyObjects - If `true`, empty objects `{}` will be removed recursively.
- * @template RemoveEmptyArrays - If `true`, empty arrays `[]` will be removed recursively.
- *
- * @param {T} input - The input array, object, or value to convert.
- * @param {boolean} [removeEmptyObjects=false] - Whether to remove empty objects `{}`.
- * @param {boolean} [removeEmptyArrays=false] - Whether to remove empty arrays `[]`.
- *
- * @returns {ConvertedDeepString<T, RemoveEmptyObjects, RemoveEmptyArrays> | undefined}
- *          The converted data structure with all values as string, or `undefined` if completely empty.
- *
- * @example
- * // Simple array conversion
- * toStringDeep([1, "2", 3])
- * // → ["1", "2", "3"]
- *
- * @example
- * // Nested arrays
- * toStringDeep([1, ["2", [3, [null, "4"]]]])
- * // → ["1", ["2", ["3", ["4"]]]]
- *
- * @example
- * // Object with nested values
- * toStringDeep({ a: 1, b: "2", c: { d: 3, e: null } })
- * // → { a: "1", b: "2", c: { d: "3" } }
- *
- * @example
- * // Removing empty objects
- * toStringDeep({ a: {}, b: "1" }, true, false)
- * // → { b: "1" }
- *
- * @example
- * // Removing empty arrays
- * toStringDeep(["1", [], { a: [] }], false, true)
- * // → ["1", { a: [] }]
- *
- * @example
- * // Removing both empty objects and arrays deeply
- * toStringDeep({ a: {}, b: [], c: [{ d: {}, e: [] }, "1"] }, true, true)
- * // → { c: ["1"] }
- *
- * @example
- * // Fully empty structure after processing becomes undefined
- * toStringDeep([null, undefined, {}], true, true)
- * // → undefined
- */
-declare const toStringDeep:<T extends unknown,RemoveEmptyObjects extends boolean=false,RemoveEmptyArrays extends boolean=false>(input:T,removeEmptyObjects?:RemoveEmptyObjects,removeEmptyArrays?:RemoveEmptyArrays)=>ConvertedDeepString<T,RemoveEmptyObjects,RemoveEmptyArrays>| undefined;type ValueFormatPhoneNumber=string | number | null;type FormatPhoneNumberProps={
-/** @default " " */
-separator?:string;
-/** @default "" */
-plusNumberCountry?:string;
-/** @default "" */
-openingNumberCountry?:string;
-/** @default "" */
-closingNumberCountry?:string;
-/** @default false */
-checkValidOnly?:boolean;
-/** @default false */
-takeNumberOnly?:boolean;};type FormatPhoneNumberPropsString=OmitStrict<FormatPhoneNumberProps,"checkValidOnly" | "takeNumberOnly">&{
-/** @default false */
-checkValidOnly?:false;
-/** @default false */
-takeNumberOnly?:false;};type FormatPhoneNumberPropsBoolean=OmitStrict<FormatPhoneNumberProps,"separator" | "plusNumberCountry" | "closingNumberCountry" | "openingNumberCountry" | "takeNumberOnly">;type FormatPhoneNumberPropsTransform=OmitStrict<FormatPhoneNumberProps,"separator" | "plusNumberCountry" | "closingNumberCountry" | "openingNumberCountry" | "checkValidOnly">;type ScrollToTopOptions={
-/** `"auto" | "instant" | "smooth"` defaults value `"smooth"` */
-behavior?:ScrollBehavior | undefined;
-/** `number | undefined` defaults value `1` as `ms` */
-timeout?:number | undefined;};type RandomStringOptions={
-/** Ensures no whitespace characters in the generated string. Default: `true`. */
-avoidWhiteSpace?:boolean;
-/** Custom characters to replace the default number set if `type` is "number". */
-replaceGenInt?:string;
-/** Custom characters to replace the default string set if `type` is "string". */
-replaceGenStr?:string;
-/** Additional characters to include in the generated string. */
-addChar?:string;
-/** Minimum length of the generated string (1 to 5000). Default: `40`. */
-minLength?:number;
-/** Maximum length of the generated string (1 to 5000). Default: `40`. */
-maxLength?:number;
-/** Type of output: "string" (default) or "number". */
-type?:"string" | "number";};
-/** ----------------------------------------------------------
- * * ***Disables user interaction by adding a CSS class to the `<html>` element.***
- * ----------------------------------------------------------
- *
- * - Works only in **browser environments** (does nothing on the server-side).
- * - Prevents multiple additions of the same class.
- * - Can be used to indicate that a process is ongoing (e.g., loading state).
- *
- * @param {string} className - The CSS class to add (default: `"on_processing"`).
- * @returns {void}
- *
- * @example
- * disableUserInteraction(); // Adds "on_processing" class to <html>
- * disableUserInteraction("loading"); // Adds "loading" class to <html>
- */
-declare const disableUserInteraction:(className?:string)=>void;
-/** ----------------------------------------------------------
- * * ***Enables user interaction by removing a CSS class from the `<html>` element.***
- * ----------------------------------------------------------
- *
- * - Works only in **browser environments** (does nothing on the server-side).
- * - Prevents errors if the class is already removed.
- * - Can be used to re-enable interactions after a process completes.
- *
- * @param {string} className - The CSS class to remove (default: `"on_processing"`).
- * @returns {void}
- *
- * @example
- * enableUserInteraction(); // Removes "on_processing" class from <html>
- * enableUserInteraction("loading"); // Removes "loading" class from <html>
- */
-declare const enableUserInteraction:(className?:string)=>void;
-/** ----------------------------------------------------------
- * * ***Removes focus from the currently active element.***
- * ----------------------------------------------------------
- *
- * - Works only in **browser environments** (does nothing on the server-side).
- * - If an element is focused, it will lose focus.
- * - Logs a warning if no element is focused.
- *
- * @returns {void}
- *
- * @example
- * removeElementFocus(); // Removes focus from an active currently element.
- */
-declare const removeElementFocus:()=>void;
-/** ----------------------------------------------------------
- * * ***Scrolls the page to the top with default smooth and extra optional settings.***
- * ----------------------------------------------------------
- *
- * - Works only in **browser environments** (does nothing on the server).
- * - Supports a **timeout delay** before scrolling.
- * - Uses the **native `window.scrollTo()`** API with smooth scrolling.
- *
- * @param {ScrollToTopOptions} [options] - Scrolling behavior options.
- * @param {ScrollBehavior} [options.behavior="smooth"] - The scroll behavior (`"auto"`,`"instant"` or `"smooth"`), default value is `"smooth"`.
- * @param {number} [options.timeout=1] - Delay (in milliseconds) before scrolling starts.
- * @returns {void}
- *
- * @example
- * smoothScrollToTop(); // Scrolls to top smoothly with 1ms delay
- * smoothScrollToTop({ behavior: "auto" }); // Instantly jumps to the top
- * smoothScrollToTop({ timeout: 500 }); // Scrolls to top after 500ms
- */
-declare const scrollToTop:(options?:ScrollToTopOptions)=>void;type NegativeFormatOption="dash" | "brackets" | "abs" |{
-/**
-	 * Custom formatter function for the final formatted negative string.
-	 * If provided, it OVERRIDES style & space entirely.
-	 */
-custom:(formatted:string)=>string;style?:never;space?:never;}|{custom?:never;
-/**
-	 * Use style & optional spacing for negative numbers.
-	 * @default "dash"
-	 */
-style?:"dash" | "brackets" | "abs";
-/** @default false */
-space?:boolean;};type FormatCurrencyOptions={
-/** `Default: "."` */
-suffixCurrency?:string;
-/** `Default: "."` */
-separator?:string;
-/** `Default: false` */
-decimal?:boolean;
-/** `Default: 2` */
-totalDecimal?:number;
-/** `Default: true` */
-endDecimal?:boolean;
-/** `Default: ""` */
-suffixDecimal?:string;
-/** `Default: "round"` */
-roundedDecimal?:"round" | "ceil" | "floor" | false;
-/** `Default: ","` */
-separatorDecimals?:string;
-/** @default "dash" */
-negativeFormat?:NegativeFormatOption;
-/** @default false */
-indianFormat?:boolean;};
-/** -------------------------------------------------------
- * * Formats a number or messy currency string into a
- *   beautifully formatted currency string, with highly
- *   customizable separators, decimal control, rounding,
- *   currency symbols, and negative styling.
- * -------------------------------------------------------
- *
- * ✅ Highlights:
- * - Accepts:
- *   * Pure numbers: `15300.95`
- *   * Messy currency strings from **any locale**:
- *     - `"Rp 15.000,21"` (Indonesian / Euro)
- *     - `"$12,345.60"` (US)
- *     - `"CHF 12'345.60"` (Swiss)
- *     - `"1,23,456.78"` (Indian)
- * - Auto extracts numeric value with smart multi-locale parsing
- *   via `parseCurrencyString`.
- * - Handles:
- *   * Thousands separators: `.`, `,`, `'`, ` `
- *   * Decimal separators: `,`, `.`
- *   * Decimal suffix (eg. `".-"`, `" USD"`)
- *   * Currency prefix (eg. `"Rp "`, `"$ "`)
- *   * Rounding: `"round"`, `"ceil"`, `"floor"`, or truncate
- *   * Negative styling: dash `-`, brackets `( )`, absolute, or custom
- * - Strong type checks & clear errors for misconfigured options.
- *
- * ✅ How input is parsed:
- * - Removes all non-digit except `.`, `,`, `'` and spaces.
- * - Detects bracket negatives: `"(15.000,10)"` ➔ `-15000.10`
- * - Uses last `,` or `.` as decimal separator (others are thousands).
- * - Ignores currency symbols like `Rp`, `$` (must re-apply with `suffixCurrency`).
- *
- * ✅ Options:
- * @param {string|number} value
- *   The input value to format.
- *   Examples:
- *     * `"Rp 15.000,21"`
- *     * `"$12,345.60"`
- *     * `"CHF 12'345.60"`
- *     * `15300.95`
- *
- * @param {FormatCurrencyOptions} [options]
- *   Optional configuration object:
- *
- *   @property {string} separator
- *     Thousands separator (default `"."`).
- *     Example: `"."` ➔ `1.000.000`
- *
- *   @property {string} separatorDecimals
- *     Decimal separator (default `","`).
- *     Example: `","` ➔ `1.000,10`
- *
- *   @property {string} suffixCurrency
- *     Prefix currency string (default `""`).
- *     Does **not auto-keep input symbols**.
- *     Must set manually: `suffixCurrency: "Rp "`.
- *
- *   @property {boolean} decimal
- *     Show decimals? (default `false`).
- *     If `false`, rounds to integer.
- *
- *   @property {number} totalDecimal
- *     Total decimal digits (default `2`).
- *     If `decimal: true` & `roundedDecimal: false`, simply cuts.
- *
- *   @property {string} suffixDecimal
- *     Text appended after decimals
- *     (e.g. `".-"`, `" USD"`). Default `""`.
- *
- *   @property {boolean} endDecimal
- *     Actually append `suffixDecimal`? (default `true`).
- *
- *   @property {"round"|"ceil"|"floor"|false} roundedDecimal
- *     Rounding mode:
- *       - `"round"` ➔ nearest
- *       - `"ceil"` ➔ always up
- *       - `"floor"` ➔ always down
- *       - `false` ➔ truncate
- *     Default `"round"`.
- *
- *   @property {"dash"|"brackets"|"abs"|{style?, space?, custom?}} negativeFormat
- *     How to format negatives:
- *       - `"dash"` ➔ `-15.000`
- *       - `"brackets"` ➔ `(15.000)`
- *       - `"abs"` ➔ `15.000` (always positive)
- *       - or object:
- *         {
- *            style: "dash"|"brackets"|"abs",
- *            space: true|false,
- *            custom: (formatted) => string
- *         }
- *     Default `"dash"`.
- *
- *   @property {boolean} indianFormat
- *     If `true`, formats as Indian: `12,34,567`.
- *     Also forces `separator: ","`, `separatorDecimals: "."`.
- *
- * @returns {string}
- *   Nicely formatted currency string.
- *   Examples:
- *     - `"15.000,10"`
- *     - `"Rp 15.000,10.-"`
- *     - `"15'000.10 USD"`
- *     - `"12,34,567.89"`
- *
- * @throws {TypeError}
- *   If:
- *     - `value` is not string or number
- *     - cannot parse to valid number
- *     - options have invalid types
- *
- * ---
- *
- * ***✅ Notes:***
- * - Always re-apply symbols via `suffixCurrency`.
- * - `parseCurrencyString` smartly detects last decimal,
- *   so `"1.121.234,56"` and `"1,121,234.56"` both parsed correctly.
- */
-declare const formatCurrency:(value:string | number,options?:FormatCurrencyOptions)=>string;
-/** ----------------------------------------------------------
- * * ***Formats a number or numeric string by adding a custom separator
- * every three digits (thousands separator), and intelligently
- * flips the decimal separator according to the chosen separator.***
- * ----------------------------------------------------------
- *
- * - Converts a number to string before formatting.
- * - Defaults to using `,` as the thousands separator.
- * - If `.` is used as the separator, the decimal will automatically become `,`, and vice versa.
- * - Handles input with existing formatting (e.g. "1,234,567.89") and normalizes it.
- * - Supports custom separators, including spaces.
- * - Preserves decimals even if more than 2 digits.
- *
- * @param {string | number} value - The numeric value or string to format.
- *   Can be plain numbers, or already formatted strings like "1,234,567.89".
- * @param {string} [separator=","] - The thousands separator to use.
- *   Examples: "," (default), ".", " ", etc.
- *
- * @returns {string} The formatted string with thousands separators and
- *   appropriate decimal separator.
- *
- * @example
- * formatNumber(1000000);
- * // → "1,000,000"
- *
- * formatNumber("987654321");
- * // → "987,654,321"
- *
- * formatNumber(1234567.89);
- * // → "1,234,567.89"
- *
- * formatNumber("1234567,89");
- * // → "1,234,567.89"
- *
- * formatNumber("1234567.892");
- * // → "1,234,567.892"
- *
- * formatNumber("1234567.89", ".");
- * // → "1.234.567,89"
- *
- * formatNumber("1234567,89", ",");
- * // → "1,234,567.89"
- *
- * formatNumber("987654321", " ");
- * // → "987 654 321"
- *
- * formatNumber("1,234,567.89");
- * // → "1,234,567.89"
- *
- * formatNumber("1.234.567,89", ",");
- * // → "1,234,567.89"
- *
- * formatNumber("1.234.567,893", ".");
- * // → "1.234.567,893"
- *
- * formatNumber("1234.56", ".");
- * // → "1.234,56"
- *
- * formatNumber("1234,56", ",");
- * // → "1,234.56"
- *
- * @throws {TypeError} If `value` is not a string or number,
- * or `separator` is not a string.
- */
-declare const formatNumber:(value:string | number,separator?:string)=>string;
-/** -------------------------------------------------------
- * * ***Formats a phone number into a customizable local or international style.***
- * -------------------------------------------------------
- *
- * Can also:
- * - Return only digits (`takeNumberOnly`).
- * - Check validity (`checkValidOnly`) using a regex for international-style phone numbers.
- *
- * Validation (`checkValidOnly: true`)
- * Valid if:
- * - Only contains digits, optional leading `+`, spaces, parentheses `()`, hyphens `-`, or dots `.`.
- * - Digits-only length < 24.
- *
- * Example:
- * ```js
- * formatPhoneNumber("081234567890")
- * // => "0812 3456 7890"
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("(0812) 3456-7890", { takeNumberOnly: true })
- * // => "081234567890"
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("(0812) 3456-7890", { checkValidOnly: true })
- * // => true
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("+6281234567890", { checkValidOnly: true })
- * // => true
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("+1 (800) 123-4567", { checkValidOnly: true })
- * // => true
- * formatPhoneNumber("+44 20 7946 0958", { checkValidOnly: true })
- * // => true
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("0812-3456-7890", { checkValidOnly: true })
- * // => true
- * formatPhoneNumber("(0812) 3456 7890", { checkValidOnly: true })
- * // => true
- * formatPhoneNumber("0812 3456 7890", { checkValidOnly: true })
- * // => true
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("+62abc123", { checkValidOnly: true })
- * // => false
- * formatPhoneNumber("0812-3456-hello", { checkValidOnly: true })
- * // => false
- * formatPhoneNumber("+62 123456789012345678901234", { checkValidOnly: true })
- * // => false
- * formatPhoneNumber("++6281234567890", { checkValidOnly: true })
- * // => false
- * formatPhoneNumber("invalid@@@", { checkValidOnly: true })
- * // => false
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("+62.812.3456.7890", { checkValidOnly: true })
- * // => true
- * formatPhoneNumber("+62(812)3456-7890", { checkValidOnly: true })
- * // => true
- * ```
- *
- * Example:
- * ```js
- * formatPhoneNumber("081234567890", {
- *   separator: "-",
- *   plusNumberCountry: "+44",
- *   openingNumberCountry: "(",
- *   closingNumberCountry: ")",
- * })
- * // => "(+44) 8123-4567-890"
- * ```
- *
- * @throws {TypeError} If `value` is not string, number, null or undefined.
- * @throws {TypeError} If `options` is not an object or contains wrong types.
- *
- * @overload
- * @param value The phone number input (string or number).
- * @param options With `checkValidOnly: true`.
- * @returns A boolean indicating whether the input is a valid phone number.
- *
- * @overload
- * @param value The phone number input (string or number).
- * @param options With `takeNumberOnly: true`.
- * @returns A string of digits only.
- *
- * @overload
- * @param value The phone number input (string or number).
- * @param options Options to customize format output (country code, separator, etc).
- * @returns A formatted phone number string.
- */
-declare function formatPhoneNumber(value?:ValueFormatPhoneNumber,options?:FormatPhoneNumberPropsString):string;declare function formatPhoneNumber(value?:ValueFormatPhoneNumber,options?:FormatPhoneNumberPropsBoolean):boolean;declare function formatPhoneNumber(value?:ValueFormatPhoneNumber,options?:FormatPhoneNumberPropsTransform):string;type SupportedLocales="en-US" | "en-GB" | "en-AU" | "en-CA" | "en-NZ" | "en-ZA" | "en-IN" | "en-IE" | "en-SG" | "en-HK" | "en-PH" | "en-MY" | "en-PK" | "en-KE" | "en-TZ" | "en-NG" | "en-LK" | "en-BW" | "en-ZM" | "id-ID" | "ms-MY" | "th-TH" | "vi-VN" | "tl-PH" | "ms-BN" | "zh-CN" | "zh-HK" | "zh-TW" | "zh-SG" | "zh-MO" | "ja-JP" | "ko-KR" | "fr-FR" | "fr-CA" | "fr-BE" | "fr-CH" | "fr-LU" | "fr-MA" | "fr-SN" | "fr-CM" | "fr-CI" | "fr-HT" | "fr-DZ" | "fr-TN" | "fr-ML" | "fr-NC" | "fr-PF" | "fr-GP" | "fr-MQ" | "fr-GF" | "de-DE" | "de-AT" | "de-CH" | "de-LU" | "de-LI" | "es-ES" | "es-MX" | "es-AR" | "es-CL" | "es-CO" | "es-PE" | "es-UY" | "es-VE" | "es-CR" | "es-EC" | "es-GT" | "es-HN" | "es-NI" | "es-PA" | "es-PR" | "es-SV" | "es-BO" | "es-PY" | "es-DO" | "es-CU" | "es-GQ" | "pt-BR" | "pt-PT" | "pt-MZ" | "pt-AO" | "pt-GW" | "pt-CV" | "pt-ST" | "it-IT" | "it-CH" | "it-SM" | "it-VA" | "nl-NL" | "nl-BE" | "nl-SR" | "nl-AW" | "nl-CW" | "ru-RU" | "uk-UA" | "kk-KZ" | "uz-UZ" | "ky-KG" | "tt-RU" | "ba-RU" | "cv-RU" | "sah-RU" | "pl-PL" | "cs-CZ" | "sk-SK" | "hu-HU" | "sl-SI" | "sv-SE" | "da-DK" | "no-NO" | "fi-FI" | "is-IS" | "ro-RO" | "bg-BG" | "hr-HR" | "sr-RS" | "mk-MK" | "bs-BA" | "me-ME" | "sq-AL" | "sq-XK" | "el-GR" | "el-CY" | "tr-TR" | "tr-CY" | "he-IL" | "ar-SA" | "ar-AE" | "ar-EG" | "ar-MA" | "ar-JO" | "ar-LB" | "ar-QA" | "ar-KW" | "ar-OM" | "ar-BH" | "ar-IQ" | "ar-LY" | "ar-TN" | "ar-YE" | "ar-SY" | "ar-PS" | "ar-SD" | "ar-DZ" | "ar-MR" | "ar-DJ" | "ar-SO" | "lt-LT" | "lv-LV" | "et-EE" | "hi-IN" | "bn-BD" | "pa-IN" | "ta-IN" | "te-IN" | "ml-IN" | "gu-IN" | "kn-IN" | "mr-IN" | "or-IN" | "as-IN" | "ne-IN" | "fa-IR" | "ur-PK" | "ps-AF" | "dv-MV" | "sw-KE" | "sw-TZ" | "zu-ZA" | "af-ZA" | "xh-ZA" | "ss-SZ" | "ts-ZA" | "tn-BW" | "ny-MW" | "lo-LA" | "mt-MT" | "ga-IE" | "cy-GB" | "ne-NP" | "si-LK" | "am-ET" | "om-ET" | "ti-ER" | "km-KH" | "my-MM" | "mn-MN" | "tg-TJ" | "tk-TM" | "hy-AM" | "ka-GE" | "az-AZ" | "be-BY" | "mo-MD" | "ro-MD" | "ht-HT" | "jw-ID" | "su-ID" | "to-TO" | "sm-WS" | "mi-NZ" | "bi-VU" | "fj-FJ" | "ty-PF" | "pau-PW" | "niu-NU" | "ck-CK" | "rw-RW" | "ln-CD" | "kg-CD" | "ha-NE" | "yo-NG" | "ig-NG" | "ak-GH" | "lg-UG" | "bo-CN" | "dz-BT" | "iu-CA" | "kl-GL" | "cv-RU" | "pap-AW" | "chr-US" | "haw-US" | "gv-IM" | "gd-GB" | "br-FR" | "co-FR" | "rm-CH" | "wa-BE" | "lb-LU" | "fur-IT" | "sc-IT" | "vec-IT" | "nap-IT" | "gsw-CH" | "rha-CH" |({}& string);
-/** ----------------------------------------------------------
- * * ***Formats a date and time into a custom string format.***
- * ----------------------------------------------------------
- *
- * - Supports only `YYYY`, `MM`, `DD`, `hh`, `mm`, and `ss` as placeholders.
- * - Uses a simple string replace (no locale).
- * - Returns `null` if the date is invalid or not provided.
- * - Defaults to `"YYYY-MM-DD hh:mm:ss"` format if none is specified.
- *
- * @param {string | Date | null} [date] - The date to format.
- * @param {string} [format="YYYY-MM-DD hh:mm:ss"] - The desired date format.
- * @returns {string | null} The formatted date string or `null` if invalid.
- *
- * @example
- * formatDateTime(new Date());
- * // => "2024-02-09 14:30:45" (example output with current time)
- *
- * formatDateTime("2023-07-01T14:30:45");
- * // => "2023-07-01 14:30:45"
- *
- * formatDateTime("2023-07-01T14:30:45", "DD/MM/YYYY");
- * // => "01/07/2023"
- *
- * formatDateTime("2023-07-01T14:30:45", "YYYY/MM/DD hh-mm-ss");
- * // => "2023/07/01 14-30-45"
- *
- * formatDateTime("2023-07-01T14:30:45", "hh:mm");
- * // => "14:30"
- *
- * formatDateTime("2023-07-01T14:30:45", "DATE: YYYY.MM.DD");
- * // => "DATE: 2023.07.01"
- *
- * formatDateTime("2023-07-01T14:30:45", "Year: YYYY, Time: hh:mm:ss");
- * // => "Year: 2023, Time: 14:30:45"
- *
- * formatDateTime("2023-07-01T14:30:45", "YYYY-MM");
- * // => "2023-07"
- *
- * formatDateTime("2023-07-01T14:30:45", "YYYYYYYY");
- * // => "20232023"
- *
- * formatDateTime("2023-07-01T14:30:45", "hh:mm:ss:ss");
- * // => "14:30:45:45"
- *
- * formatDateTime("invalid-date");
- * // => null
- *
- * formatDateTime(null);
- * // => null
- *
- * formatDateTime(undefined);
- * // => null
- */
-declare const formatDateTime:(date?:string | Date | null,
-/** @default "YYYY-MM-DD hh:mm:ss" */
-format?:string)=>string | null;
-/** ----------------------------------------------------------
- * * ***Formats a date using the `Intl.DateTimeFormat` API.***
- * ----------------------------------------------------------
- *
- * - Supports custom locales (type-safe `SupportedLocales`).
- * - Accepts additional `Intl.DateTimeFormatOptions` like `timeZone`, `hour12`, etc.
- * - Defaults to `"en-US"` if `locale` is not provided or is an empty string.
- * - Returns `null` if the date is invalid, not provided, or options are invalid.
- *
- * @param {string | Date | null | undefined} [date] - The date to format.
- *   Can be a `Date` object or an ISO string. If invalid or not provided, returns `null`.
- *
- * @param {Intl.DateTimeFormatOptions & { locale?: SupportedLocales | SupportedLocales[] }} [options]
- *   - Optional formatting options for `Intl.DateTimeFormat`.
- *   - Use `locale` to specify the language & region format.
- *
- * @returns {string | null}
- *   - Formatted date string.
- *   - Returns `null` if date is invalid or options are of wrong type.
- *
- * @example
- * formatDateIntl(new Date());
- * // => "7/14/2025"
- *
- * formatDateIntl("2025-07-14T00:00:00Z", { locale: "fr-FR", dateStyle: "long" });
- * // => "14 juillet 2025"
- *
- * formatDateIntl(null);
- * // => null
- *
- * formatDateIntl(new Date(), { timeZone: "UTC", hour: "2-digit", minute: "2-digit" });
- * // => "01:30 AM"
- */
-declare const formatDateIntl:(date?:string | Date | null,options?:Intl.DateTimeFormatOptions &{locale?:SupportedLocales | SupportedLocales[];})=>string | null;
-/** ----------------------------------------------------------
- * * ***Formats a date into a human-readable string using `date-fns`.***
- * ----------------------------------------------------------
- *
- * - Supports custom output formats using `date-fns/format`.
- * - Can parse localized non-ISO strings via `inputFormat` & `inputLocale`.
- * - Supports `locale` as `"id"`, `"en"` or `date-fns` `Locale` objects (like `id` or `enUS`).
- * - Returns `null` if the date is invalid, not provided, or parsing fails.
- *
- * @param {string | Date | null} [date] - The date input to format. Can be:
- *   - A `Date` object
- *   - An ISO string (e.g. `"2024-01-01T12:00:00Z"`)
- *   - A localized string (requires `inputFormat` + `inputLocale`)
- *
- * @param {object} [options] - Options for formatting and parsing.
- *
- * @param {string} [options.format="dd MMM yyyy - HH:mm:ss"]
- *   The output format string (passed to `date-fns/format`).
- *   E.g. `"dd MMMM yyyy, HH:mm:ss" => "14 Juli 2025, 17:25:42"`
- *
- * @param {"id" | "en" | (string & {}) | Locale} [options.locale="id"]
- *   The output locale. If string, only `"id"` (Indonesian) or `"en"` (English)
- *   is recognized. Or you can pass a `date-fns` `Locale` object.
- *   Example:
- *   ```ts
- *     import { ar } from "date-fns/locale";
- *     formatDateFns(new Date(), { locale: ar, format: "PPPppp" });
- *   ```
- *
- * @param {"id" | "en" | (string & {}) | Locale} [options.inputLocale]
- *   Required if `date` is a localized non-ISO string. Used with `inputFormat`.
- *   Example for Indonesian string:
- *   ```ts
- *     formatDateFns("14 Juli 2025 10:25:42", {
- *       inputFormat: "dd MMMM yyyy HH:mm:ss",
- *       inputLocale: "id",
- *     });
- *   ```
- *
- * @param {string} [options.inputFormat]
- *   The format string to parse `date` if it is a non-ISO string.
- *   Required together with `inputLocale`.
- *
- * @returns {string | null} A formatted date string or `null` if input is invalid.
- *
- * @example
- * formatDateFns(new Date());
- * // "14 Jul 2025 - 17:25:42"
- *
- * formatDateFns("2025-07-14T10:25:42Z", { format: "dd/MM/yyyy", locale: "en" });
- * // "14/07/2025"
- *
- * formatDateFns("14 Juli 2025 10:25:42", {
- *   inputFormat: "dd MMMM yyyy HH:mm:ss",
- *   inputLocale: "id",
- *   format: "yyyy-MM-dd"
- * });
- * // "2025-07-14"
- *
- * formatDateFns(null);
- * // null
- */
-declare const formatDateFns:(date?:string | Date | null,
-/**
- * Options for formatting and parsing a date using `date-fns`.
- */
-options?:OmitStrict<FormatOptions,"locale",true,false>&{
-/**
-	 * Output format string using `date-fns/format`.
-	 * @default "dd MMM yyyy - HH:mm:ss"
-	 * @example "dd MMMM yyyy, HH:mm:ss"
-	 */
-format?:string;
-/**
-	 * The locale to be used for formatting.
-	 * If `string` Only Accepts "id" for Indonesian or "en" for English.
-	 * Or you can put props `Locale` from `date-fns/locale`, e.g :
-	 *
-	 * ```ts
-	 *    import { ar } from "date-fns/locale";
-	 *
-	 *    // then passing `ar` to this props.
-	 *    formatDateFns(
-	 *    // your date input...,
-	 *    {
-	 *       locale: ar,
-	 *       //.... other options.
-	 *    });
-	 *
-	 * ```
-	 * @default "id"
-	 */
-locale?:"id" | "en" |(string &{})| Locale;
-/**
-	 * The Input locale to be used for parsing `inputFormat`.
-	 * If `string` Only Accepts "id" for Indonesian or "en" for English.
-	 * Required if `date` is a non-standard string like "03 Mei 2025 10:25:42").
-	 *
-	 *  Or you can put props `Locale` from `date-fns/locale`, e.g :
-	 *
-	 * ```ts
-	 *    import { ar } from "date-fns/locale";
-	 *
-	 *    // then passing `ar` to this props.
-	 *    formatDateFns(
-	 *    // your date input...,
-	 *    {
-	 *        inputLocale: ar,
-	 *        //.... other options.
-	 *    });
-	 *```
-
-	 * @default undefined
-	 */
-inputLocale?:"id" | "en" |(string &{})| Locale;
-/**
-	 * Input format string for parsing non-ISO string dates
-	 * (e.g., localized strings like "03 Mei 2025 10:25:42").
-	 * Required if `date` is a non-standard string.
-	 * @example "dd MMMM yyyy HH:mm:ss"
-	 */
-inputFormat?:string;})=>string | null;
-/** ----------------------------------------------------------
- * * ***Returns the formatted GMT offset (e.g., `+0700`, `-0500`) for a given date.***
- * ----------------------------------------------------------
- *
- * - If `date` is **not provided** or empty string, it defaults to the current date/time.
- * - If `date` is **invalid** or of wrong type (like object or number), it returns `"0"`.
- * - The returned string follows the **GMT offset format** (`±HHMM`), where:
- *   - `±` is `+` if ahead of UTC, `-` if behind.
- *   - `HH` is two-digit hours.
- *   - `MM` is two-digit minutes.
- *
- * @param {string | Date | null} [date] - The date to get the GMT offset from.
- *   - Accepts `Date` object or ISO date string (e.g., `"2024-01-01T12:00:00Z"`).
- *   - If `null`, `undefined`, or empty string, uses current system date.
- *   - If invalid date or wrong type (like `123` or `{}`), returns `"0"`.
- *
- * @returns {string} The GMT offset string in format `±HHMM`,
- *   e.g. `"+0700"`, `"-0530"`, or `"0"` if invalid.
- *
- * @example
- * getGMTOffset();
- * // => "+0700" (depends on system timezone)
- *
- * getGMTOffset(new Date("2024-02-09T12:00:00Z"));
- * // => "+0000"
- *
- * getGMTOffset("2024-02-09");
- * // => "+0700" (depends on your timezone)
- *
- * getGMTOffset("invalid-date");
- * // => "0"
- *
- * getGMTOffset(123);
- * // => "0"
- */
-declare const getGMTOffset:(date?:string | Date | null)=>string;
-/** ----------------------------------------------------------
- * * Censors an email by replacing characters with "*", with support for random or fixed mode.
- * ----------------------------------------------------------
- *
- * In "random" mode (default), characters are randomly replaced each time.
- * In "fixed" mode, censorship is deterministic based on a hash of the email,
- * resulting in the same output for the same input.
- *
- * @param email - The email to censor.
- * @param mode - Censoring mode: "random" or "fixed". Default is "random".
- * @returns The censored email or an empty string if invalid.
- *
- * @example
- * censorEmail("john.doe@gmail.com", "random"); // -> j***.d*@g***l.com (varies)
- * censorEmail("john.doe@gmail.com", "fixed");  // -> j**n.**e@g***l.com (always the same)
- * censorEmail("invalid-email");                // -> ""
- */
-declare const censorEmail:(email?:string | null,mode?:"random" | "fixed")=>string;
-/** ----------------------------------------------
- * * ***Chunks a string by inserting a separator every `limiter` characters.***
- * ----------------------------------------------
- *
- * This function handles two main behaviors based on `reCountAfterSpace`:
- *
- * 1. If `reCountAfterSpace` is `false` (default):
- * The separator is inserted strictly every `limiter` characters throughout the entire string,
- * regardless of spaces. Spaces are treated as regular characters in the count.
- * Example: `chunkString("1234567890", 3, "-")` returns `"123-456-789-0"`.
- * Example: `chunkString("Hello World", 3, "-")` returns `"Hel-lo -Wor-ld"`.
- *
- * 2. If `reCountAfterSpace` is `true`:
- * The function first processes the input string to replace any multiple consecutive spaces
- * with a single space (e.g., "A   B" becomes "A B").
- * Then, it treats the string as a sequence of "words" (segments separated by single spaces).
- * - Each word is processed independently: if a word's length exceeds the `limiter`,
- * separators are inserted internally within that word.
- * - Words are then grouped. Each group will contain `limiter` number of words.
- * Words within the same group are joined by the specified `separator`.
- * - Finally, these groups are joined by a single space, preserving the original word separation structure
- * between groups.
- *
- * @param {string} subject - The target string where the separator will be added.
- * @param {number} limiter - The interval (number of characters) at which the separator should be inserted.
- * @param {string} [separator=" "] - The separator string to insert (default is a single space `" "`).
- * @param {boolean} [reCountAfterSpace=false] - If `true`, the counting for `limiter`
- * resets after each space, and words are grouped as described above. If `false`,
- * the counting is continuous throughout the string.
- * @returns {string} - The formatted string with separators added according to the specified rules.
- *
- * @example
- * // Basic usage (reCountAfterSpace = false)
- * chunkString("1234567890", 3, "-"); // Returns: "123-456-789-0"
- * chunkString("HelloWorld", 2, "_"); // Returns: "He_ll_oW_or_ld"
- *
- * @example
- * // Usage with reCountAfterSpace = true:
- * // Multiple spaces are normalized to single spaces before processing.
- * chunkString("AB  CD   EF GH", 2, "-", true); // Returns: "AB-CD EF-GH" (after normalization to "AB CD EF GH")
- * // Words "AB" and "CD" form a group and are joined by "-", "EF" and "GH" form another group.
- * // The groups "AB-CD" and "EF-GH" are then joined by a space.
- *
- * @example
- * // Another usage with reCountAfterSpace = true:
- * chunkString("ABC DEF GHI JKL", 3, "-", true); // Returns: "ABC-DEF-GHI JKL"
- * // Words "ABC", "DEF", "GHI" form a group and are joined by "-".
- * // The word "JKL" forms its own group (as it's the last word and completes no other group).
- * // The groups "ABC-DEF-GHI" and "JKL" are then joined by a space.
- */
-declare function chunkString(subject:string,limiter:number,separator?:string,reCountAfterSpace?:boolean):string;
-/** ----------------------------------------------------------
- * * ***Truncates a string to a specified length and optionally appends an ending.***
- * * ***Also provides an option to trim the string before truncation.***
- * * ***If truncation occurs, trailing spaces before the ending are removed.***
- * * ***The `ending` parameter is always trimmed first; if it becomes empty, it defaults to `"..."`.***
- * ----------------------------------------------------------
- *
- * @param {string|null|undefined} text - The input string to truncate.
- *        If `null`, `undefined`, or empty after trim, returns `""`.
- * @param {number} [length=10] - The maximum length of the truncated string **(default: `10`)**.
- * @param {string} [ending="..."] - The string to append if truncation occurs **(default: `"..."`)**.
- *                                   This value is always passed through `ending.trim()`.
- *                                   If `ending.trim().length < 1`, it automatically becomes `"..."`.
- * @param {boolean} [trim=true] - Whether to trim the string before truncation **(default: `true`)**.
- *
- * @returns {string} - The truncated string with optional trimming and ending.
- *                     If text is `null`, `undefined`, or `length < 1`, returns `""`.
- *                     If truncation happens, trailing spaces before the `ending` are automatically removed.
- *
- * @throws {TypeError} - If `length` is not a number, `ending` is not a string, or `trim` is not a boolean.
- *
- * @example
- * truncateString("hello world", 5); // "hello..."
- * truncateString("hello world", 5, "---"); // "hello---"
- * truncateString("hello world", 5, "   "); // "hello..." (because ending.trim() -> "" -> default to "...")
- * truncateString("hello world", 5, "   !!!   "); // "hello!!!" (ending is trimmed to "!!!")
- * truncateString("   long data string   ", 8, "...", true); // "long dat..."
- * truncateString("   long data string   ", 8, "...", false); // "   long ..."
- * truncateString(" text with spaces ", 10, "...", false); // " text with..."
- * truncateString("abc def", 7); // "abc def"
- * truncateString(null, 5); // ""
- * truncateString("short", 10); // "short"
- */
-declare const truncateString:(text?:string | null,length?:number,ending?:string,trim?:boolean)=>string;
-/** ---------------------------------
- * * ***Returns a random element from a given array.***
- * ---------------------------------
- *
- * @template T The type of elements in the array (string | number).
- * @param {T[]} array - The input array.
- * @returns {T | undefined} A random element from the array, or `undefined` if the array is empty or invalid.
- *
- * @example
- * getRandomItem([1, 2, 3, 4]); // Returns a random number from the array
- * getRandomItem(["apple", "banana", "cherry"]); // Returns a random string from the array
- * getRandomItem([]); // Returns `undefined`
- */
-declare const getRandomItem:<T extends string | number>(array?:T[])=>T | undefined;
-/** ----------------------------
- * * ***Generates a random integer within a specified range (inclusive).***
- * ----------------------------
- *
- * @description
- * Generates a random integer between `min` and `max` (inclusive),
- * with safety constraints:
- * - `min` will be forced to be at least `1`.
- * - `max` will be capped at `Number.MAX_SAFE_INTEGER`.
- *
- * Validates input parameters to ensure robust behavior.
- *
- * @param {number} min - The minimum value (inclusive). Must be an integer.
- * @param {number} max - The maximum value (inclusive). Must be an integer.
- *
- * @returns {number} A random integer N where `min ≤ N ≤ max`.
- *
- * @throws {Error} If:
- * - `min` or `max` is not an integer.
- * - `min` is greater than `max`.
- *
- * @example
- * randomInt(1, 10);  // → returns 1 to 10
- * randomInt(50, 100); // → returns 50 to 100
- * randomInt(5, 5);    // → always returns 5
- *
- * @example
- * randomInt(-5, 3);   // → always returns ≥ 1, since min is adjusted
- *
- * @example
- * randomInt(1, Number.MAX_SAFE_INTEGER + 10000);
- * // → still safely capped at MAX_SAFE_INTEGER
- */
-declare const randomInt:(min:number,max:number)=>number;
-/** ----------------------------------------------------------
- * * ***Generates a random integer within a specified range of digit lengths.***
- * ----------------------------------------------------------
- *
- * @description
- * This function allows generating random integers that strictly conform to
- * a specified minimum and maximum digit length. It is useful for scenarios
- * such as generating realistic-looking IDs, codes, or random test data.
- *
- * The function ensures:
- * - `minLength` is at least 1 and not greater than `maxLength`.
- * - `maxLength` is no more than 16 (due to JavaScript's Number.MAX_SAFE_INTEGER).
- * - If `avoidZero` is `true`, ensures that `0` is never returned.
- *
- * @param {object} [options] - Configuration options.
- * @param {number} [options.minLength=1] - Minimum number of digits (must be ≥1 and ≤ `maxLength`).
- * @param {number} [options.maxLength=16] - Maximum number of digits (must be ≤16).
- * @param {boolean} [options.avoidZero=false] - If true, will ensure the result is never zero.
- *
- * @returns {number} A randomly generated integer within the specified constraints.
- *
- * @throws {Error} If parameters are invalid, such as:
- * - `minLength` < 1
- * - `maxLength` > 16
- * - `minLength` > `maxLength`
- * - non-integer values for `minLength` or `maxLength`
- *
- * @example
- * randomIntByLength({ minLength: 3, maxLength: 5 }); // → (`4829` << random), (`192` << random) or (`71492` << random).
- * randomIntByLength({ minLength: 4, maxLength: 4 }); // → `5930` (exact 4 digits)
- * randomIntByLength({ avoidZero: true });            // → never 0
- */
-declare const randomIntByLength:(options?:{
-/** * Minimum length of the random number, the `allowed` `minimal` `value` `integer` is `1` `and` `not` `bigger` `than` `value` `of` `maxLength`.
-	 * @default 1
-	 */
-minLength?:number;
-/** * Maximum length of the random number, the `allowed` `maximal` `value` `integer` is `16`.
-	 *
-	 * @default 16
-	 */
-maxLength?:number;
-/** * If true, prevents the result from being zero.
-	 * @default false
-	 */
-avoidZero?:boolean;})=>number;
-/** ---------------------------------------------------------------------------------
- * * ***Generates a random alphanumeric string or number with a specified length range.***
- * ---------------------------------------------------------------------------------
- *
- * @description
- * This function allows you to generate random strings or numbers with fully customizable options,
- * such as length range, character sets, inclusion of additional characters, and whether to avoid whitespace.
- *
- * @param {Object} [options] - Configuration options for generating the string.
- * @param {number} [options.minLength=40] - Minimum length of the generated string (must be ≥ 1).
- * @param {number} [options.maxLength=40] - Maximum length of the generated string (must be ≤ 5000).
- * @param {"string" | "number"} [options.type="string"] - Whether to generate a general alphanumeric string or purely numeric string.
- * @param {boolean} [options.avoidWhiteSpace=true] - If true, removes all whitespace, tabs, and newlines from the character set before generating.
- * @param {string} [options.replaceGenStr] - A custom character set to use when `type` is `"string"`.
- * @param {string} [options.replaceGenInt] - A custom character set to use when `type` is `"number"`.
- * @param {string} [options.addChar] - Additional characters to always include in the character set.
- *
- * @returns {string} The randomly generated string or numeric string of the desired length.
- *
- * @throws {Error} If provided options are invalid (such as minLength > maxLength, invalid type, or empty character set).
- *
- * @example
- * randomStr(); // → Generates a 40-character random alphanumeric string
- * randomStr({ minLength: 10, maxLength: 20 }); // → Generates a string between 10 and 20 characters
- * randomStr({ type: "number", minLength: 5, maxLength: 5 }); // → "48302"
- * randomStr({ replaceGenStr: "ABC ", avoidWhiteSpace: false }); // → String using A, B, C and space
- * randomStr({ addChar: "!@#", minLength: 15, maxLength: 15 }); // → Guaranteed to include !@# in the set
- */
-declare const randomStr:(options?:RandomStringOptions)=>string;
-/** --------------------------------------------------
- * * ***This method returns `undefined`.***
- * --------------------------------------------------
- *
- * @example
- * console.log(noop) // => undefined
- * isUndefined(noop) // => true
- *
- */
-declare const noop:()=>void;
-/** ----------------------------------------
- * * ***Checks if the current environment is a server-side (Node.js) or a client-side (browser).***
- * ----------------------------------------
- *
- * @returns {boolean} `true` if running on the server-side, `false` if running in the client-side (browser).
- */
-declare const isServer:()=>boolean;
-/** ----------------------------------------------------------------------
- * * ***Finds duplicate values in an array by deep equality comparison.***
- * ----------------------------------------------------------------------
- *
- * - ✔ Uses `isEqual` to compare elements (handles objects, arrays, dates, NaN, etc.)
- * - ✔ Returns a new array containing only the *first occurrences* of duplicated values.
- * - ✔ Does **not mutate** the original array.
- * - ✔ Throws `TypeError` if input is not an array.
- *
- * @template T Type of elements in the input array.
- * @param {T[]} values - The array to check for duplicates.
- * @returns {T[]} An array of the duplicate values found in the input,
- *                preserving order of their first duplicate appearance.
- *
- * @throws {TypeError} If the provided `values` argument is not an array.
- *
- * @example
- * findDuplicates([1, 2, 2, 3, 4, 4]); // => [2, 4]
- * findDuplicates(["apple", "banana", "apple", "orange"]); // => ["apple"]
- * findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]); // => [{ a: 1 }]
- * findDuplicates([NaN, NaN, 1]); // => [NaN]
- * findDuplicates([true, false, true]); // => [true]
- * findDuplicates([1, 2, 3]); // => []
- */
-declare const findDuplicates:<T>(values:T[])=>T[];
-/** --------------------------------
- * * ***Creates a new object excluding specified keys.***
- * --------------------------------
- * This function creates a shallow copy of the given object
- * omitting the specified keys. It will return a new object
- * without mutating the original.
- *
- * It also validates that `keysToOmit` does not contain duplicate keys.
- *
- * Internally, it uses `isEqual` to check for duplicates in the `keysToOmit` array.
- *
- * @template I The type of the input object.
- * @template K The keys to omit from the object.
- * @param {I} object - The source object to omit keys from.
- * @param {K[]} keysToOmit - An array of keys to exclude from the returned object.
- * @returns {Omit<I, K>} A new object without the specified keys.
- *
- * @throws {TypeError} If `keysToOmit` is not an array.
- * @throws {Error} If duplicate keys are found in `keysToOmit`.
- *
- * @example
- * omitKeys({ a: 1, b: 2, c: 3 }, ["b", "c"]);
- * // => { a: 1 }
- *
- * @example
- * omitKeys({ name: "John", age: 30 }, ["age"]);
- * // => { name: "John" }
- *
- * @example
- * omitKeys({ a: 1, b: 2 }, []);
- * // => { a: 1, b: 2 } (no changes)
- */
-declare const omitKeys:<I extends Record<string,unknown>,K extends keyof I>(object:I,keysToOmit:K[])=>Omit<I,K>;type DotPath$1<T,Prev extends string="">=T extends Array<infer U>? DotPath$1<U,`${Prev}${Prev extends "" ? "":"."}${number}`>:T extends object ?{[K in keyof T & string]:`${Prev}${Prev extends "" ? "":"."}${K}` | DotPath$1<T[K],`${Prev}${Prev extends "" ? "":"."}${K}`>;}[keyof T & string]:never;
-/** ------------------------------------------------------
- * * Recursively omits properties from an object using dot notation paths.
- * * Also removes resulting empty objects (`{}`) and arrays (`[]`),
- * * cascading upwards to remove empty parents until root if needed.
- * ------------------------------------------------------
- *
- * @template I - Type of the input object
- *
- * @param {I} object
- *    The object to process. Should be a plain nested object or array structure.
- *
- * @param {DotPath<I>[]} keysToOmit
- *    An array of string paths in dot notation indicating the properties to remove.
- *    Paths can include numeric indices to target array elements, e.g. `"arr.0.x"` to remove `x`
- *    from the first object inside the `arr` array.
- *
- * @returns {Partial<I>}
- *    A new deeply cloned object with the specified keys omitted,
- *    with resulting empty objects or arrays fully removed (even if it collapses to `{}`).
- *
- * @throws {TypeError}
- *    If `keysToOmit` is not an array will throw TypeError.
- *
- * @throws {Error}
- *    If `keysToOmit` contains duplicate paths will throw Error.
- *
- * @remarks
- * ⚠️ Be careful: if after omission an object or array becomes empty, it will be removed entirely
- * including all the way up to the root if necessary, resulting in `{}`.
- *
- * @example
- * omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, ["a.b.c"]);
- * // → { a: { d: 2 }, e: 3 }
- *
- * @example
- * omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, ["a.0.b"]);
- * // → { a: [{ c: 2 }] }
- *
- * @example
- * omitKeysDeep({ a: [{ b: 1 }] }, ["a.0.b"]);
- * // → {} (array becomes empty and removed)
- *
- * @example
- * omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, ["complex.0.deep.0.x"]);
- * // → { complex: [{ deep: [{ y: 2 }] }] }
- *
- * @example
- * omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, ["complex.0.deep.0.x"]);
- * // → {} (deep chain emptied and collapsed)
- *
- * @example
- * omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, ["data.0.0.foo"]);
- * // → { data: [[{ bar: 2 }]] }
- *
- * @example
- * omitKeysDeep({ data: [[{ foo: 1 }]] }, ["data.0.0.foo"]);
- * // → {} (nested arrays emptied completely)
- *
- * @example
- * omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, ["x.0.y.0.z"]);
- * // → { x: [{ y: [{ w: 2 }] }] }
- *
- * @example
- * omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, ["x.0.y.0.z"]);
- * // → {} (entire nested arrays removed)
- *
- * @example
- * omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, ["p.q.r"]);
- * // → { s: 6 } (`p` removed because it becomes empty)
- *
- * @example
- * omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, ["arr.0.a"]);
- * // → { arr: [{ b: 2 }, { c: 3 }] }
- *
- * @example
- * omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, ["root.0.sub.0.leaf"]);
- * // → {} (deep nested arrays emptied to root)
- *
- * @example
- * omitKeysDeep({ meta: { tags: ["x", "y"], count: 2 } }, ["meta.count"]);
- * // → { meta: { tags: ["x", "y"] } }
- *
- * @example
- * omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, ["arr.0.0.a"]);
- * // → { arr: [[{ b: 2 }]] }
- *
- * @example
- * omitKeysDeep({ arr: [[{ a: 1 }]] }, ["arr.0.0.a"]);
- * // → {} (double nested emptied)
- *
- * @example
- * omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, ["nested.0.list.0.val"]);
- * // → { nested: [{ list: [{ id: 1 }] }] }
- *
- * @example
- * omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, ["nested.0.list.0.id"]);
- * // → {} (full collapse to empty)
- *
- * @example
- * omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, ["mixed.b.c"]);
- * // → { mixed: { a: [1, 2, 3] } }
- */
-declare const omitKeysDeep:<I extends Record<string,unknown>>(object:I,keysToOmit:DotPath$1<I>[])=>Partial<I>;
-/** --------------------------------
- * * Removes Property from PROPS Collection
- * --------------------------------
- * @description Becarefull put array in arrayException, If array is duplicated it will be throw an exception error
- * @param object is Record as object (string,any)
- * @param arrayExcept is Array exception []
- * @returns
- *
- * @deprecated - Use `omitKeys` instead, this function will remove a next update.
- */
-declare const omitProps:<I extends Record<string,unknown>,S extends(keyof I)[]>(object:I,arrayExcept:S)=>Omit<I,S[number]>| undefined;
-/** ----------------------------------------------------------
- * * ***Extracts the base file name (without extension) from a given URL, file path, or file name.***
- * ----------------------------------------------------------
- *
- * - ✅ Strips known extensions (including multi-part extensions such as `.tar.gz`, `.tar.bz2`, etc.).
- * - ✅ Handles plain file names, local file paths, and full URLs seamlessly.
- * - ✅ If the path ends with a `/`, returns an empty string `""` (represents a directory or empty segment).
- * - ✅ If the input is empty, whitespace, or not a string, returns `undefined`.
- * - ✅ Leaves unknown or unrecognized extensions intact (does not attempt to strip unknown file extensions).
- *
- * Behavior summary:
- * - `extractFileName("https://example.com/file.txt")` → `"file"`
- * - `extractFileName("/local/path/image.jpeg")` → `"image"`
- * - `extractFileName("backup.archive.tar.gz")` → `"backup.archive"`
- * - `extractFileName("folder/")` → `""`
- * - `extractFileName("")` → `undefined`
- * - `extractFileName("unknownfile.weirdext")` → `"unknownfile.weirdext"` (keeps unknown extension)
- *
- * This is particularly useful for displaying or logging file names
- * without cluttering them with redundant extensions, while being careful
- * not to accidentally truncate unfamiliar formats.
- *
- * @param {string} url - The URL, file system path, or plain file name to process.
- * @returns {string | undefined} The file name without its extension(s),
- *                               or `undefined` if input is invalid,
- *                               or an empty string `""` if the path ends with `/`.
- *
- * @example
- * extractFileName("document.pdf");                     // "document"
- * extractFileName("/files/archive.tar.gz");            // "archive"
- * extractFileName("https://cdn.site.com/video.mp4");   // "video"
- * extractFileName("folder/");                          // ""
- * extractFileName("strangefile.unknownext");           // "strangefile.unknownext"
- * extractFileName("");                                 // undefined
- */
-declare const extractFileName:(url:string)=>string | undefined;
-/** ---------------------------------
- * * ***Compares two objects for deep equality.***
- * ---------------------------------
- *  * This Function using `lodash` library.
- *
- * @template T1 The type of the first object.
- * @template T2 The type of the second object.
- * @param {T1} object1 - The first object to compare.
- * @param {T2} object2 - The second object to compare.
- * @returns {boolean} `true` if both objects are deeply equal, otherwise `false`.
- *
- * @example
- * areObjectsEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // Returns true
- * areObjectsEqual({ a: 1 }, { a: 1, b: undefined }); // Returns false
- * areObjectsEqual([1, 2, 3], [1, 2, 3]); // Returns true
- */
-declare const areObjectsEqual:(object1:unknown,object2:unknown)=>boolean;
-/** ---------------------------------
- * * ***Checks if two URLs are the same, ignoring query parameters.***
- * ---------------------------------
- *
- * This function compares only the protocol, host, and pathname.
- *
- * @param {URL} urlA - The first URL to compare.
- * @param {URL} urlB - The second URL to compare.
- * @returns {boolean} Returns `true` if both URLs are the same (ignoring search parameters), otherwise `false`.
- */
-declare const areURLsEqualPath:(urlA:URL,urlB:URL)=>boolean;
-/** ---------------------------------
- * * ***Checks if two URLs are exactly the same, including protocol, host, pathname, and query parameters.***
- * ---------------------------------
- *
- * @param {URL} urlA - The first URL to compare.
- * @param {URL} urlB - The second URL to compare.
- * @returns {boolean} Returns `true` if both URLs are identical, otherwise `false`.
- */
-declare const areURLsIdentical:(urlA:URL,urlB:URL)=>boolean;
-/** ----------------------------------------------------------
- * * ***Checks if at least one element from `targetArray` exists in `sourceArray`.***
- * ----------------------------------------------------------
- *
- * - ✅ Uses `Set` for **faster lookup** compared to `Array.prototype.includes()`.
- * - ✅ Supports **any data type** (`number`, `string`, `boolean`, `object`, `array`, `function`, etc.).
- * - ✅ Uses **reference equality** for non-primitive values (object, array, function).
- * - ✅ Returns `false` if either array is missing, empty, or not an array.
- *
- * @template T - The expected type of array elements.
- *
- * @param {T[]} [sourceArray] - The array to search within.
- * @param {T[]} [targetArray] - The array containing elements to match.
- *
- * @returns {boolean}
- *    - `true` if **at least one element from `targetArray` is strictly found in `sourceArray`**.
- *    - Comparison uses:
- *       - **Value equality** for primitives (`number`, `string`, `boolean`, `null`, `undefined`).
- *       - **Reference equality** for objects, arrays, and functions.
- *    - `false` if:
- *       - No matching elements exist,
- *       - Either array is not provided, not an actual array, or is empty.
- *
- * @example
- * arrayHasAnyMatch(["apple", "banana", "cherry"], ["banana", "grape"]); // → true
- * arrayHasAnyMatch(["red", "blue"], ["green", "yellow"]); // → false
- * arrayHasAnyMatch([1, 2, 3], [3, 4, 5]); // → true
- * arrayHasAnyMatch([], ["test"]); // → false
- * arrayHasAnyMatch(["A", "B", "C"], []); // → false
- *
- * @example
- * const obj = { x: 1 };
- * arrayHasAnyMatch([obj], [obj]); // → true (same reference)
- * arrayHasAnyMatch([{ x: 1 }], [{ x: 1 }]); // → false (different reference)
- *
- * @example
- * const fn = () => "hello";
- * arrayHasAnyMatch([fn], [fn]); // → true
- * arrayHasAnyMatch([() => "hello"], [() => "hello"]); // → false (different function reference)
- *
- * @example
- * const arr = [1, 2];
- * arrayHasAnyMatch([arr], [arr]); // → true
- * arrayHasAnyMatch([[1, 2]], [[1, 2]]); // → false (different array object)
- */
-declare const arrayHasAnyMatch:<T>(sourceArray?:T[],targetArray?:T[])=>boolean;
-/** ----------------------------------------------------------
- * * ***Recursively checks if a given key exists in an object or array.***
- * ----------------------------------------------------------
- *
- * - ✅ **Supports deeply nested objects and arrays**, searching recursively.
- * - ✅ Uses `Object.prototype.hasOwnProperty.call()` to safely check if the key exists at each level,
- *      even if its value is `null` or `undefined`.
- * - ✅ Optimized to return `true` immediately when the key is found (short-circuits).
- * - ✅ Handles edge cases gracefully:
- *      - Returns `false` for `null`, `undefined`, or non-object inputs.
- *      - Returns `false` if key is not found anywhere, even in deeply nested structures.
- *
- * ⚠️ Note: This function only checks for **the existence of the key itself**,
- * not whether its value is non-null or non-undefined.
- * If you need to check for both existence and meaningful value, write a stricter function.
- *
- * @template T - The type of the input object or array.
- * @param {T | Record<string, unknown> | unknown[]} object - The object or array to search.
- * @param {PropertyKey} key - The key to look for (string, number, or symbol).
- * @returns {boolean} Returns `true` if the key exists anywhere in the object or array (even with `null` / `undefined` value), otherwise `false`.
- *
- * @example
- * doesKeyExist({ name: "John", age: 30 }, "age"); // true
- * doesKeyExist({ user: { profile: { email: "test@example.com" } } }, "email"); // true
- * doesKeyExist([{ id: 1 }, { id: 2 }], "id"); // true
- * doesKeyExist({ a: { b: { c: 10 } } }, "d"); // false
- * doesKeyExist(null, "name"); // false
- * doesKeyExist(undefined, "test"); // false
- *
- * @example
- * // Key exists even if value is null or undefined:
- * doesKeyExist({ a: null, b: undefined, c: { d: null } }, "a"); // true
- * doesKeyExist({ a: null, b: undefined, c: { d: null } }, "b"); // true
- * doesKeyExist({ a: null, b: undefined, c: { d: null } }, "d"); // true
- *
- * @example
- * doesKeyExist({ a: 1 }, true); // ❌ Throws TypeError
- * doesKeyExist({ a: 1 }, ["not", "valid"]); // ❌ Throws TypeError
- */
-declare const doesKeyExist:<T>(object:T | Record<string,unknown>| unknown[],key:PropertyKey)=>boolean;
-/** ---------------------------------
- * * ***Extracts all valid URLs from a given string.***
- * ---------------------------------
- *
- * This function scans the input url and returns an array of URLs
- * that match a valid `http` or `https` format.
- *
- * Supports:
- * - Internationalized domain names (IDN), e.g. `https://münich.de`
- * - Unicode & emoji paths, e.g. `https://example.com/🎉/page`
- * - Long URLs with multiple queries & fragments, e.g. `https://example.com/path?foo=1#hash`
- *
- * Ignores:
- * - Non-string inputs
- * - Empty or whitespace-only strings
- * - Non-HTTP(S) protocols (ftp, mailto, etc)
- *
- * @example
- * extractURLs("Visit https://example.com and https://例子.公司");
- * // => ["https://example.com", "https://例子.公司"]
- *
- * @example
- * extractURLs("Here: https://example.com/🎉/page");
- * // => ["https://example.com/🎉/page"]
- *
- * @example
- * extractURLs("ftp://example.com http://example.com");
- * // => ["http://example.com"]
- *
- *
- * @param {string} [url] - The input string containing potential URLs.
- * @returns {string[] | null} An array of extracted URLs or `null` if no URLs are found.
- */
-declare const extractURLs:(url:string)=>string[] | null;
-/** ----------------------------------------------------------
- * * ***Type guard: Checks if a value is an array.***
- * ----------------------------------------------------------
- *
- * - ✅ Uses `Array.isArray()` for reliable and safe type checking.
- * - ✅ Supports TypeScript **type narrowing** using `value is T[]`.
- * - ✅ Handles edge cases like `null`, `undefined`, and non-array objects.
- *
- * @template T - The expected type of array elements.
- * @param {unknown} value - The value to check.
- * @returns {value is T[]} Returns `true` if the value is an array, otherwise `false`.
- *
- * @example
- * isArray([1, 2, 3]); // true
- * isArray([]); // true
- * isArray("hello"); // false
- * isArray({ key: "value" }); // false
- * isArray(null); // false
- * isArray(undefined); // false
- */
-declare function isArray<T>(value:T[]):value is T[];declare function isArray(value:unknown):value is unknown[];
-/** ----------------------------------------------------------
- * * ***Type guard: Checks if a value is of type bigint.***
- * ----------------------------------------------------------
- *
- * - ✅ Uses `typeof value === "bigint"` for strict type checking.
- * - ✅ Supports TypeScript type narrowing with `value is bigint`.
- * - ❗ Returns `false` for `BigInt` object (object-wrapped), e.g. `Object(BigInt(123))`
- *
- * @param value - The value to check.
- * @returns {value is bigint} - `true` if value is a primitive `bigint`.
- *
- * @example
- * isBigInt(123n); // true
- * isBigInt(BigInt(123)); // true
- * isBigInt("123"); // false
- * isBigInt(Object(BigInt(1))); // false
- */
-declare const isBigInt:(value:unknown)=>value is bigint;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is of type `boolean`.***
- * ---------------------------------------------------------
- *
- * @param {unknown} value - The value to check.
- * @returns {boolean} Returns `true` if the value is a boolean, otherwise `false`.
- *
- * @example
- * isBoolean(true);   // true
- * isBoolean(false);  // true
- * isBoolean("true"); // false
- */
-declare const isBoolean:(value:unknown)=>value is boolean;
-/** -----------------------------------------------------------
- * * Checks whether an input looks like a currency or number string,
- * * using the same smart multi-locale parsing logic as `parseCurrencyString`.
- * -----------------------------------------------------------
- *
- * ✅ Highlights:
- * - Supports strings or numbers like:
- *   - "15.000,10"  (European)
- *   - "15,000.10"  (US)
- *   - "15'000.10"  (Swiss)
- *   - "15 000,10"  (French)
- *   - "Rp 15.000,10" or "$15,000.10"
- * - Also accepts simple numbers (15300.95).
- *
- * 🚀 Uses the same core logic as `parseCurrencyString` but
- * just checks if a final parsed float is sensible.
- *
- * @param {string|number} input
- *   The input value to check.
- *
- * @returns {boolean}
- *   `true` if it can be reasonably parsed into a currency-like number,
- *   `false` otherwise.
- *
- * @example
- * isCurrencyLike("Rp 15.000,10");
- * // ➔ true
- *
- * isCurrencyLike("$15,000.10");
- * // ➔ true
- *
- * isCurrencyLike("(15'000.10)");
- * // ➔ true
- *
- * isCurrencyLike("abc");
- * // ➔ false
- *
- * isCurrencyLike(15300.95);
- * // ➔ true
- *
- * isCurrencyLike("");
- * // ➔ false
- */
-declare const isCurrencyLike:(input:string | number)=>boolean;
-/** ----------------------------------------------------------
- * * ***Type guard: Checks if a value is a valid `Date` object.***
- * ----------------------------------------------------------
- *
- * - ✅ Checks if value is an instance of `Date`
- * - ✅ Ensures the date is valid (`!isNaN(date.getTime())`)
- * - ❗ Returns false for strings or invalid date objects
- *
- * @param value - The value to check.
- * @returns {boolean} - `true` if value is a valid Date object.
- *
- * @example
- * isDate(new Date()); // true
- * isDate(new Date("invalid")); // false
- * isDate("2024-01-01"); // false
- */
-declare const isDate:(value:unknown)=>value is Date;
-/**
- * ----------------------------------------------------------
- * *** Performs a deep equality check between two values. ***
- * ----------------------------------------------------------
- *
- * - Compares nested arrays, objects, Dates, RegExp, NaN, Symbols, Set, and Map.
- * - Handles special cases:
- *   - `NaN` is considered equal to `NaN`.
- *   - `Date` objects are equal if `.getTime()` is equal.
- *   - `RegExp` objects are equal if `.toString()` is equal.
- *   - `Symbol("x")` and `Symbol("x")` are treated equal if `.toString()` matches.
- *   - `Set` and `Map` are deeply compared by content (order-insensitive).
- * - Does not support circular references.
- */
-declare const isDeepEqual:(a:unknown,b:unknown)=>boolean;
-/** ----------------------------------------------------------
- * * ***Checks whether a given value is an empty array.***
- * ----------------------------------------------------------
- *
- * This utility checks if a value is an array and whether it's empty.
- * Non-array inputs are considered "empty" by default (defensive strategy).
- *
- * @param {unknown} [value] - The value to check.
- * @returns {boolean} - Returns `true` if it's not an array or an empty array.
- *
- * @example
- * isEmptyArray([]);             // true
- * isEmptyArray([1, 2, 3]);      // false
- * isEmptyArray("not an array"); // true
- * isEmptyArray(null);           // true
- * isEmptyArray(undefined);      // true
- *
- * @example
- * if (isEmptyArray(data.items)) {
- *   console.log("No items to display.");
- * }
- */
-declare const isEmptyArray:(value?:unknown)=>boolean;
-/** ----------------------------------------------------------
- * * ***Recursively checks if a value is "deeply empty".***
- * ----------------------------------------------------------
- *
- * - Returns `true` for:
- *   - Empty objects: `{}`
- *   - Empty arrays: `[]`
- *   - Nested empty structures: `{ a: [], b: {} }`
- *   - Falsy values (except numbers): `null`, `undefined`, `false`, `""`, `NaN`
- *
- * - Returns `false` for:
- *   - Non-zero numbers
- *   - Objects or arrays containing non-empty values
- *   - Non-empty strings, `true`, functions, symbols, etc.
- *
- * @param {unknown} value - The value to deeply check.
- * @returns {boolean} `true` if the value is deeply empty, otherwise `false`.
- *
- * @example
- * isEmptyDeep({}); // true
- * isEmptyDeep([]); // true
- * isEmptyDeep({ a: {} }); // true
- * isEmptyDeep([[], {}]); // true
- * isEmptyDeep({ a: [1] }); // false
- * isEmptyDeep([0]); // false
- * isEmptyDeep("test"); // false
- * isEmptyDeep(""); // true
- * isEmptyDeep(0); // false
- * isEmptyDeep(NaN); // true
- */
-declare const isEmptyDeep:(value:unknown)=>boolean;
-/** ----------------------------------------------------------
- * * ***Checks whether a given value is an empty string.***
- * ----------------------------------------------------------
- *
- * This utility checks if a string is empty (`""`) or consists only of whitespace
- * (if `trim` is enabled, which is the default). Non-string inputs are considered empty.
- *
- * @param {string} [value] - The value to check.
- * @param {Object} [options] - Optional settings.
- * @param {boolean} [options.trim=true] - Whether to trim the string before checking, defaultValue `true`.
- * @returns {boolean} - Returns `true` if the value is string not a string or value string is considered empty.
- *
- * @example
- * isEmptyString("");                         // true
- * isEmptyString("   ");                      // true (default trims)
- * isEmptyString("   ", { trim: false });     // false
- * isEmptyString("hello");                    // false
- * isEmptyString(undefined);                  // true
- * isEmptyString(null);                       // true
- * isEmptyString(123 as any);                 // true
- *
- * @example
- * // Used in validation
- * if (isEmptyString(form.name)) {
- *   throw new Error("Name cannot be empty.");
- * }
- */
-declare const isEmptyString:(value?:string | null,options?:{
-/**
-	 * Whether to trim the string before checking.
-	 *
-	 * @default `true` */
-trim?:boolean;})=>boolean;
-/** ----------------------------------------------------------
- * * ***Determines if a value is an empty object (`{}`), empty array (`[]`), or generally falsy.***
- * ----------------------------------------------------------
- *
- * - Returns `true` for `{}`, `[]`, `null`, `undefined`, `""`, `false`, and `NaN`.
- * - Returns `false` for objects with properties, non-empty arrays, numbers, functions, and other non-empty values.
- * - Safely handles `null`, `undefined`, and non-object types without throwing.
- *
- * @param {unknown} value - The value to evaluate.
- * @returns {boolean} `true` if the value is considered empty, otherwise `false`.
- *
- * @example
- * isEmptyValue({}); // true
- * isEmptyValue([]); // true
- * isEmptyValue({ key: "value" }); // false
- * isEmptyValue([1, 2, 3]); // false
- * isEmptyValue(null); // true
- * isEmptyValue(undefined); // true
- * isEmptyValue(""); // true
- * isEmptyValue("   "); // true
- * isEmptyValue(0); // false
- * isEmptyValue(-1); // false
- * isEmptyValue(2); // false
- * isEmptyValue(() => {}); // false
- */
-declare const isEmptyValue:(value:unknown)=>boolean;
-/** ----------------------------------------------------------
- * * ***Checks if a given value is an instance of the `Error` object.***
- * ----------------------------------------------------------
- *
- * - ✅ This function helps ensure that the provided value is a valid JavaScript error.
- * - ✅ Useful for error handling in TypeScript.
- *
- * @param {unknown} error - The value to check.
- * @returns {boolean} - Returns `true` if the value is an `Error`, otherwise `false`.
- *
- * @example
- * isError(new Error("Something went wrong")); // true
- * isError("Error message"); // false
- * isError(null); // false
- */
-declare const isError:(error:unknown)=>error is Error;
-/**
- * ----------------------------------------------------------
- * * ***Type guard: Checks if a value is a function.***
- * ----------------------------------------------------------
- *
- * - ✅ Uses `typeof value === "function"` for strict type checking.
- * - ✅ Supports TypeScript type narrowing with `value is (...args: any[]) => any`.
- * - ✅ Safe alternative to `Function` type (doesn't trigger ESLint warning).
- *
- * @param value - The value to check.
- * @returns {boolean} - `true` if the value is a function.
- *
- * @example
- * isFunction(() => {}); // true
- * isFunction(async () => {}); // true
- * isFunction(null); // false
- * isFunction({}); // false
- */
-declare const isFunction:(value:unknown)=>value is AnyFunction;
-/** ----------------------------------------------------------
- * * ***Type guard: Checks if a value is a non-empty array.***
- * ----------------------------------------------------------
- *
- * - ✅ Ensures the value is an actual array using `Array.isArray`.
- * - ✅ Ensures the array contains at least one item.
- * - ✅ Narrows type to `T[]` (non-empty array) when true.
- *
- * @param value - The value to check.
- * @returns {value is T[]} - `true` if value is a non-empty array.
- *
- * @example
- * isNonEmptyArray([1, 2, 3]); // true
- * isNonEmptyArray([]);       // false
- * isNonEmptyArray(null);     // false
- * isNonEmptyArray("test");   // false
- */
-declare function isNonEmptyArray(value:unknown):value is unknown[];declare function isNonEmptyArray<T>(value:T):value is NonNullable<Extract<T,unknown[]>>;
-/**
- * ----------------------------------------------------------
- * * ***Type guard: Checks if a value is a non-empty string.***
- * ----------------------------------------------------------
- *
- * Determines whether the given `value` is a string containing at least one non-whitespace character,
- * with optional trimming behavior.
- *
- * - ✅ Validates that `value` is a string.
- * - ✅ Optionally trims the string before checking (`trim` defaults to `true`).
- * - ✅ Returns `true` only if the resulting string is not empty.
- *
- * @param value - The value to test.
- * @param options - Optional settings.
- * @param options.trim - If `true`, trims the string before checking. Defaults to `true`.
- *
- * @returns `true` if `value` is a non-empty string, otherwise `false`.
- *
- * @example
- * isNonEmptyString("hello"); // true
- * isNonEmptyString("   ", { trim: true }); // false
- * isNonEmptyString("   ", { trim: false }); // true
- * isNonEmptyString(""); // false
- * isNonEmptyString(123); // false
- * isNonEmptyString(undefined); // false
- * isNonEmptyString(null); // false
- * isNonEmptyString({}); // false
- * isNonEmptyString([]); // false
- */
-declare const isNonEmptyString:(value:unknown,options?:{trim?:boolean;})=>value is string;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is `null`.***
- * ---------------------------------------------------------
- *
- * @param {unknown} val - The value to check.
- * @returns {val is null} Returns `true` if the value is `null`, otherwise `false`.
- *
- * @example
- * isNull(null); // true
- * isNull(0);    // false
- */
-declare const isNull:(val:unknown)=>val is null;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is of type `number`.***
- * ---------------------------------------------------------
- *
- * **Note**: To exclude Infinity, -Infinity, and NaN, which are classified as numbers, use the `isFinite(...)`.
- * @param {unknown} value - The value to check.
- * @returns {boolean} Returns `true` if the value is a number (excluding NaN), otherwise `false`.
- *
- * @example
- * isNumber(42);    // true
- * isNumber(NaN);   // false
- * isNumber("42");  // false
- */
-declare const isNumber:(value:unknown)=>value is number;type IsObject<T=unknown>=unknown extends T ? Record<string,unknown>& unknown:T extends object ? T extends NonPlainObject ? never:T:never;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is a plain object.***
- * ---------------------------------------------------------
- *
- * Will return `false` for arrays, undefined and `null`.
- *
- * @param {unknown} val - The value to check.
- * @returns {val is Record<string, unknown>} Returns `true` if the value is a plain object, otherwise `false`.
- *
- * @example
- * isObject({ name: "Alice" }); // true
- * isObject([1,2,3]);           // false
- * isObject(null);              // false
- * isObject(undefined);         // false
- */
-declare function isObject<T>(val:T):val is IsObject<T>;
-/** ----------------------------------------------------------
- * * ***Type guard: Checks if a value is a RegExp instance.***
- * ----------------------------------------------------------
- *
- * @param value - The value to check.
- * @returns {boolean} - `true` if value is an instance of RegExp.
- *
- * @example
- * isRegExp(/abc/); // true
- * isRegExp(new RegExp("abc")); // true
- * isRegExp("abc"); // false
- */
-declare const isRegExp:(value:unknown)=>value is RegExp;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is of type `string`.***
- * ---------------------------------------------------------
- *
- * This function is a type guard that determines if the provided value
- * is a `string`. It can be used to narrow types in TypeScript.
- *
- * @param {unknown} value - The value to check.
- * @returns {boolean} `true` if the value is a string, otherwise `false`.
- *
- * @example
- * isString("hello"); // true
- * isString(123);     // false
- *
- * // Usage in type narrowing
- * const value: unknown = getValue();
- * if (isString(value)) {
- *   // TypeScript now knows `value` is a string
- *   console.log(value.toUpperCase());
- * }
- */
-declare const isString:(value:unknown)=>value is string;
-/** ----------------------------------------------------------
- * * ***Checks whether a value is a symbol.***
- * ----------------------------------------------------------
- *
- * @param value - The value to check.
- * @returns `true` if the value is of type symbol.
- *
- * @example
- * isSymbol(Symbol("id"));         // true
- * isSymbol("not a symbol");       // false
- * isSymbol(123);                  // false
- * isSymbol(undefined);            // false
- */
-declare const isSymbol:(value:unknown)=>value is symbol;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is an instance of the `URL` class.***
- * ---------------------------------------------------------
- *
- * @param {unknown} val - The value to check.
- * @returns {val is URL} Returns `true` if the value is a `URL` instance, otherwise `false`.
- *
- * @example
- * isURL(new URL("https://example.com")); // true
- * isURL("https://example.com");          // false
- */
-declare const isURL:(val:unknown)=>val is URL;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is `undefined`.***
- * ---------------------------------------------------------
- *
- * @param {unknown} val - The value to check.
- * @returns {val is undefined} Returns `true` if the value is `undefined`, otherwise `false`.
- *
- * @example
- * isUndefined(undefined); // true
- * isUndefined(null);      // false
- */
-declare const isUndefined:(val:unknown)=>val is undefined;
-/** ---------------------------------
- * * ***Validates whether a given string is a properly formatted URL.***
- * ---------------------------------
- *
- * This function checks if the input string follows a valid URL format,
- * including `http` or `https` protocols.
- *
- * @param {string} [url] - The URL string to validate.
- * @returns {boolean} `true` if the URL is valid, otherwise `false`.
- */
-declare const isValidURL:(url?:string | null)=>boolean;
-/** ----------------------------------------------------------
- * * ***Checks if the given `text` contains all of the specified `searchWords`.***
- * ----------------------------------------------------------
- *
- * - ✅ Uses **regular expressions** for flexible pattern matching.
- * - ✅ **Escapes special characters** to prevent regex injection attacks.
- * - ✅ **Trims input** to avoid false positives with empty spaces.
- * - ✅ **Supports exact word matching** (optional).
- *
- * @param {string} text - The text to search within.
- * @param {string[]} searchWords - An array of words/phrases to match against the text.
- * @param {boolean} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.
- * @param {string} [options.flags="i"] - Optional regex flags (default: `"i"` for case-insensitive).
- * @returns {boolean} - `true` if all `searchWords` are found in `text`, otherwise `false`.
- *
- * @example
- * textContainsAll("Hello world, WithAI APP", ["Hello", "world"]); // true
- * textContainsAll("JavaScript and TypeScript", ["Java", "Script"]); // true
- * textContainsAll("Machine Learning", ["AI", "Learning"]); // false
- * textContainsAll("open-source", ["open"], { exactMatch: true }); // false (because options `exactMatch=true`)
- */
-declare const textContainsAll:<T extends string>(text:T,searchWords:T[] | string[],options?:{
-/** If `true`, matches whole words only, defaultValue is `false`. */
-exactMatch?:boolean;
-/** Optional regex flags (default: `"i"` for case-insensitive). */
-flags?:string;})=>boolean;
-/** ----------------------------------------------------------
- * * ***Checks if the given `text` contains at least one of the specified `searchWords`.***
- * ----------------------------------------------------------
- *
- * - ✅ Uses **regular expressions** for flexible pattern matching.
- * - ✅ **Escapes special characters** to prevent regex injection attacks.
- * - ✅ **Trims input** to avoid false positives with empty spaces.
- * - ✅ **Supports exact word matching** (optional).
- *
- * @param {string} text - The text to search within.
- * @param {string[]} searchWords - An array of words/phrases to match against the text.
- * @param {boolean} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.
- * @param {string} [options.flags="i"] - Optional regex flags (default: `"i"` for case-insensitive).
- * @returns {boolean} - `true` if at least one `searchWord` is found in `text`, otherwise `false`.
- *
- * @example
- * textContainsAny("Hello world", ["hello", "test"]); // true
- * textContainsAny("withAI APP", ["chat", "ai"]); // false
- * textContainsAny("TypeScript is great!", ["script", "java"]); // true
- * textContainsAny("open-source", ["open"], { exactMatch: true }); // false (because options `exactMatch=true`)
- */
-declare const textContainsAny:<T extends string>(text:T,searchWords:T[] | string[],options?:{
-/** If `true`, matches whole words only, defaultValue is `false`. */
-exactMatch?:boolean;
-/** Optional regex flags (default: `"i"` for case-insensitive). */
-flags?:string;})=>boolean;
-/** ----------------------------------------------------
- * * ***Get the precise JavaScript type of any value.***
- * ----------------------------------------------------
- *
- * Features:
- * - Handles all ECMAScript built-in types, including edge cases and naming inconsistencies.
- * - Always returns result in PascalCase with spaces (e.g., "Big Uint 64 Array").
- * - Normalizes incorrect or environment-specific type names (e.g., "finalizationregistry" → "FinalizationRegistry").
- *
- * @param value - The value to check.
- * @returns The precise type name in PascalCase with spaces.
- *
- * Examples:
- * ```ts
- * getPreciseType([]); // "Array"
- * getPreciseType(new Map()); // "Map"
- * getPreciseType(new FinalizationRegistry(() => {})); // "Finalization Registry"
- * getPreciseType(BigInt(10)); // "Big Int"
- * ```
- */
-declare const getPreciseType:(value:unknown)=>string;type IsObjectOrArray<T>=unknown extends T ? Record<string,unknown>| unknown[]:T extends object ? T extends unknown[] ? T:T extends NonPlainObject ? never:T:never;
-/** ---------------------------------------------------------
- * * ***Type guard: Checks if a value is an object or array.***
- * ---------------------------------------------------------
- *
- * Will return `false` for `null`, `undefined`, and primitives.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is object} Returns `true` if the value is an object or array.
- *
- * @example
- * isObjectOrArray({ name: "Alice" }); // true
- * isObjectOrArray([1,2,3]);           // true
- * isObjectOrArray(null);              // false
- * isObjectOrArray(undefined);         // false
- * isObjectOrArray("hello");           // false
- */
-declare function isObjectOrArray<T>(value:T):value is IsObjectOrArray<T>;
-/** -------------------
- * * ***Checks if `value` is likely an `arguments` object.***
- * -------------------
- *
- * @param {*} value The value to check.
- *
- * @returns {boolean} Returns `true` if `value` is an `arguments` object,
- *  else `false`.
- *
- * @example
- *
- * isArguments(function() { return arguments; }());
- * // => true
- *
- * isArguments([1, 2, 3]);
- * // => false
- */
-declare const isArguments:(value:unknown)=>value is IArguments;
-/** ----------------------------------------------------
- * * ***Checks if `value` is classified as an `ArrayBuffer` object.***
- * ----------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
- *
- * @example
- *
- * isArrayBuffer(new ArrayBuffer(2));
- * // => true
- *
- * isArrayBuffer(new Array(2));
- * // => false
- */
-declare function isArrayBuffer(value:unknown):value is ArrayBuffer;
-/** ----------------------------------------------------
- * * ***Checks if `value` is array-like. A value is considered array-like if it's
- * not a function and has a `value.length` that's an integer greater than or
- * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.***
- * ----------------------------------------------------
- *
- * @param {*} value The value to check.
- *
- * @returns Returns `true` if `value` is array-like, else `false`.
- *
- * @example
- * isArrayLike([1, 2, 3]);
- * // => true
- *
- * isArrayLike(document.body.children);
- * // => true
- *
- * isArrayLike('abc');
- * // => false
- *
- * isArrayLike(noop);
- * // => false
- */
-declare function isArrayLike<T extends{__anyHack:unknown;}>(value:T):boolean;declare function isArrayLike(value:((...args:any[])=>any)| null | undefined):value is never;declare function isArrayLike(value:unknown):value is{length:number;};
-/** ----------------------------------------------------
- * * ***This method is like `isArrayLike` except that it also checks if `value` is an object.***
- * ----------------------------------------------------
- *
- * @param {*} value The value to check.
- *
- * @returns Returns `true` if `value` is array-like object, else `false`.
- *
- * @example
- * isArrayLikeObject([1, 2, 3]);
- * // => true
- *
- * isArrayLikeObject(document.body.children);
- * // => true
- *
- * isArrayLikeObject('abc');
- * // => false
- *
- * isArrayLikeObject(noop);
- * // => false
- */
-declare function isArrayLikeObject<T extends{__anyHack:unknown;}>(value:T):boolean;declare function isArrayLikeObject(value:AnyFunction | string | boolean | number | null | undefined):value is never;declare function isArrayLikeObject(value:unknown):value is object &{length:number;};
-/** ----------------------------------------------------
- * * ***Checks if value is a buffer.***
- * ----------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
- * @example
- *
- * isBuffer(new Buffer(2));
- * // => true
- *
- * isBuffer(new Uint8Array(2));
- * // => false
- */
-declare const isBuffer:(value:unknown)=>value is Buffer;
-/** ----------------------------------------------------
- * * ***Checks if `value` is likely a DOM element.***
- * ----------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
- * @example
- *
- * isElement(document.body);
- * // => true
- *
- * isElement('<body>');
- * // => false
- *
- * isElement(document.createElement("div"));
- * // => true
- */
-declare function isElement(value:unknown):boolean;type EmptyObject<T>={[K in keyof T]?:never;};type EmptyObjectOf<T>=EmptyObject<T>extends T ? EmptyObject<T>:never;type List<T>=ArrayLike<T>;
-/** ----------------------------------------------------
- * * ***Checks if `value` is an empty object, collection, map, or set.***
- * ----------------------------------------------------
- *
- * Objects are considered empty if they have no own enumerable string keyed
- * properties.
- *
- * Array-like values such as `arguments` objects, arrays, buffers, strings, or
- * jQuery-like collections are considered empty if they have a `length` of `0`.
- * Similarly, maps and sets are considered empty if they have a `size` of `0`.
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is empty, else `false`.
- * @example
- *
- * isEmpty(null);
- * // => true
- *
- * isEmpty(true);
- * // => true
- *
- * isEmpty(1);
- * // => true
- *
- * isEmpty([1, 2, 3]);
- * // => false
- *
- * isEmpty({ 'a': 1 });
- * // => false
- */
-declare function isEmpty<T extends{__trapAny:any;}>(value?:T):boolean;declare function isEmpty(value:string):value is "";declare function isEmpty(value:Map<any,any>| Set<any>| List<any>| null | undefined):boolean;declare function isEmpty(value:object):boolean;declare function isEmpty<T extends object>(value:T | null | undefined):value is EmptyObjectOf<T>| null | undefined;declare function isEmpty(value:any):boolean;
-/** ----------------------------------------------------
- * * ***Performs a deep comparison between two values to determine if they are equivalent.***
- * ----------------------------------------------------
- *
- * **Note:** This method supports comparing arrays, array buffers, booleans,
- * date objects, error objects, maps, numbers, `Object` objects, regexes,
- * sets, strings, symbols, and typed arrays. `Object` objects are compared
- * by their own, not inherited, enumerable properties. Functions and DOM
- * nodes are **not** supported.
- *
- *
- * @param value The value to compare.
- * @param other The other value to compare.
- * @returns Returns `true` if the values are equivalent, else `false`.
- *
- * @example
- *
- * const object = { user: "fred" };
- * const other = { user: "fred" };
- *
- * isEqual(object, other);
- * // => true
- *
- * object === other;
- * // => false
- */
-declare function isEqual(value:unknown,other:unknown):boolean;type IsEqualCustomizer=(value:any,other:any,indexOrKey:PropertyKey | undefined,parent:any,otherParent:any,stack:any)=>boolean | undefined;
-/** ----------------------------------------------------
- * * ***This method is like `isEqual` except that it accepts `customizer` which
- * is invoked to compare values. If `customizer` returns `undefined`, comparisons
- * are handled by the method instead. The `customizer` is invoked with up to
- * six arguments: (objValue, othValue [, index|key, object, other, stack]).***
- * ----------------------------------------------------
- *
- * @param {*} value The value to compare.
- * @param {*} other The other value to compare.
- * @param {Function} [customizer] The function to customize comparisons.
- * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
- * @example
- *
- * function isGreeting(value) {
- *   return /^h(?:i|ello)$/.test(value);
- * }
- *
- * function customizer(objValue, othValue) {
- *   if (isGreeting(objValue) && isGreeting(othValue)) {
- *     return true;
- *   }
- * }
- *
- * var array = ['hello', 'goodbye'];
- * var other = ['hi', 'goodbye'];
- *
- * isEqualWith(array, other, customizer);
- * // => true
- */
-declare function isEqualWith(value:unknown,other:unknown,customizer?:IsEqualCustomizer):boolean;
-/** -----------------------------------------------------------------------------
- * * Checks if `value` is a finite number (not `Infinity`, `-Infinity`, or `NaN`).
- * -----------------------------------------------------------------------------
- *
- * This method is based on
- * [`Number.isFinite()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite).
- * It returns `true` only for values that are of type `number` and are finite.
- *
- * @param {*} value - The value to check.
- * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
- *
- * @example
- *
- * isFinite(3);
- * // => true
- *
- * isFinite(Number.MIN_VALUE);
- * // => true
- *
- * isFinite(Infinity);
- * // => false
- *
- * isFinite("3");
- * // => false
- */
-declare function isFinite$1(value?:unknown):boolean;
-/** ----------------------------------------------------
- * * ***Checks if `value` is a integer.***
- * ----------------------------------------------------
- *
- * **Note:** This method is based on
- * [`Number.isInteger`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger).
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
- * @example
- *
- * isInteger(3);
- * // => true
- *
- * isInteger(Number.MIN_VALUE);
- * // => false
- *
- * isInteger(Infinity);
- * // => false
- *
- * isInteger('3');
- * // => false
- */
-declare function isInteger(value?:unknown):boolean;
-/** ----------------------------------------
- * * ***Checks if `value` is a valid array-like length.***
- * ----------------------------------------
- *
- * **Note:** This method is loosely based on
- * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
- * @example
- *
- * isLength(3); // => true
- * isLength(Number.MIN_VALUE); // => false
- * isLength(Infinity); // => false
- * isLength('3'); // => false
- * isLength(4294967296); // => true
- *
- */
-declare function isLength(value:unknown):boolean;
-/** ----------------------------------------------------
- * * ***Performs a partial deep comparison between `object` and `source` to determine if `object` contains equivalent property values.***
- * ----------------------------------------------------
- *
- * - This method returns `true` if all the properties in `source` exist in `object` and are deeply equal.
- * - It does **not** require `object` and `source` to be the same shape—only that `object` contains a subset that matches `source`.
- *
- * ⚠️ Arrays are treated as objects: only the matching indexed keys are compared.
- *
- * @remarks
- * - This method is equivalent to a partially applied `matches(source)` predicate.
- * - Partial comparisons will match:
- *   - An empty array (`[]`) in `source` with any array in `object`.
- *   - An empty object (`{}`) in `source` with any object in `object`.
- *
- * @param object - The object to inspect.
- * @param source - The object containing property values to match.
- * @returns Returns `true` if `object` is a match, else `false`.
- *
- * @example
- * const object = { a: 1, b: 2 };
- *
- * isMatch(object, { b: 2 });
- * // => true
- *
- * isMatch(object, { b: 1 });
- * // => false
- *
- * isMatch([1, 2, 3], [1, 2]);
- * // => true (treats arrays as objects with index keys)
- */
-declare function isMatch(object:object,source:object):boolean;type isMatchWithCustomizer=(value:any,other:any,indexOrKey:PropertyKey,object:object,source:object)=>boolean | undefined;
-/** ----------------------------------------------------
- * * ***Performs a partial deep comparison between `object` and `source`,
- *   like `isMatch`, but with a `customizer` function to control comparisons.***
- * ----------------------------------------------------
- *
- * If `customizer` returns a value other than `undefined`, that value is used
- * as the result of the comparison for the current property. Otherwise,
- * the comparison falls back to the default deep equality logic.
- *
- * @remarks
- * - The `customizer` function is invoked with up to **five** arguments:
- *   `(objValue, srcValue, keyOrIndex, object, source)`.
- * - Returning `true` from `customizer` will short-circuit further comparison
- *   for that key.
- * - Returning `false` will cause `isMatchWith` to return `false` immediately.
- * - Returning `undefined` allows default comparison to proceed.
- *
- * @category Lang
- *
- * @param object - The object to inspect.
- * @param source - The object of property values to match.
- * @param customizer - The function to customize comparisons.
- * @returns Returns `true` if `object` is a match, else `false`.
- *
- * @example
- * function isGreeting(value: unknown) {
- *   return typeof value === 'string' && /^h(?:i|ello)$/.test(value);
- * }
- *
- * function customizer(objValue: unknown, srcValue: unknown) {
- *   if (isGreeting(objValue) && isGreeting(srcValue)) {
- *     return true;
- *   }
- * }
- *
- * const object = { greeting: 'hello' };
- * const source = { greeting: 'hi' };
- *
- * isMatchWith(object, source, customizer);
- * // => true
- */
-declare function isMatchWith(value:object,other:object,customizer?:isMatchWithCustomizer):boolean;
-/** ----------------------------------------------------
- * * ***Checks if `value` is `NaN`.***
- * ----------------------------------------------------
- *
- * **Note:** This method is based on
- * [`Number.isNaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) and is not the same as
- * global [`isNaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN) which returns `true` for
- * `undefined` and other non-number values.
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
- * @example
- *
- * import * as RzlUtilsJs from "@rzl-zone/utils-js";
- *
- * RzlUtilsJs.isNaN(NaN); // => true
- *
- * RzlUtilsJs.isNaN(new Number(NaN)); // => true
- *
- * RzlUtilsJs.isNaN(undefined); // => false
- *
- * // This global isNaN:
- * isNaN(undefined); // => true
- */
-declare function isNaN$1(value?:unknown):boolean;
-/** ----------------------------------------------------
- * * ***Checks if `value` is a pristine native function.***
- * ----------------------------------------------------
- *
- * **Note:** This method can't reliably detect native functions in the presence
- * of the core-js package because core-js circumvents this kind of detection.
- * Despite multiple requests, the core-js maintainer has made it clear: any
- * attempt to fix the detection will be obstructed. As a result, we're left
- * with little choice but to throw an error. Unfortunately, this also affects
- * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
- * which rely on core-js.
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a native function,
- *  else `false`.
- * @example
- *
- * isNative(Array.prototype.push);
- * // => true
- *
- * import * as RzlUtilsJs from "@rzl-zone/utils-js";
- * isNative(RzlUtilsJs);
- * // => false
- */
-declare function isNative(value?:unknown):value is AnyFunction;
-/** ----------------------------------------------------
- * * ***Checks if `value` is `null` or `undefined`.***
- * ----------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
- * @example
- *
- * isNil(null);
- * // => true
- *
- * isNil(void 0);
- * // => true
- *
- * isNil(NaN);
- * // => false
- */
-declare function isNil(value?:unknown):value is null | undefined;
-/** --------------------------------------------------
- * * ***Checks if `value` is the
- * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
- * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)***
- * --------------------------------------------------
- *
- * @note
- * ⚠ **For More Strict Object Use `isObject` instead.**
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an object, else `false`.
- * @example
- *
- * isObjectLoose({});
- * // => true
- *
- * isObjectLoose([1, 2, 3]);
- * // => true
- *
- * isObjectLoose(noop);
- * // => true
- *
- * isObjectLoose(null);
- * // => false
- *
- * isObjectLoose(undefined);
- * // => false
- */
-declare function isObjectLoose<T=object>(value:unknown):value is T;
-/** ----------------------------------------------------
- * * ***Checks if `value` is a plain object, that is, an object created by the `Object` constructor or one with a `[[Prototype]]` of `null`..***
- * ----------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
- * @example
- *
- * function Foo() {
- *   this.a = 1;
- * }
- *
- * isPlainObject(new Foo);
- * // => false
- *
- * isPlainObject([1, 2, 3]);
- * // => false
- *
- * isPlainObject({ 'x': 0, 'y': 0 });
- * // => true
- *
- * isPlainObject(Object.create(null));
- * // => true
- */
-declare function isPlainObject(value:unknown):value is Record<string,unknown>;declare function isPlainObject<T>(value:T):value is NonNullable<Extract<T,Record<string,unknown>>>;
-/** --------------------------------------------------
- * * ***Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 double precision number which isn't the result of a rounded unsafe integer.***
- * --------------------------------------------------
- *
- * **Note:** This method is based on
- * [`Number.isSafeInteger`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
- * @example
- *
- * isSafeInteger(3);
- * // => true
- *
- * isSafeInteger(Number.MIN_VALUE);
- * // => false
- *
- * isSafeInteger(Infinity);
- * // => false
- *
- * isSafeInteger('3');
- * // => false
- */
-declare function isSafeInteger(value:unknown):value is number;
-/** --------------------------------------------------
- * * ***Checks if `value` is classified as a `Set` object.***
- * --------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a set, else `false`.
- * @example
- *
- * isSet(new Set);
- * // => true
- *
- * isSet(new WeakSet);
- * // => false
- */
-declare function isSet<T=any>(value:Set<T>):value is Set<T>;declare function isSet(value:unknown):value is Set<any>;
-/** --------------------------------------------------
- * * ***Checks if `value` is classified as a typed array.***
- * --------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
- * @example
- *
- *
- * isTypedArray(new Uint8Array);          // => true
- * isTypedArray(new Uint8Array());        // => true
- * isTypedArray(new Float32Array());      // => true
- * isTypedArray(new Uint8ClampedArray()); // => true
- * isTypedArray([]);                      // => false
- * isTypedArray(Buffer.from("hi"));       // => false
- */
-declare function isTypedArray(value:unknown):value is TypedArray;
-/** --------------------------------------------------
- * * ***Checks if `value` is classified as a `WeakMap` object.***
- * --------------------------------------------------
- *
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
- * @example
- *
- * isWeakMap(new WeakMap);
- * // => true
- *
- * isWeakMap(new Map);
- * // => false
- */
-declare function isWeakMap<K extends object=object,V=unknown>(value:unknown):value is WeakMap<K,V>;
-/** ----------------------------------------
- * * ***Creates a delay for a specified duration.***
- * ----------------------------------------
- *
- * @param {number} [milliSeconds=1000] - The duration of the delay in milliSeconds (default: 1000ms).
- * @param {AbortSignal} [signal] - An optional AbortSignal to cancel the delay.
- * @returns {Promise<void>} A promise that resolves after the specified delay or rejects if aborted.
- *
- * @throws {TypeError} If `milliSeconds` is not a valid non-negative number.
- * @throws {TypeError} If `signal` is not a valid AbortSignal.
- * @throws {DOMException} If aborted, rejects with `AbortError`.
- *
- * @example
- * await delay(2000); // waits for 2 seconds
- *
- * // With AbortSignal
- * const controller = new AbortController();
- * delay(5000, controller.signal).catch(err => console.log(err.name)); // "AbortError"
- * controller.abort();
- */
-declare const delay:(milliSeconds?:number,signal?:AbortSignal)=>Promise<void>;
-/** ----------------------------------------------------------
- * * Capitalizes the first letter of a string.
- * * Optionally lowercases the rest and trims whitespace.
- * ----------------------------------------------------------
- *
- * @param string - The string to be processed.
- * @param options - Options to control behavior.
- * @param options.lowerCaseNextRest - If true, lowercases the rest (next first letter) (default: true).
- * @param options.trim - If true, trims the string before processing (default: false).
- * @returns The processed string. Returns "" if input is null, undefined, or not a valid string.
- *
- * @example
- * capitalizeFirst(" hello WORLD ") // " Hello world"
- * capitalizeFirst(" hello WORLD ", { trim: true }) // "Hello world"
- * capitalizeFirst("FOO", { lowerCaseNextRest: false }) // "FOO"
- * capitalizeFirst("   foo BAR   ", { trim: true, lowerCaseNextRest: false }) // "Foo BAR"
- */
-declare const capitalizeFirst:(string?:string | null,options?:{
-/**
-	 * @description If true, the rest of the string will be converted to lowercase after capitalizing the first letter.
-	 *  @default true
-	 */
-lowerCaseNextRest?:boolean;
-/**
-	 * @description If true, the string will trimmed.
-	 *  @default false
-	 */
-trim?:boolean;})=>string;
-/** ----------------------------------------------------------
- * * ***Capitalizes the first letter of each word in a string
- * while converting the rest to lowercase.***
- * ----------------------------------------------------------
- *
- * @param value - The input string to be processed. If `null` or `undefined`, returns an empty string.
- * @param options - Optional settings to control the output:
- *   - `trim`: If `true`, removes leading and trailing spaces.
- *   - `collapseSpaces`: If `true`, collapses multiple spaces **between words** into a single space (while preserving leading/trailing spaces).
- *
- * @returns A new string where each word starts with an uppercase letter
- * and the remaining letters are lowercase. If `value` is empty, `null`, or `undefined`,
- * returns an empty string.
- *
- * @example
- * capitalizeWords("  hello   world  ");
- * // => "  Hello   World  "
- *
- * capitalizeWords("  hello   world  ", { trim: true });
- * // => "Hello   World"
- *
- * capitalizeWords("  hello   world  ", { collapseSpaces: true });
- * // => "  Hello World  "
- *
- * capitalizeWords("  hello   world  ", { trim: true, collapseSpaces: true });
- * // => "Hello World"
- */
-declare const capitalizeWords:(value?:string | null,options?:{
-/** If `true`, removes leading and trailing spaces, default `false`. */
-trim?:boolean;
-/** If `true`, collapses multiple spaces **between words** into a single space (while preserving leading/trailing spaces), default `false`. */
-collapseSpaces?:boolean;})=>string;
-/** ----------------------------------------------------------
- * * ***Converts a string to `camelCase`.***
- * ----------------------------------------------------------
- *
- * @description
- * - Splits the string by any sequence of non-alphanumeric characters
- *   (including spaces, punctuation, symbols, hyphens, underscores, emojis, etc).
- * - The first word is fully lowercase.
- * - Each subsequent word starts with an uppercase letter and the rest is lowercase.
- * - Joins all words without separators to form camelCase.
- * - If input is `null` or `undefined`, returns an empty string.
- * - Ignores empty segments (multiple delimiters are collapsed).
- *
- * @param {string | null | undefined} value - The input string to be convert. If `null` or `undefined`, returns an empty string.
- * @returns {string} The camelCase formatted string.
- *
- * @example
- * toCamelCase("hello world");                  // "helloWorld"
- * toCamelCase("convert_to-camel case");        // "convertToCamelCase"
- * toCamelCase("___hello--world__ again!!");    // "helloWorldAgain"
- * toCamelCase("🔥fire_and-ice❄️");             // "fireAndIce"
- * toCamelCase(null);                           // ""
- */
-declare const toCamelCase:(value?:string | null)=>string;
-/** ----------------------------------------------------------
- * * ***Converts a string to `PascalCase`.***
- * ----------------------------------------------------------
- *
- * @description
- * - Splits the string by any sequence of non-alphanumeric characters
- *   (including spaces, punctuation, symbols, hyphens, underscores, emojis, etc).
- * - Each resulting word starts with an uppercase letter, followed by lowercase.
- * - Joins all words without separators (PascalCase).
- * - If input is `null` or `undefined`, returns an empty string.
- * - Ignores empty segments (multiple delimiters are collapsed).
- *
- * @param {string | null | undefined} value - The input string to be convert. If `null` or `undefined`, returns an empty string.
- * @returns {string} The PascalCase formatted string.
- *
- * @example
- * toPascalCase("hello world");                  // "HelloWorld"
- * toPascalCase("convert_to-pascal case");       // "ConvertToPascalCase"
- * toPascalCase("___hello--world__ again!!");    // "HelloWorldAgain"
- * toPascalCase("🔥fire_and-ice❄️");             // "FireAndIce"
- * toPascalCase(null);                           // ""
- */
-declare const toPascalCase:(value?:string | null)=>string;
-/** ----------------------------------------------------------
- * * ***Converts a string to `kebab-case`.***
- * ----------------------------------------------------------
- *
- * @description
- * - Splits the string by any sequence of non-alphanumeric characters
- *   (spaces, hyphens, underscores, symbols, emojis, etc).
- * - Joins all words with hyphens (-).
- * - Converts entire string to lowercase.
- * - If input is `null` or `undefined`, returns an empty string.
- * - Ignores empty segments (multiple delimiters are collapsed).
- *
- * @param {string | null | undefined} value - The input string to be convert. If `null` or `undefined`, returns an empty string.
- * @returns {string} The kebab-case formatted string.
- *
- * @example
- * toKebabCase("Hello World");                 // "hello-world"
- * toKebabCase("convert_to-kebab case");       // "convert-to-kebab-case"
- * toKebabCase("🔥fire___and--ice❄️");         // "fire-and-ice"
- * toKebabCase(null);                          // ""
- */
-declare const toKebabCase:(value?:string | null)=>string;
-/** ----------------------------------------------------------
- * * ***Converts a string to `snake_case`.***
- * ----------------------------------------------------------
- *
- * @description
- * - Lowercases all letters.
- * - Joins words with `_`.
- * - Removes special characters, treating them as word separators.
- * - If input is `null` or `undefined`, returns "".
- *
- * @param {string | null | undefined} value - The input string to be convert. If `null` or `undefined`, returns an empty string.
- * @returns {string} snake_case string
- *
- * @example
- * toSnakeCase("Hello World") => "hello_world"
- * toSnakeCase("convert-to_snake case") => "convert_to_snake_case"
- */
-declare const toSnakeCase:(value?:string | null)=>string;
-/** ----------------------------------------------------------
- * * ***Converts a string to `dot.case`.***
- * ----------------------------------------------------------
- *
- * @description
- * - Lowercases all letters.
- * - Joins words with `.`.
- * - Removes special characters, treating them as word separators.
- * - If input is `null` or `undefined`, returns "".
- *
- * @param {string | null | undefined} value - The input string to be convert. If `null` or `undefined`, returns an empty string.
- * @returns {string} dot.case string
- *
- * @example
- * toDotCase("Hello World") => "hello.world"
- * toDotCase("convert-to_dot case") => "convert.to.dot.case"
- */
-declare const toDotCase:(value?:string | null)=>string;
-/** ----------------------------------------------------------
- * * ***Slugifies a string for use in URLs.***
- * ----------------------------------------------------------
- *
- * @description
- * - Lowercases all letters.
- * - Joins words with `-`.
- * - Removes special characters and trims leading/trailing dashes.
- * - If input is `null` or `undefined`, returns "".
- *
- * @param {string | null | undefined} value - The input string to be convert. If `null` or `undefined`, returns an empty string.
- * @returns {string} slug string
- *
- * @example
- * slugify("Hello World!") => "hello-world"
- * slugify(" --- Convert to Slug? --- ") => "convert-to-slug"
- */
-declare const slugify:(value?:string | null)=>string;
-/** ----------------------------------------------------------
- * * ***Normalizes whitespace in a string by reducing multiple spaces
- * to a single space, optionally trims, or only trims based on options.***
- * ----------------------------------------------------------
- *
- * - ✅ Collapses all consecutive whitespace (spaces, tabs, newlines) into a single space.
- * - ✅ Can trim leading/trailing spaces (default behavior), or preserve them with `withTrim: false`.
- * - ✅ Can skip normalization entirely and only trim using `trimOnly: true`.
- * - ✅ Returns an empty string if input is `null` or `undefined`.
- *
- * @param {string} [value] - The input string to be processed. If `null` or `undefined`, returns an empty string.
- * @param {object} [options] - Configuration options.
- * @param {boolean} [options.trimOnly=false] - If `true`, skips normalization and only trims the string.
- * @param {boolean} [options.withTrim=true] - If `false`, preserves leading/trailing whitespace.
- *
- * @returns {string} The processed string.
- *
- * @example
- * normalizeSpaces("   Hello    World\tthis   is\n\nok ");
- * // "Hello World this is ok"
- *
- * normalizeSpaces("   Hello    World\tthis   is\n\nok ", { trimOnly: true });
- * // "Hello    World	this   is\n\nok"
- *
- * normalizeSpaces("   Hello    World   ", { withTrim: false });
- * // " Hello World "
- *
- * normalizeSpaces(null);
- * // ""
- */
-declare const normalizeSpaces:(value?:string | null,options?:{
-/**
-	 * If `true`, skips normalization and only trims whitespace from start & end.
-	 * @default false */
-trimOnly?:boolean;
-/**
-	 * If `false`, skips trimming value.
-	 * @default true */
-withTrim?:boolean;})=>string;
-/** ----------------------------------------------------------
- * * ***Normalizes a string by ensuring it is a valid string and trimming whitespace.***
- * ----------------------------------------------------------
- *
- * @description
- * If the input is `undefined`, `null`, or an `empty string` after trimming,
- * it returns an empty string `("")`.
- *
- * @param {string | undefined | null} input - The input string to be normalize. If `null` or `undefined`, returns an empty string.
- * @returns {string} A trimmed string or an empty string if the input is invalid.
- *
- * @example
- * normalizeString("   Hello World   ");
- * // → "Hello World"
- *
- * normalizeString("");
- * // → ""
- *
- * normalizeString(null);
- * // → ""
- *
- * normalizeString(undefined);
- * // → ""
- */
-declare const normalizeString:(input?:string | null)=>string;
-/** ----------------------------------------------------------
- * * ***Removes all spaces from a string or trims only, based on the options provided.***
- * ----------------------------------------------------------
- *
- * @description
- * - If `trimOnly` is `true`, the string is simply trimmed.
- * - Otherwise, removes **all spaces**, tabs, newlines, etc.
- * - If the input is `null` or `undefined`, returns an empty string `("")`.
- *
- * @param {string | null | undefined} value - The input string to be processed. If `null` or `undefined`, returns an empty string.
- * @param {object} [options] - The options object.
- * @param {boolean} [options.trimOnly=false] - If `true`, only trims the string without removing spaces inside.
- * @returns {string} The processed string.
- *
- * @example
- * removeSpaces("  Hello   World  ");
- * // → "HelloWorld"
- *
- * removeSpaces("  Hello   World  ", { trimOnly: true });
- * // → "Hello   World"
- *
- * removeSpaces(null);
- * // → ""
- */
-declare const removeSpaces:(value?:string | null,options?:{
-/**
-	 * @description If true, only trims the string.
-	 *
-	 * @default false */
-trimOnly?:boolean;})=>string;
-/** ----------------------------------------------------------
- * * ***Removes all HTML tags from a given string.***
- * ----------------------------------------------------------
- *
- * This function removes valid HTML tags (including nested and self-closing ones)
- * by replacing them with spaces, then collapses multiple whitespaces into a single space.
- *
- * It handles the following cases:
- * - If the input is not a string (`null`, `undefined`, or any non-string), it is returned as undefined.
- * - If the input is an empty or whitespace-only string, it returns an empty string (`""`).
- * - Otherwise, it returns the cleaned string with tags removed and normalized whitespace.
- *
- * @template T - Input string type (string | null | undefined).
- * @param {T} [input] - A string potentially containing HTML tags.
- * @returns {T extends string ? string : T} - Cleaned string if input is string, or original input otherwise.
- *
- * @example
- * stripHtmlTags("<p>Hello</p>"); // "Hello"
- * stripHtmlTags("<div><b>Bold</b> text</div>"); // "Bold text"
- * stripHtmlTags("Line<br/>Break"); // "Line Break"
- * stripHtmlTags("2 < 5 and 5 > 2"); // "2 < 5 and 5 > 2"
- * stripHtmlTags(""); // ""
- * stripHtmlTags("   "); // ""
- * stripHtmlTags(null); // undefined
- * stripHtmlTags(undefined); // undefined
- */
-declare const stripHtmlTags:<T extends string | null | undefined=undefined>(input?:T)=>T extends string ? string:undefined;
-/** ----------------------------------------------------------
- * * ***Replaces a substring at a specified index within a string.***
- * ----------------------------------------------------------
- *
- * @description
- * Replaces exactly one character at the specified index in the original string
- * with the provided `replaceTo` string. If `replaceTo` has more than one character,
- * the result will expand accordingly.
- *
- * @param {number} index - The starting index where the replacement should occur.
- * @param {string} originalString - The original string to modify.
- * @param {string} replaceTo - The string to insert at the specified index.
- * @returns {string} - The modified string with the replacement applied.
- *
- * @example
- * replaceAt(3, "hello", "X");
- * // → "helXo"
- *
- * replaceAt(1, "world", "AB");
- * // → "wABrld"
- *
- * replaceAt(0, "cat", "br");
- * // → "brat"
- *
- * replaceAt(2, "12345", "-");
- * // → "12-45"
- *
- * replaceAt(4, "ABCDE", "Z");
- * // → "ABCDZ"
- *
- * // ❌ Examples that throw:
- * replaceAt(10, "short", "X");
- * // → ❌ RangeError: Index parameter is out of range at function `replaceAt`
- *
- * replaceAt(-1, "test", "X");
- * // → ❌ RangeError: Index parameter is out of range at function `replaceAt`
- *
- * replaceAt("1", "test", "X");
- * // → ❌ TypeError: Expected 'index' to be a number, and 'replaceTo' and 'originalString' to be strings
- *
- * replaceAt(2, null, "X");
- * // → ❌ TypeError: Expected 'index' to be a number, and 'replaceTo' and 'originalString' to be strings
- */
-declare const replaceAt:(index:number,originalString:string,replaceTo:string)=>string;
-/** ----------------------------------------------------------
- * * ***Extracts initials from a given name.***
- * ----------------------------------------------------------
- *
- * @description
- * Extracts initials from the given name string.
- * - For names with two or more words, returns the first letter of the first and second words.
- * - For a single word with 2+ characters, returns the first two letters.
- * - For a single character, returns that character.
- * - For empty, null, or whitespace-only input, returns an empty string.
- *
- * @param {string} [name=""] - The name to extract initials from.
- * @returns {string} The extracted initials (e.g., "JD" for "John Doe").
- *
- * @example
- * getInitialsName("John Doe");            // "JD"
- * getInitialsName("Alice");               // "AL"
- * getInitialsName(" Bob Marley ");        // "BM"
- * getInitialsName("John Ronald Donal");   // "JR"
- * getInitialsName("Lord John Doe Moe");   // "LJ"
- * getInitialsName("X");                   // "X"
- * getInitialsName("  ");                  // "" (empty string)
- * getInitialsName("");                    // "" (empty string)
- * getInitialsName(null);                  // "" (null input)
- * getInitialsName(undefined);             // "" (undefined input)
- */
-declare const getInitialsName:(name?:string | null)=>string;type UnionToIntersectionStrict<U>=(U extends never ? never:(arg:U)=>never)extends(arg:infer I)=>void ? I:never;type UnionToTupleStrict<T>=UnionToIntersectionStrict<T extends never ? never:(t:T)=>T>extends(_:never)=>infer W ? [...UnionToTupleStrict<Exclude<T,W>>,W]:[];
-/** ----------------------------------------------------------
- * * ***Creates a helper for styled-components `shouldForwardProp`.***
- * ----------------------------------------------------------
- *
- * @description
- * This utility returns a predicate function that determines
- * whether a given prop should be forwarded to the DOM.
- * Useful for filtering out internal props (e.g., `$size`, `$active`)
- * so they don't end up as invalid HTML attributes.
- *
- * - Accepts a tuple (strict) of prop keys to exclude from forwarding.
- * - Automatically coerces prop names to string for consistent checking.
- * - Supports string, number, or symbol keys (via PropertyKey).
- * - Will throw an error if the provided `props` argument is not an array.
- *
- * @template CustomProps - The type of the component's props.
- * @param {UnionToTupleStrict<keyof CustomProps>} props
- *   The list of prop names (keys of `CustomProps`) to exclude from forwarding.
- *
- * @returns {(propName: PropertyKey) => boolean}
- *   A function that takes a prop name and returns `true` if it should be forwarded, `false` if it should be blocked.
- *
- * @throws {Error} If `props` is not an array.
- *
- * @example
- * type Props = { $size: string; color: string; visible: boolean };
- * const filter = shouldForwardProp<Props>(["$size"]);
- * filter("$size"); // false (blocked)
- * filter("color"); // true (forwarded)
- *
- * @example
- * // Using with styled-components:
- * styled.div.withConfig({
- *   shouldForwardProp: shouldForwardProp<CustomProps>(["$internal"])
- * })
- */
-declare const shouldForwardProp:<CustomProps>(props:UnionToTupleStrict<keyof CustomProps>)=>(propName:PropertyKey)=>boolean;
-/** ---------------------------------
- * * ***Constructs a valid URL with optional query parameters and allows selective removal of duplicate parameters.***
- * ---------------------------------
- *
- *
- * @param {string | URL} baseUrl
- *   The base URL to build upon. Must include protocol (e.g., "https://"),
- *   domain, and may include port and existing query parameters.
- *
- * @param {Iterable<[string, string]>|URLSearchParamsIterator<[string, string]>} [queryParams]
- *   Additional query parameters to append or overwrite on the URL.
- *   Accepts any iterable of key-value pairs (like `new URLSearchParams().entries()`).
- *
- * @param {string[]} [removeParams]
- *   A list of query parameter keys to remove from the final URL,
- *   whether they were in the base URL or provided queryParams.
- *
- * @returns {URL}
- *   A new URL object representing the constructed URL with merged
- *   and cleaned query parameters.
- *
- * @throws {TypeError}
- *   Throws if `baseUrl` is not a valid non-empty string or URL object,
- *   or if `queryParams` is not iterable, or if `removeParams` is not an array of strings.
- *
- * @example
- * // Basic usage
- * constructURL("https://example.com/path", new URLSearchParams({ a: "1", b: "2" }).entries());
- * // => URL { href: "https://example.com/path?a=1&b=2", ... }
- *
- * @example
- * // Remove parameters from base and added
- * constructURL("https://example.com/path?foo=1&bar=2", new URLSearchParams({ bar: "ignored", baz: "3" }).entries(), ["bar"]);
- * // => URL { href: "https://example.com/path?foo=1&baz=3", ... }
- */
-declare const constructURL:(baseUrl:string | URL,queryParams?:URLSearchParamsIterator<[string,string]>,removeParams?:string[])=>URL;
-/** --------------------------------------------------------
- * * ***Get Prefix from URL with Optional Base or Auto-detection (Supports String or Array of URLs).***
- * --------------------------------------------------------
- *
- * @description
- * This function extracts the prefix from one or more URLs. It can either:
- * - Use a provided `base` string or an array of strings to check and return the matching prefix.
- * - Automatically detect the prefix if no `base` is provided by analyzing the first part of the URL.
- *
- * The function is flexible and can handle both scenarios:
- * 1. **When the base is provided as a single string or an array of strings**: The function will check if the URL starts with one of the provided base(s) and return the matching base.
- * 2. **When the base is not provided**: The function will automatically detect the prefix by splitting the URL or using a regex.
- *
- * **Important Notes**:
- * - If a base (or an array of bases) is provided, the URL must start with one of the given base(s).
- * - If no base is provided, the function will attempt to detect the prefix automatically.
- * - The `url` parameter can be either a string or an array of strings.
- * - Supports deduplication of results (enabled by default).
- * - Automatically returns a single string if only one unique result exists after processing.
- *
- * ---
- *
- * @param {string|string[]} url The full URL(s) from which the prefix should be extracted. Can be a string or an array of strings.
- * @param {string|string[]|null} [base=null] The base URL(s) (e.g., "/settings"). It can be a string, an array of strings, or `null`. If provided, it will be used to check the URL(s). If not provided, the prefix will be auto-detected.
- * @param {{ levels?: number; removeDuplicates?: boolean }} [options] Additional options object:
- * - `levels` (default `1`): The number of segments to include when auto-detecting the prefix (e.g. `/foo/bar` for `levels: 2`).
- * - `removeDuplicates` (default `true`): Whether to remove duplicate prefixes from the final array result.
- *
- * @returns {string|string[]|null}
- * Returns one of:
- * - A single string if only one unique prefix/base is found.
- * - An array of strings if multiple different prefixes/bases are found.
- * - `null` if no matching base is found when using `base`.
- *
- * ---
- *
- * @throws {TypeError}
- * Throws if:
- * - `url` is not a string or an array of strings.
- * - `base` is not a string, array of strings, or `null`.
- * - `options` is not an object.
- * - `levels` is not a number.
- * - `removeDuplicates` is not a boolean.
- *
- * ---
- *
- * ### **🔹 Usage Examples**
- *
- * #### ✅ **Correct Usage (With an Array of URLs and Base)**
- * ```ts
- * const routes = [
- *   "/settings/profile",
- *   "/settings/password",
- *   "/settings/other-path",
- *   "/other-path/xyz",
- * ];
- *
- * // With base provided as a string
- * routes.forEach(route => {
- *   console.log(getPrefixPathname(route, '/settings')); // Output: "/settings"
- * });
- *
- * // With base provided as an array
- * routes.forEach(route => {
- *   console.log(getPrefixPathname(route, ['/settings', '/admin'])); // Output: "/settings" or "/admin" depending on the URL
- * });
- * ```
- *
- * #### ✅ **Correct Usage (With Single URL and Single Base)**
- * ```ts
- * const result = getPrefixPathname("/settings/profile", "/settings");
- * console.log(result); // Output: "/settings"
- * ```
- *
- * #### ✅ **Correct Usage (With Multiple URLs and Single Base)**
- * ```ts
- * const result = getPrefixPathname(["/settings/profile", "/settings/password"], "/settings");
- * console.log(result); // Output: "/settings"
- * ```
- *
- * #### ✅ **Correct Usage (With Multiple URLs and Multiple Bases)**
- * ```ts
- * const result = getPrefixPathname(["/settings/profile", "/admin/password"], ["/settings", "/admin"]);
- * console.log(result); // Output: ["/settings", "/admin"]
- * ```
- *
- * #### ✅ **Auto-detection of Prefix**
- * ```ts
- * const result = getPrefixPathname("/settings/profile");
- * console.log(result); // Output: "/settings"
- *
- * const result2 = getPrefixPathname("/settings/profile/info", null, { levels: 2 });
- * console.log(result2); // Output: "/settings/profile"
- * ```
- *
- * #### ✅ **Multiple URLs with Auto-detection**
- * ```ts
- * const result = getPrefixPathname(["/admin/profile", "/settings/password"]);
- * console.log(result); // Output: ["/admin", "/settings"]
- * ```
- *
- * #### ✅ **Handling Duplicates**
- * ```ts
- * const result = getPrefixPathname(["/settings/profile", "/settings/password"], "/settings");
- * console.log(result); // Output: "/settings" (deduped to single string)
- *
- * const result2 = getPrefixPathname(["/settings/profile", "/settings/profile"], "/settings", { removeDuplicates: false });
- * console.log(result2); // Output: ["/settings", "/settings"]
- * ```
- *
- * #### ❌ **Incorrect Usage (URL Does Not Match Base)**
- * ```ts
- * const result = getPrefixPathname("/other-path/profile", "/settings");
- * console.log(result); // Output: null
- * ```
- *
- * ---
- */
-declare const getPrefixPathname:(url:string | string[],base?:string | string[] | null,options?:{
-/** The number of levels to include in the prefix (default is 1). For example, with `levels = 2`, the function will return the first two parts of the URL. */
-levels?:number;
-/** Whether to remove duplicates from the result if multiple URLs are passed (default is `true`). */
-removeDuplicates?:boolean;})=>string | string[] | null;
-/** --------------------------------------------------------
- * * ***Extract First Valid Prefix from Path Array or String.***
- * --------------------------------------------------------
- *
- * ### 🚀 **Main Purpose:**
- * This function helps extract the first valid URL prefix from various possible inputs.
- * It is especially useful in routing systems, middleware, or frontend apps that
- * need to decide layout, active navigation, or permissions based on the first
- * segment (or prefix) of a pathname.
- *
- * Typical uses include:
- * - Determining which layout to render (e.g., `/admin` vs `/dashboard` vs `/`).
- * - Highlighting the active menu item in a sidebar based on the current URL.
- * - Enforcing route guards or access controls depending on the URL prefix.
- * - Parsing multi-level route prefixes and selecting the most relevant one.
- *
- * ---
- *
- * ### 🔍 Behavior:
- * It works as follows:
- * - If `result` is an array of strings, it normalizes each element and returns
- *   the first non-root path (i.e., not just `"/"`). If all items normalize to `"/"`,
- *   it returns the `defaultValue` (normalized).
- * - If `result` is a single string, it normalizes it and returns it if valid,
- *   otherwise falls back to the normalized `defaultValue`.
- * - If `result` is `null` or `undefined`, it returns the normalized `defaultValue`.
- *
- * ---
- *
- * ### 🔍 Validation & Errors:
- *
- * - Throws a `TypeError` if:
- *   - `defaultValue` is not a non-empty string.
- *   - `result` is an array that contains non-string elements.
- *   - `result` is a value that is neither `string`, `string[]`, nor `null`.
- *
- * ---
- *
- * ### 🛠 Usage Examples:
- *
- *  1. #### For React: *Determining layout*
- * ```ts
- * const prefix = getFirstPrefixPathname(getPrefixPathname("/admin/settings", ["/admin", "/dashboard"]));
- * if (prefix === "/admin") {
- *   renderAdminLayout();
- * }
- * ```
- *
- *  2. #### Setting active menu state
- * ```ts
- * const activeSection = getFirstPrefixPathname(["", "/dashboard", "/profile"]);
- * // => "/dashboard"
- * ```
- *
- *  3. #### Providing graceful fallback
- * ```ts
- * const section = getFirstPrefixPathname([], "/home");
- * // => "/home"
- * ```
- *  4. #### ✅ Using with an Array of Pathnames
- * ```ts
- * const result = getPrefixPathname(["   ", "/dashboard", "/settings"]);
- * console.log(getFirstPrefixPathname(result)); // => "/dashboard"
- * ```
- *
- *  5. #### ✅ Using with Single String:
- * ```ts
- * console.log(getFirstPrefixPathname("/profile/settings")); // => "/profile/settings"
- * console.log(getFirstPrefixPathname("   ")); // => "/"
- * ```
- *
- *  6. #### ✅ Fallback to Custom Default:
- * ```ts
- * console.log(getFirstPrefixPathname(["   ", ""], "/home")); // => "/home"
- * console.log(getFirstPrefixPathname(null, "/dashboard"));   // => "/dashboard"
- * ```
- *
- *  7. #### ✅ Throws on Invalid Input:
- * ```ts
- * getFirstPrefixPathname([1, 2] as any); // ❌ throws TypeError
- * getFirstPrefixPathname({} as any);     // ❌ throws TypeError
- * getFirstPrefixPathname(null, "   ");   // ❌ throws TypeError
- * ```
- *
- * ---
- *
- * @param {string | string[] | null} result
- *    The pathname(s) to process. Can be:
- *    - A string path (e.g. `"/profile"`),
- *    - An array of string paths (e.g. `["   ", "/dashboard"]`),
- *    - Or `null`.
- *
- * @param {string} [defaultValue="/"]
- *    A custom default path to use if `result` is null or no valid prefix is found.
- *    Must be a non-empty string. Defaults to `"/"`.
- *
- * @returns {string}
- *    The first valid normalized pathname, or the normalized default.
- *
- * @throws {TypeError}
- *    If `result` is not a valid type, or `defaultValue` is not a non-empty string.
- */
-declare const getFirstPrefixPathname:(result?:string | string[] | null,defaultValue?:string)=>string;
-/** --------------------------------------------------------
- * * ***Normalizes a given pathname by ensuring consistent formatting.***
- * --------------------------------------------------------
- *
- * @description
- * This function processes and normalizes a given pathname:
- *
- * - If `pathname` is `null`, `undefined`, empty, or only whitespace,
- *   the `defaultPath` will be returned instead.
- *
- * - If `pathname` is a full URL (starting with `http://` or `https://`),
- *   it extracts and returns the pathname along with any search parameters and hash.
- *   Example: `"https://site.com/foo/bar?x=1#sec"` becomes `"/foo/bar?x=1#sec"`.
- *
- * - All spaces inside the pathname are removed.
- *
- * - Multiple consecutive slashes (like `"//"` or `"///"`) are collapsed into a single slash `"/"`.
- *
- * - Ensures the returned string always starts with exactly one `/`.
- *
- * @param {string | null | undefined} pathname - The pathname to normalize.
- * @param {string} [defaultPath="/"] - A fallback value returned if `pathname` is empty or invalid. Must be a non-empty string, default `"/"`.
- *
- * @returns {string} A properly normalized pathname starting with a single `/`,
- * or the `defaultPath` if the input is invalid or empty.
- *
- * @throws {TypeError} If `defaultPath` is not a non-empty string.
- * @throws {NormalizePathnameError} If an unexpected error occurs during normalization (e.g., URL parsing failure).
- *
- * @example
- * normalizePathname("   /foo//bar  "); // => "/foo/bar"
- *
- * normalizePathname("https://example.com//path///to/resource?x=1#hash");
- * // => "/path/to/resource?x=1#hash"
- *
- * normalizePathname("   "); // => "/"
- * normalizePathname(null, "/home"); // => "/home"
- * normalizePathname("/double//slashes"); // => "/double/slashes"
- *
- * normalizePathname(" nested / path / 🚀 "); // => "/nested/path/🚀"
- */
-declare const normalizePathname:(pathname?:string | null,defaultPath?:string)=>string;
-/** -----------------------------------------------
- * * ***Retrieves and formats an environment port variable.***
- * -----------------------------------------------
- *
- * - Extracts only digits from the input.
- * - If no digits found, returns an empty string.
- * - By default does NOT prefix with a colon.
- *   Use `{ prefixColon: true }` to prefix with a colon.
- *
- * @param envVar The environment variable string.
- * @param options Optional object: `{ prefixColon?: boolean }`.
- * @returns A string like ":8080" or "8080", or "" if no digits.
- *
- * @throws TypeError if `options` is not an object or `prefixColon` is not boolean.
- *
- * @example
- * formatEnvPort("port:8080");           // "8080"
- * formatEnvPort("port:8080", { prefixColon: true }); // ":8080"
- */
-declare const formatEnvPort:(envVar?:string | null,options?:{
-/** Add prefix with a colon.
-	 *
-	 * @default false
-	 */
-prefixColon?:boolean;})=>string;
-/** ---------------------------------
- * * ***Custom Error for Pathname Normalization Failures***
- * ---------------------------------
- */
-declare class NormalizePathnameError extends Error{originalError:Error;constructor(message:string,originalError:Error);}export{NormalizePathnameError,areObjectsEqual,areURLsEqualPath,areURLsIdentical,arrayHasAnyMatch,assertIsString,capitalizeFirst,capitalizeWords,censorEmail,chunkString,cleanParsedData,constructURL,convertType,dedupeArray,delay,disableUserInteraction,doesKeyExist,enableUserInteraction,extractDigits,extractFileName,extractURLs,filterNullArray,findDuplicates,formatCurrency,formatDateFns,formatDateIntl,formatDateTime,formatEnvPort,formatNumber,formatPhoneNumber,getFirstPrefixPathname,getGMTOffset,getInitialsName,getPreciseType,getPrefixPathname,getRandomItem,isArguments,isArray,isArrayBuffer,isArrayLike,isArrayLikeObject,isBigInt,isBoolean,isBuffer,isCurrencyLike,isDate,isDeepEqual,isElement,isEmpty,isEmptyArray,isEmptyDeep,isEmptyString,isEmptyValue,isEqual,isEqualWith,isError,isFinite$1 as isFinite,isFunction,isInteger,isLength,isMatch,isMatchWith,isNaN$1 as isNaN,isNative,isNil,isNonEmptyArray,isNonEmptyString,isNull,isNumber,isObject,isObjectLoose,isObjectOrArray,isPlainObject,isRegExp,isSafeInteger,isServer,isSet,isString,isSymbol,isTypedArray,isURL,isUndefined,isValidURL,isWeakMap,noop,normalizePathname,normalizeSpaces,normalizeString,omitKeys,omitKeysDeep,omitProps,parseCurrencyString,parseCustomDate,randomInt,randomIntByLength,randomStr,removeElementFocus,removeObjectPaths,removeSpaces,replaceAt,safeJsonParse,safeStableStringify,scrollToTop,shouldForwardProp,slugify,stripHtmlTags,textContainsAll,textContainsAny,toBooleanContent,toBooleanContentDeep,toBooleanExplicit,toBooleanLoose,toCamelCase,toDotCase,toKebabCase,toNumberArrayUnRecursive,toNumberDeep,toPascalCase,toSnakeCase,toStringArrayUnRecursive,toStringDeep,toStringDeepForce,truncateString};export type{IsObjectOrArray};
+export{assertIsArray,assertIsBigInt,assertIsBoolean,assertIsNumber,assertIsPlainObject,assertIsString}from'./assertions/index.js';export{cleanParsedData,convertType,dedupeArray,extractDigits,filterNilArray,filterNullArray,parseCurrencyString,parseCustomDate,removeObjectPaths,safeJsonParse,safeStableStringify,toBooleanContent,toBooleanContentDeep,toBooleanExplicit,toBooleanLoose,toNumberArrayUnRecursive,toNumberDeep,toStringArrayUnRecursive,toStringDeep,toStringDeepForce}from'./conversions/index.js';export{isServer}from'./env/index.js';export{disableUserInteraction,enableUserInteraction,removeElementFocus,scrollToTop}from'./events/index.js';export{censorEmail,chunkString,formatCurrency,formatDateFns,formatDateIntl,formatDateTime,formatNumber,formatPhoneNumber,getGMTOffset,truncateString}from'./formatting/index.js';export{getRandomItem,noop,randomInt,randomIntByLength,randomStr}from'./generator/index.js';export{findDuplicates,omitKeys,omitKeysDeep,omitProps}from'./operations/index.js';export{extractFileName}from'./parsers/index.js';export{IsArrayResult,areArraysEqual,areObjectsEqual,areURLsEqualPath,areURLsIdentical,arrayHasAnyMatch,doesKeyExist,hasOwnProp,isArguments,isArray,isArrayBuffer,isArrayLike,isArrayLikeObject,isBigInt,isBoolean,isBuffer,isCurrencyLike,isDate,isDeepEqual,isElement,isEmpty,isEmptyArray,isEmptyDeep,isEmptyObject,isEmptyString,isEmptyValue,isEqual,isEqualWith,isError,isFinite,isFunction,isInteger,isLength,isMap,isMatch,isMatchWith,isNaN,isNative,isNil,isNonEmptyArray,isNonEmptyString,isNonEmptyValue,isNull,isObject,isObjectLoose,isObjectOrArray,isRegExp,isSafeInteger,isSet,isString,isSymbol,isTypedArray,isURL,isUndefined,isValidURL,isWeakMap,textContainsAll,textContainsAny}from'./predicates/index.js';export{G as GetPreciseTypeOptions,I as IsNumberOptions,a as IsPlainObjectResult,g as getPreciseType,i as isNumber,b as isPlainObject}from'./isPlainObject-BKYaI6a8.js';export{delay}from'./promise/index.js';export{capitalizeFirst,capitalizeWords,getInitialsName,normalizeSpaces,normalizeString,removeSpaces,replaceAt,slugify,stripHtmlTags,toCamelCase,toDotCase,toKebabCase,toLowerCase,toPascalCase,toPascalCaseSpace,toSnakeCase}from'./strings/index.js';export{shouldForwardProp}from'./stylings/index.js';export{QueryParamPairs,constructURL,extractURLs,formatEnvPort,getFirstPrefixPathname,getPrefixPathname,normalizePathname}from'./urls/index.js';import'./type-data-DDs-u2kq.js';import'./arrays-normalize-recursive-CnjYJ9xg.js';import'./nils-DMz3kU7M.js';import'./any-BmdI8UbK.js';import'./if-CvT4R7Kh.js';import'./extends-Mp81Hq9-.js';import'./array-CIZRbqTF.js';import'./never-BfayMBF9.js';import'./prettify-C4xLcYOP.js';import'./NumberRangeUnion-DC-C3_Kq.js';import'./omit-VvmIsZmX.js';import'date-fns/locale';import'date-fns';import'./is-array-Ckm_47hw.js';