reslib 1.0.0

package/build/utils/isEmpty.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if the provided value is empty.
+ *
+ * A value is considered empty if it is null, undefined, an empty string, or an empty array.
+ *
+ * @param {any} value The value to check.
+ * @returns {boolean} True if the value is empty, false otherwise.
+ * @example
+ * ```typescript
+ * console.log(isEmpty(null)); // Output: true
+ * console.log(isEmpty(undefined)); // Output: true
+ * console.log(isEmpty('')); // Output: true
+ * console.log(isEmpty([])); // Output: true
+ * console.log(isEmpty('hello')); // Output: false
+ * console.log(isEmpty([1, 2, 3])); // Output: false
+ * ```
+ */
+export declare function isEmpty(value: any): boolean;

package/build/utils/isEmpty.js

@@ -0,0 +1 @@
+'use strict';function n(r){return !!(r==null||typeof r=="undefined"||typeof r=="string"&&r===""||Array.isArray(r)&&!r.length)}exports.isEmpty=n;

package/build/utils/isNonNullString.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if the provided value is a non-empty string.
+ *
+ * A value is considered a non-empty string if it is not null and is a string.
+ *
+ * @param {any} val The value to check.
+ * @returns {boolean} True if the value is a non-empty string, false otherwise.
+ * @example
+ * ```typescript
+ * console.log(isNonNullString('hello')); // Output: true
+ * console.log(isNonNullString('')); // Output: false
+ * console.log(isNonNullString(null)); // Output: false
+ * console.log(isNonNullString(undefined)); // Output: false
+ * console.log(isNonNullString(123)); // Output: false
+ * ```
+ */
+export declare function isNonNullString<T = any>(val: T): val is T & string;

package/build/utils/isNonNullString.js

@@ -0,0 +1 @@
+'use strict';function t(n){return !!(n&&typeof n=="string")}exports.isNonNullString=t;

package/build/utils/isNullable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a value is nullable (null, undefined, NaN, or empty string).
+ *
+ * @param value - The value to check
+ * @returns True if the value is considered nullable, false otherwise
+ */
+export declare function isNullable<T>(value: T): value is T;

package/build/utils/isNullable.js

@@ -0,0 +1 @@
+'use strict';function t(r){return !!(r==null||typeof r=="number"&&isNaN(r)||typeof r=="string"&&r.trim()==="")}exports.isNullable=t;

package/build/utils/isNumber.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Checks if the provided value is a valid finite number, excluding NaN (Not-a-Number)
+ * and infinite values (Infinity and -Infinity).
+ *
+ * This function performs a type check to ensure the value is of type `number` and
+ * additionally verifies that it is finite and not NaN, which are special numeric values
+ * representing invalid or infinite numbers.
+ *
+ * It serves as a type guard, narrowing the type of the input value to `number` if the check passes.
+ * This is useful in TypeScript for ensuring type safety when dealing with potentially
+ * untrusted or dynamically typed inputs, such as user inputs, API responses, or parsed data.
+ *
+ * @param value - The value to check. Can be of any type, but the function will only return true
+ *                for actual finite numbers.
+ * @returns `true` if the value is a finite number and not NaN; otherwise, `false`.
+ *          When `true`, TypeScript will narrow the type of `value` to `number`.
+ *
+ * @example
+ * ```typescript
+ * console.log(isNumber(42));        // true
+ * console.log(isNumber(3.14));      // true
+ * console.log(isNumber(NaN));       // false
+ * console.log(isNumber(Infinity));  // false
+ * console.log(isNumber(-Infinity)); // false
+ * console.log(isNumber('42'));      // false
+ * console.log(isNumber(null));      // false
+ * console.log(isNumber(undefined)); // false
+ * ```
+ *
+ * @note This function does not consider numeric strings (e.g., "42") as numbers.
+ *       For parsing strings to numbers, consider using `parseFloat` or `parseInt`
+ *       in combination with this check.
+ * @note This function rejects infinite values (Infinity/-Infinity) as they typically
+ *       represent error conditions or overflow in validation contexts.
+ */
+export declare function isNumber(value: any): value is number;

package/build/utils/isNumber.js

@@ -0,0 +1 @@
+'use strict';function n(i){return typeof i=="number"&&!isNaN(i)&&isFinite(i)}exports.isNumber=n;

package/build/utils/isPrimitive.d.ts

@@ -0,0 +1,16 @@
+import { Primitive } from '../types';
+/**
+ * Type guard to check if a value is a primitive type.
+ *
+ * @param {any} value - The value to check
+ * @returns {boolean} True if the value is a primitive, false otherwise
+ *
+ * @example
+ * isPrimitive("hello")     // returns true
+ * isPrimitive(42)          // returns true
+ * isPrimitive(true)        // returns true
+ * isPrimitive(null)        // returns true
+ * isPrimitive({})          // returns false
+ * isPrimitive([])          // returns false
+ */
+export declare function isPrimitive(value: any): value is Primitive;

package/build/utils/isPrimitive.js

@@ -0,0 +1 @@
+'use strict';function t(i){return i==null||typeof i=="string"||typeof i=="number"||typeof i=="boolean"}exports.isPrimitive=t;

package/build/utils/isPromise.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks if the provided value is a Promise.
+ *
+ * A value is considered a Promise if it is a native Promise or if it has a Promise-like interface.
+ *
+ * @param {any} value The value to check.
+ * @returns {boolean} True if the value is a Promise, false otherwise.
+ * @example
+ * ```typescript
+ * console.log(isPromise(Promise.resolve())); // Output: true
+ * console.log(isPromise({})); // Output: false
+ * ```
+ */
+export declare function isPromise(value: any): boolean;

package/build/utils/isPromise.js

@@ -0,0 +1 @@
+'use strict';function o(t){return typeof t=="boolean"||!t||typeof t=="number"||typeof t=="string"||typeof t=="symbol"?false:Object(t).constructor===Promise||t.constructor&&(t.constructor.name==="Promise"||t.constructor.name==="AsyncFunction")||t instanceof Promise||typeof(t==null?void 0:t.then)=="function"&&typeof(t==null?void 0:t.catch)=="function"&&typeof(t==null?void 0:t.finally)=="function"?true:t&&typeof t.constructor=="function"&&Function.prototype.toString.call(t.constructor).replace(/\(.*\)/,"()")===Function.prototype.toString.call(Function).replace("Function","Promise").replace(/\(.*\)/,"()")}function n(t){return t&&Object.prototype.toString.call(t)==="[object Promise]"?true:o(t)}exports.isPromise=n;

package/build/utils/isRegex.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks if the provided value is a regular expression.
+ *
+ * A value is considered a regular expression if it is an instance of the RegExp constructor, or if it can be converted to a RegExp.
+ *
+ * @param {any} regExp The value to check.
+ * @returns {boolean} True if the value is a regular expression, false otherwise.
+ * @example
+ * ```typescript
+ * console.log(isRegExp(/hello/)); // Output: true
+ * console.log(isRegExp("hello")); // Output: true
+ * console.log(isRegExp({})); // Output: false
+ * ```
+ */
+export declare function isRegExp(regExp: any): regExp is RegExp;

package/build/utils/isRegex.js

@@ -0,0 +1 @@
+'use strict';function n(e){if(e instanceof RegExp)return  true;if(!e||typeof e!="object"||!Object.prototype.toString.call(e).includes("RegExp"))return  false;try{return new RegExp(e),!0}catch(t){return  false}}exports.isRegExp=n;

package/build/utils/isTime.d.ts

@@ -0,0 +1,18 @@
+declare const timeOptions: {
+    readonly hour24: {
+        readonly default: RegExp;
+        readonly withSeconds: RegExp;
+        readonly withOptionalSeconds: RegExp;
+    };
+    readonly hour12: {
+        readonly default: RegExp;
+        readonly withSeconds: RegExp;
+        readonly withOptionalSeconds: RegExp;
+    };
+};
+export interface IsTimeOptions {
+    format?: keyof typeof timeOptions;
+    mode?: 'withSeconds' | 'default' | 'withOptionalSeconds';
+}
+export default function isTime(input: string, options: IsTimeOptions): boolean;
+export {};

package/build/utils/isTime.js

@@ -0,0 +1 @@
+'use strict';function x(e){return !!(e&&typeof e=="string")}function d(e){return !e||typeof e!="object"?false:e instanceof Date?true:typeof e.getTime!="function"?false:!(Object.prototype.toString.call(e)!=="[object Date]"||isNaN(e.getTime()))}function m(e){return typeof window!="object"||!window||typeof document=="undefined"||typeof HTMLElement=="undefined"||!HTMLElement?false:e===document?true:"HTMLElement"in window?!!e&&e instanceof HTMLElement:!!e&&typeof e=="object"&&e.nodeType===1&&!!e.nodeName}function T(e){return e==null||typeof e=="string"||typeof e=="number"||typeof e=="boolean"}function O(e){if(e instanceof RegExp)return  true;if(!e||typeof e!="object"||!Object.prototype.toString.call(e).includes("RegExp"))return  false;try{return new RegExp(e),!0}catch(n){return  false}}function c(e){if(e===null||typeof e!="object"||m(e)||d(e)||O(e)||T(e))return  false;let n=Object.getPrototypeOf(e);if(n===null)return  true;let t=n.constructor;if(typeof t!="function")return  false;if(t===Object)return  true;let r=t.prototype;return typeof r!="object"?false:r===Object.prototype?true:typeof n.hasOwnProperty=="function"&&Object.prototype.hasOwnProperty.call(n,"isPrototypeOf")&&typeof n.isPrototypeOf=="function"}function A(e){if(Array.isArray(e)){let r=[];for(var n=0;n<e.length;n++)r[n]=A(e[n]);return r}else if(c(e)&&e){let r={};for(var t in e)e.hasOwnProperty(t)&&(r[t]=A(e[t]));return r}else return e}Object.getSize=function(e,n=false){if(!e||typeof e!="object")return 0;if(Array.isArray(e))return e.length;typeof n!="boolean"&&(n=false);let t=0;for(let r in e)if(Object.prototype.hasOwnProperty.call(e,r)&&(t++,n===true))return t;return t};function p(e,...n){let t=Array.isArray(e),r=c(e);(e==null||!t&&!r)&&(e={});for(let i=0;i<n.length;i++){let o=n[i];if(o==null)continue;let a=c(o),y=Array.isArray(o);if(!(!a&&!y)){if(t){y&&g(e,o);continue}else if(y)continue;for(let s in o){let f=o[s];if(f==null)continue;if(f===o){e[s]=e;continue}let u=e[s],S=Array.isArray(u),w=Array.isArray(f);if(S){w?g(e[s],f):e[s]=f;continue}else if(!c(u)){e[s]=f;continue}if(w||!c(f)){e[s]=f;continue}e[s]=p({},u,f);}}}return e}var g=(e,n)=>{let t=n.length,r=0;for(let i=0;i<e.length;i++){let o=e[i],a=n[i];if(i<t){let y=Array.isArray(o),s=Array.isArray(a),f=c(o),u=c(a);y&&s||f&&u?(e[r]=p(y?[]:{},o,a),r++):a!=null?(e[r]=a,r++):o!=null&&(e[r]=o,r++);}}for(let i=e.length;i<t;i++)n[i]!==void 0&&n[i]!==null&&e.push(n[i]);return e};function b(e,n){return l(e,"",{},n)}function l(e,n="",t={},r){if(t=c(t)?t:{},T(e)||d(e)||O(e)||Array.isArray(e)&&(r!=null&&r.skipArrays))return n&&(t[n]=e),t;if(typeof e=="function"||typeof e=="object"&&!c(e)&&!N(e))return t;if(e instanceof Map||e instanceof WeakMap)return Array.from(e.entries()).forEach(([i,o])=>{let a=n?`${n}[${String(i)}]`:String(i);l(o,a,t,r);}),t;if(Array.isArray(e)||e instanceof Set||e instanceof WeakSet)return (Array.isArray(e)?e:Array.from(e)).forEach((o,a)=>{let y=n?`${n}[${a}]`:String(a);l(o,y,t,r);}),t;if(c(e))for(let i in e){if(!Object.prototype.hasOwnProperty.call(e,i))continue;let o=e[i],a=n?n.endsWith("]")?`${n}.${i}`:`${n}.${i}`:i;l(o,a,t,r);}return t}function N(e){return Array.isArray(e)||e instanceof Set||e instanceof Map||e instanceof WeakMap||e instanceof WeakSet}function k(e){return Object.entries(e)}Object.typedEntries=k;Object.flatten=b;Object.clone=A;var h={hour24:{default:/^([01]?[0-9]|2[0-3]):([0-5][0-9])$/,withSeconds:/^([01]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/,withOptionalSeconds:/^([01]?[0-9]|2[0-3]):([0-5][0-9])(?::([0-5][0-9]))?$/},hour12:{default:/^(0?[1-9]|1[0-2]):([0-5][0-9]) (A|P)M$/,withSeconds:/^(0?[1-9]|1[0-2]):([0-5][0-9]):([0-5][0-9]) (A|P)M$/,withOptionalSeconds:/^(0?[1-9]|1[0-2]):([0-5][0-9])(?::([0-5][0-9]))? (A|P)M$/}};function M(e,n){var t;return x(e)?(n=p({},{format:"hour24",mode:"default"},n),(!n.format||!h[n.format])&&(n.format="hour24"),(!n.mode||!((t=h[n.format])!=null&&t[n.mode]))&&(n.mode="default"),h[n.format][n.mode].test(e)):false}module.exports=M;

package/build/utils/json.d.ts

@@ -0,0 +1,224 @@
+/**
+ * A utility class providing helper methods for JSON manipulation, including
+ * handling circular references, stringification, validation, and parsing.
+ *
+ * This class offers robust JSON operations that go beyond standard JSON methods,
+ * particularly useful for complex data structures with circular references or
+ * nested JSON strings.
+ *
+ * @example
+ * ```typescript
+ * import { JsonHelper } from './json';
+ *
+ * // Handle circular references
+ * const circular = { name: 'test' };
+ * circular.self = circular;
+ * const safe = JsonHelper.decycle(circular);
+ * console.log(JsonHelper.stringify(safe)); // '{"name":"test","self":null}'
+ *
+ * // Validate JSON strings
+ * console.log(JsonHelper.isJSON('{"key": "value"}')); // true
+ * console.log(JsonHelper.isJSON('not json')); // false
+ *
+ * // Parse nested JSON
+ * const nested = { data: '{"inner": "value"}' };
+ * const parsed = JsonHelper.parse(nested);
+ * console.log(parsed.data.inner); // 'value'
+ * ```
+ */
+export declare class JsonHelper {
+    /**
+     * Removes circular references from an object by replacing them with `null`.
+     *
+     * This method recursively traverses objects and arrays, detecting when an object
+     * references itself (directly or indirectly) and replacing such references with
+     * `null` to prevent infinite recursion during JSON serialization.
+     *
+     * Functions are converted to `undefined` as they cannot be reliably serialized.
+     * Primitive values (strings, numbers, booleans) and `null`/`undefined` are returned as-is.
+     *
+     * @param obj - The object to decycle. Can be any type.
+     * @param stack - Internal parameter used for tracking visited objects during recursion.
+     *                Should not be provided by external callers.
+     * @returns A new object with circular references removed, or the original value if it's not an object.
+     *
+     * @example
+     * ```typescript
+     * const circular = { name: 'test' };
+     * circular.self = circular; // Creates circular reference
+     *
+     * console.log(JSON.stringify(circular)); // Throws TypeError: Converting circular structure to JSON
+     *
+     * const decycled = JsonHelper.decycle(circular);
+     * console.log(JSON.stringify(decycled)); // '{"name":"test","self":null}'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const nested = {
+     *   a: { b: {} },
+     *   c: {}
+     * };
+     * nested.a.b = nested.c; // Cross-reference
+     * nested.c.ref = nested.a; // Creates cycle
+     *
+     * const safe = JsonHelper.decycle(nested);
+     * console.log(JSON.stringify(safe)); // No circular references
+     * ```
+     */
+    static decycle(obj: any, stack?: Array<any>): any;
+    /**
+     * Converts a JavaScript value to a JSON string, with optional circular reference handling.
+     *
+     * This method wraps `JSON.stringify()` and provides an option to automatically
+     * remove circular references before serialization. If the input is already a string,
+     * it is returned as-is.
+     *
+     * @param jsonObj - The value to convert to a JSON string. Can be any type.
+     * @param decylcleVal - Whether to remove circular references before stringification.
+     *                      Defaults to `false` for performance. Set to `true` to handle
+     *                      objects with circular references.
+     * @returns A JSON string representation of the input value.
+     *
+     * @throws Will throw the same errors as `JSON.stringify()` if the value cannot be serialized
+     *         and `decylcleVal` is `false`, or if circular references cannot be resolved.
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const obj = { name: 'John', age: 30 };
+     * console.log(JsonHelper.stringify(obj)); // '{"name":"John","age":30}'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Handle circular references
+     * const circular = { name: 'test' };
+     * circular.self = circular;
+     *
+     * // Without decycling - would throw
+     * // console.log(JsonHelper.stringify(circular)); // TypeError
+     *
+     * // With decycling
+     * console.log(JsonHelper.stringify(circular, true)); // '{"name":"test","self":null}'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // String input is returned as-is
+     * console.log(JsonHelper.stringify('already a string')); // 'already a string'
+     * ```
+     */
+    static stringify(jsonObj: any, decylcleVal?: boolean): string;
+    /**
+     * Determines whether a given value is a valid JSON string representing an object or array.
+     *
+     * This method performs strict validation, only accepting JSON strings that parse to
+     * objects `{}` or arrays `[]`. Primitive JSON values (strings, numbers, booleans, null)
+     * are considered invalid for this helper's purposes.
+     *
+     * The method includes performance optimizations like checking the first character
+     * and trimming whitespace before attempting to parse.
+     *
+     * @param json_string - The value to test. Only strings are considered valid input.
+     * @returns `true` if the input is a string containing valid JSON for an object or array,
+     *          `false` otherwise.
+     *
+     * @example
+     * ```typescript
+     * // Valid JSON objects and arrays
+     * console.log(JsonHelper.isJSON('{"key": "value"}')); // true
+     * console.log(JsonHelper.isJSON('[1, 2, 3]')); // true
+     * console.log(JsonHelper.isJSON('{"nested": {"key": "value"}}')); // true
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Invalid inputs
+     * console.log(JsonHelper.isJSON('not json')); // false
+     * console.log(JsonHelper.isJSON('"string"')); // false (primitive)
+     * console.log(JsonHelper.isJSON('42')); // false (primitive)
+     * console.log(JsonHelper.isJSON('true')); // false (primitive)
+     * console.log(JsonHelper.isJSON('null')); // false (primitive)
+     * console.log(JsonHelper.isJSON(123)); // false (not a string)
+     * console.log(JsonHelper.isJSON(null)); // false (not a string)
+     * console.log(JsonHelper.isJSON('')); // false (empty string)
+     * console.log(JsonHelper.isJSON('   ')); // false (whitespace only)
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Edge cases
+     * console.log(JsonHelper.isJSON('{invalid json')); // false (malformed)
+     * console.log(JsonHelper.isJSON('starts with [ but invalid')); // false
+     * ```
+     */
+    static isJSON(json_string: any): boolean;
+    /**
+     * Parses JSON strings with support for nested JSON parsing and custom revivers.
+     *
+     * This method extends `JSON.parse()` by recursively parsing any string properties
+     * within objects that contain valid JSON. It's particularly useful for deserializing
+     * data structures that have been serialized with nested JSON strings.
+     *
+     * If the input is not a string, it's returned as-is. If parsing fails, the original
+     * input is returned instead of throwing an error.
+     *
+     * @template T - The expected return type. Defaults to `any`.
+     * @param jsonStr - The value to parse. If it's a string, attempts JSON parsing.
+     *                  If it's an object, recursively parses any JSON string properties.
+     * @param reviver - An optional function to transform the parsed values, passed to `JSON.parse()`.
+     * @returns The parsed value, or the original input if parsing fails or input is not a string.
+     *
+     * @example
+     * ```typescript
+     * // Basic JSON parsing
+     * const parsed = JsonHelper.parse('{"name": "John", "age": 30}');
+     * console.log(parsed.name); // 'John'
+     * console.log(parsed.age); // 30
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Parse nested JSON strings within objects
+     * const nested = {
+     *   user: '{"name": "John", "age": 30}',
+     *   metadata: '{"created": "2023-01-01"}',
+     *   notes: 'not json'
+     * };
+     *
+     * const parsed = JsonHelper.parse(nested);
+     * console.log(parsed.user.name); // 'John'
+     * console.log(parsed.metadata.created); // '2023-01-01'
+     * console.log(parsed.notes); // 'not json' (unchanged)
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Using a reviver function
+     * const json = '{"date": "2023-01-01", "count": "42"}';
+     * const parsed = JsonHelper.parse(json, (key, value) => {
+     *   if (key === 'date') return new Date(value);
+     *   if (key === 'count') return parseInt(value);
+     *   return value;
+     * });
+     * console.log(parsed.date instanceof Date); // true
+     * console.log(typeof parsed.count); // 'number'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Non-string inputs are returned as-is
+     * console.log(JsonHelper.parse(42)); // 42
+     * console.log(JsonHelper.parse(null)); // null
+     * console.log(JsonHelper.parse({ already: 'parsed' })); // { already: 'parsed' }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Invalid JSON returns original input
+     * console.log(JsonHelper.parse('{invalid json}')); // '{invalid json}'
+     * ```
+     */
+    static parse<T = any>(jsonStr: any, reviver?: (this: any, key: string, value: any) => any): T;
+}

package/build/utils/json.js

@@ -0,0 +1 @@
+'use strict';var i=class n{static decycle(e,t=[]){if(typeof e=="function")return;if(!e||typeof e!="object")return e;if(t.includes(e))return null;let r=t.concat([e]);return Array.isArray(e)?e.map(a=>n.decycle(a,r)):Object.fromEntries(Object.entries(e).map(([a,c])=>[a,n.decycle(c,r)]))}static stringify(e,t=false){return typeof e=="string"?e:JSON.stringify(t!==false?n.decycle(e):e)}static isJSON(e){if(typeof e!="string")return  false;let t=e.trim();if(t.length===0)return  false;let r=t[0];if(r!=="{"&&r!=="[")return  false;try{let a=JSON.parse(t);return a!==null&&typeof a=="object"}catch(a){return  false}}static parse(e,t){if(typeof e=="string")try{e=JSON.parse(e,t);}catch(r){return e}if(e&&typeof e=="object")for(let r in e){let a=e[r];n.isJSON(a)&&(e[r]=n.parse(a,t));}return e}};exports.JsonHelper=i;

package/build/utils/numbers.d.ts

@@ -0,0 +1,148 @@
+import { Currency, CurrencyFormatters, CurrencySymbol } from '../currency/types';
+/**
+ * Extends the Number interface with additional methods for formatting and abbreviating numbers.
+ */
+declare global {
+    interface Number extends CurrencyFormatters {
+        /**
+         * Counts the number of decimal places in the number.
+         * @returns {number} The number of decimal places.
+         */
+        countDecimals: () => number;
+        /**
+         * Formats the number as a currency string.
+         * @param {Currency | CurrencySymbol} [symbol] The currency symbol to use (optional).
+         * @param {number} [decimalDigits] The number of decimal places to display (optional).
+         * @param {string} [thousandSeparator] The separator to use for thousands (optional).
+         * @param {string} [decimalSeparator] The separator to use for decimals (optional).
+         * @param {string} [format] The format to use for the currency string (optional).
+         * @returns {string} The formatted currency string.
+         * @example
+         * ```ts
+         * (12).formatMoney(); // Output: "12 FCFA"
+         * (12000).formatMoney(); // Output: "12 000 FCFA"
+         * ```
+         */
+        formatMoney: (symbol?: Currency | CurrencySymbol, decimalDigits?: number, thousandSeparator?: string, decimalSeparator?: string, format?: string) => string;
+        /**
+         * Formats the number using the specified formatter.
+         * @param {string} [formatter] The formatter to use (optional).
+         * @param {boolean} [abreviate] Whether to abbreviate the number (optional).
+         * @returns {string} The formatted string.
+         * @example
+         * ```ts
+         * (12).format("moneyCAD"); // Output: "CA$12"
+         * ```
+         */
+        format: (formatter?: string, abreviate?: boolean) => string;
+        /**
+         * Formats the number as a formatted number string with thousands separators.
+         * @param {Currency | number} [optionsOrDecimalDigits] The options or decimal digits to use (optional).
+         * @param {string} [thousandSeparator] The separator to use for thousands (optional).
+         * @param {string} [decimalSeparator] The separator to use for decimals (optional).
+         * @returns {string} The formatted number string.
+         */
+        formatNumber: (optionsOrDecimalDigits?: Currency | number, thousandSeparator?: string, decimalSeparator?: string) => string;
+        /**
+         * Abbreviates the number and formats it as a currency string.
+         * @param {Currency | CurrencySymbol} [symbol] The currency symbol to use (optional).
+         * @param {number} [decimalDigits] The number of decimal places to display (optional).
+         * @param {string} [thousandSeparator] The separator to use for thousands (optional).
+         * @param {string} [decimalSeparator] The separator to use for decimals (optional).
+         * @param {string} [format] The format to use for the currency string (optional).
+         * @returns {string} The formatted and abbreviated currency string.
+         */
+        abreviate2FormatMoney: (symbol?: Currency | CurrencySymbol, decimalDigits?: number, thousandSeparator?: string, decimalSeparator?: string, format?: string) => string;
+        /***
+         * Abbreviates a number and formats it as a number string.
+         * @param {number} [decimalDigits] The number of decimal places to display (optional).
+         * @param {string} [thousandSeparator] The separator to use for thousands (optional).
+         * @param {string} [decimalSeparator] The separator to use for decimals (optional).
+         * @returns {string} The formatted and abbreviated number string.
+         */
+        abreviate2FormatNumber: (decimalDigits?: number, thousandSeparator?: string, decimalSeparator?: string) => string;
+    }
+}
+/**
+ * Represents the result of abbreviating a number.
+ */
+export type AbreviateNumberResult = {
+    /**
+     * The abbreviated result.
+     */
+    result: string;
+    /**
+     * The original value that was abbreviated.
+     */
+    value: number;
+    /**
+     * The format used for abbreviation.
+     */
+    format: string;
+    /**
+     * The suffix used for abbreviation (e.g. "K", "M", etc.).
+     */
+    suffix: string;
+    /**
+     * The formatted value.
+     */
+    formattedValue: string;
+    /**
+     * The minimum number of decimal digits required for a given number when abbreviating it,
+     * ensuring that the abbreviated value does not lose significant information compared to the original number.
+     */
+    minAbreviationDecimalDigits: number;
+};
+/**
+ * Abbreviates a number to a shorter form (e.g. 1000 -> 1K).
+ * @see : https://stackoverflow.com/questions/10599933/convert-long-number-into-abbreviated-string-in-javascript-with-a-special-shortn
+ * @param {number} num The number to abbreviate.
+ *
+ *  @param {IAbreviateNumberOptions} [options] Formatting options when returnObject is true.
+ *  @param {number} num The number to abbreviate.
+ *  @param {number} [options.decimalDigits] Number of decimal digits to display. If not provided, will use the minimum number required for precision.
+ *  @param {string} [options.thousandsSeparator] Character to use as thousands separator. Example: "," for 1,234 or " " for 1 234.
+ *  @param {string} [options.decimalSeparator] Character to use as decimal separator. Example: "." for 1.5 or "," for 1,5.
+ * @returns {AbreviateNumberResult} The abbreviated number or an object with additional information.
+ */
+export declare const _abreviateNumber: (num: number, decimalDigits?: number, thousandsSeparator?: string, decimalSeparator?: string) => AbreviateNumberResult;
+/**
+ * Abbreviates a number to a shorter form with optional formatting.
+ *
+ * This function converts a large number into a shorter representation
+ * with suffixes such as 'K' for thousands, 'M' for millions, etc.
+ * It also allows optional customization of the number of decimal digits
+ * and the separators used for thousands and decimals.
+ *
+ * @param {number} num The number to abbreviate.
+ * @param {number} [decimalDigits] Optional number of decimal digits to display.
+ *   If not provided, the function will use the minimum number required for precision.
+ * @param {string} [thousandsSeparator] Optional character to use as thousands separator.
+ *   Example: ',' for 1,234 or ' ' for 1 234.
+ * @param {string} [decimalSeparator] Optional character to use as decimal separator.
+ *   Example: '.' for 1.5 or ',' for 1,5.
+ * @returns {string} The abbreviated number as a string.
+ */
+export declare const abreviateNumber: (num: number, decimalDigits?: number, thousandsSeparator?: string, decimalSeparator?: string) => string;
+/**
+ * Abbreviates a number and formats it as a monetary value.
+ *
+ * @param {number} number The number to abbreviate and format.
+ * @param {Currency | CurrencySymbol} [symbol] The currency symbol or name.
+ * @param {number} [decimalDigits] The number of decimal digits to use.
+ * @param {string} [thousandSeparator] The thousand separator to use.
+ * @param {string} [decimalSeparator] The decimal separator to use.
+ * @param {string} [format] The format string to use.
+ * @returns {string} The abbreviated and formatted monetary value.
+ */
+export declare const abreviate2FormatMoney: (number: number, symbol?: Currency | CurrencySymbol, decimalDigits?: number, thousandSeparator?: string, decimalSeparator?: string, format?: string) => string;
+/**
+ * Returns the first non-zero number from a list of arguments, or 0 if no such number exists.
+ *
+ * This function iterates over the arguments and returns the first one that is a non-zero number.
+ * If no such number is found, it returns 0.
+ *
+ * @param args A list of arguments to check.
+ * @returns The first non-zero number, or 0 if no such number exists.
+ */
+export declare function defaultNumber(...args: any[]): number;