toolbox-x 2.2.4 → 2.3.0

package/dist/{basics-byj0VH1c.cjs → utils-DR9g0Sef.cjs}

@@ -16,458 +16,215 @@
 
 const require_primitives = require('./primitives-CBGICrDR.cjs');
 const require_specials = require('./specials-DU8u108m.cjs');
-const require_utilities = require('./utilities-BVpk3LKy.cjs');
-const require_guards = require('./guards-CqbVT4L5.cjs');
+const require_utilities = require('./utilities-_COSGq1U.cjs');
+const require_guards = require('./guards-BD2Fkugj.cjs');
 
-//#region src/array/helpers.ts
-/**
-* Safely resolves value of nested key (dot-notation key like `"user.city"`).
-*
-* @param obj - The source object
-* @param path - The nested path string (e.g. `"user.city"`)
-* @returns The resolved value or `undefined`
-*/
-function _resolveNestedKey(obj, path) {
-	if (require_specials.isNotEmptyObject(obj)) return path?.split(".").reduce((acc, key) => {
-		if (require_specials.isNotEmptyObject(acc)) return acc[key];
-	}, obj);
-}
-/**
-* Retrieves a numeric value from a nested property (dot-notation key like 'user.income.tax').
-* Falls back to 0 if value is not a number or numeric string.
-*
-* @param obj - The source object to read from.
-* @param path - The dot-notation path string like 'user.income.tax'.
-* @returns The numeric value at that path, or 0 if	 not valid.
-*/
-function _getNumericProp(obj, path) {
-	return require_utilities.normalizeNumber(_resolveNestedKey(obj, path)) ?? 0;
-}
-
-//#endregion
-//#region src/array/sort.ts
-/**
-* Compare two strings using natural sorting (e.g., `"file2"` < `"file10"`).
-* - Optionally supports case-insensitive and locale-aware string chunk comparisons.
-*
-* @param a - The first string to compare.
-* @param b - The second string to compare.
-* @param options - Optional settings to configure comparison behavior.
-* @returns A negative number if `a` comes before `b`, a positive number if `a` comes after `b`, or 0 if equal.
-*/
-function naturalSort(a, b, options) {
-	const { caseInsensitive = true, localeAware = false } = options || {};
-	/**
-	* * Splits a string into an array of number and non-number chunks.
-	* @param str - The string to split.
-	* @returns An array of string and number parts.
-	*/
-	const _createChunks = (str) => {
-		const chunks = [];
-		let current = "";
-		let isNumeric = false;
-		for (const char of str) {
-			const charIsNum = !Number.isNaN(Number(char));
-			if (current?.length === 0) {
-				current = char;
-				isNumeric = charIsNum;
-				continue;
-			}
-			if (charIsNum === isNumeric) current += char;
-			else {
-				chunks?.push(isNumeric ? Number(current) : current);
-				current = char;
-				isNumeric = charIsNum;
-			}
-		}
-		if (current?.length > 0) chunks?.push(isNumeric ? Number(current) : current);
-		return chunks;
-	};
-	const aChunks = _createChunks(a);
-	const bChunks = _createChunks(b);
-	for (let i = 0; i < Math.min(aChunks?.length, bChunks?.length); i++) {
-		let aChunk = aChunks[i];
-		let bChunk = bChunks[i];
-		if (caseInsensitive && require_primitives.isString(aChunk) && require_primitives.isString(bChunk)) {
-			aChunk = aChunk?.toLowerCase();
-			bChunk = bChunk?.toLowerCase();
-		}
-		if (typeof aChunk !== typeof bChunk) return require_primitives.isString(aChunk) ? 1 : -1;
-		if (aChunk !== bChunk) {
-			if (require_primitives.isNumber(aChunk) && require_primitives.isNumber(bChunk)) return aChunk - bChunk;
-			if (require_primitives.isString(aChunk) && require_primitives.isString(bChunk)) {
-				if (localeAware) {
-					const cmp = aChunk.localeCompare(bChunk, void 0, { sensitivity: caseInsensitive ? "accent" : "variant" });
-					if (cmp !== 0) return cmp;
-				}
-				return aChunk < bChunk ? -1 : 1;
-			}
-		}
-	}
-	return aChunks?.length - bChunks?.length;
-}
+//#region src/string/basics.ts
 /**
-* * Sorts an array of strings, numbers, booleans, or objects based on the provided options.
+* * Utility to truncate a string to a specified length.
 *
-* @param array - The array to sort.
-* @param options - Sorting options.
-* @returns The sorted array.
+* @param str The string to truncate.
+* @param maxLength The maximum length of the truncated string.
+* @returns Truncated string with ellipsis (`...`) (only if it has more length than `maxLength`).
 */
-function sortAnArray(array, options) {
-	if (!require_specials.isValidArray(array)) return array;
-	if (require_specials.isArrayOfType(array, require_primitives.isString)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? naturalSort(b, a) : naturalSort(a, b));
-	if (require_specials.isArrayOfType(array, require_primitives.isNumber)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? b - a : a - b);
-	if (require_specials.isArrayOfType(array, require_primitives.isBoolean)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? Number(b) - Number(a) : Number(a) - Number(b));
-	if (require_specials.isArrayOfType(array, require_specials.isObject) && options && "sortByField" in options) return [...array].sort((a, b) => {
-		const _getKeyValue = (obj, path) => {
-			return path.split(".").reduce((acc, key) => acc?.[key], obj);
-		};
-		const keyA = _getKeyValue(a, options?.sortByField);
-		const keyB = _getKeyValue(b, options?.sortByField);
-		if (keyA == null || keyB == null) return keyA == null ? 1 : -1;
-		if (require_primitives.isString(keyA) && require_primitives.isString(keyB)) return options?.sortOrder === "desc" ? naturalSort(keyB, keyA) : naturalSort(keyA, keyB);
-		if (require_primitives.isNumber(keyA) && require_primitives.isNumber(keyB)) return options?.sortOrder === "desc" ? keyB - keyA : keyA - keyB;
-		if (require_primitives.isBoolean(keyA) && require_primitives.isBoolean(keyB)) return options?.sortOrder === "desc" ? Number(keyB) - Number(keyA) : Number(keyA) - Number(keyB);
-		return 0;
-	});
-	return [...array];
+function truncateString(str, maxLength) {
+	if (!require_primitives.isNonEmptyString(str)) return "";
+	const trimmedString = str.trim();
+	if (!trimmedString) return "";
+	if (trimmedString.length <= maxLength) return trimmedString;
+	return trimmedString.slice(0, maxLength).concat("...");
 }
-
-//#endregion
-//#region src/utils/index.ts
-/**
-* * Deeply compare two values (arrays, objects, or primitive values).
-*
-* @param a First value to compare.
-* @param b Second value to compare.
-* @returns Whether the values are deeply equal.
-*/
-const isDeepEqual = (a, b) => {
-	if (a === b) return true;
-	if (typeof a !== typeof b) return false;
-	if (a === null || b === null) return a === b;
-	if (require_specials.isArray(a) && require_specials.isArray(b)) {
-		if (a?.length !== b?.length) return false;
-		return a?.every((element, index) => isDeepEqual(element, b?.[index]));
-	}
-	if (require_specials.isObject(a) && require_specials.isObject(b)) {
-		const aKeys = Object.keys(a);
-		const bKeys = Object.keys(b);
-		if (aKeys?.length !== bKeys?.length) return false;
-		return aKeys?.every((key) => isDeepEqual(a?.[key], b?.[key]));
-	}
-	return false;
-};
 /**
-* * Converts an array of primitive values or objects to a string using a separator or target key.
+* * Generates a random alphanumeric (16 characters long, this length is customizable in the options) ID string composed of an optional `prefix`, `suffix`, a `timestamp`, `caseOption` and a customizable `separator`.
 *
-* @param array Array to convert.
-* @param options Options for separator or key extraction from objects.
-* @returns String representation of array values.
-*/
-function convertArrayToString(array, options) {
-	if (!require_specials.isValidArray(array)) return "";
-	const { separator = ", " } = options ?? {};
-	if (require_specials.isArrayOfType(array, require_primitives.isPrimitive)) return array?.join(separator);
-	else if (require_specials.isArrayOfType(array, require_specials.isNotEmptyObject)) if (options && "target" in options) return array?.map((el) => _resolveNestedKey(el, options?.target))?.join(separator);
-	else return "";
-	return "";
-}
-/**
-* * A generic debounce function that delays the execution of a callback.
+* @param options Configuration options for random ID generation.
+* @returns The generated ID string composed of the random alphanumeric string of specified length with optional `timeStamp`, `prefix`, and `suffix`, `caseOption` and `separator`.
 *
-* @param callback - The function to debounce.
-* @param delay - The delay in milliseconds. Default is `300ms`.
-* @returns A debounced version of the callback function.
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/uuid uuid} for `uuid` generation
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/random-hex randomHex} for random hexadecimal string generation
 *
 * @example
-* const debouncedSearch = debounceAction((query: string) => {
-*   console.log(`Searching for: ${query}`);
-* }, 300);
+* // Generate an ID with all default options
+* const id = generateRandomID();
+* // Example output: "swo8ckxwsc13w7xw"
 *
-* debouncedSearch('laptop'); // Executes after 300ms of inactivity.
-*/
-function debounceAction(callback, delay = 300) {
-	let timeoutId;
-	return (...args) => {
-		clearTimeout(timeoutId);
-		timeoutId = setTimeout(() => {
-			callback(...args);
-		}, delay);
-	};
-}
-/**
-* * A generic throttle function that ensures a callback is executed at most once per specified interval.
+* @example
+* // Generate an ID with a custom prefix and separator
+* const id = generateRandomID({ prefix: 'ID', separator: '-' });
+* // Example output: "ID-eh1ymwfxzwas9jte"
 *
-* @param callback - The function to throttle.
-* @param delay - The delay in milliseconds. Default is `150ms`.
-* @returns A throttled version of the callback function.
+* @example
+* // Generate an ID with a timestamp
+* const id = generateRandomID({ timeStamp: false });
+* // Example output: "1764610287501pd3r4w85qwkuulgf"
 *
 * @example
-* const throttledResize = throttleAction(() => {
-*   console.log('Resized');
-* }, 300);
+* // Generate an ID with a custom length for the random string
+* const id = generateRandomID({ length: 8 });
+* // Example output: "i623uiev"
 *
-* window.addEventListener('resize', throttledResize);
-*/
-function throttleAction(callback, delay = 150) {
-	let lastCall = 0;
-	return (...args) => {
-		const now = Date.now();
-		if (now - lastCall >= delay) {
-			lastCall = now;
-			callback(...args);
-		}
-	};
-}
-/**
-* * Retrieves the names of all instance methods defined directly on a class prototype.
+* @example
+* // Generate an ID with a custom suffix
+* const id = generateRandomID({ suffix: 'END' });
+* // Example output: "3csf27a4800rbli9END"
 *
-* @param cls - The class constructor (not an instance).
-* @returns A sorted array of instance method names.
-*/
-function getInstanceMethodNames(cls) {
-	const prototype = cls.prototype;
-	return sortAnArray(Object.getOwnPropertyNames(prototype).filter((method) => {
-		if (method === "constructor") return false;
-		return require_specials.isMethodDescriptor(Object.getOwnPropertyDescriptor(prototype, method));
-	}));
-}
-/**
-* * Retrieves the names of all static methods defined directly on a class constructor.
+* @example
+* // Generate an ID with a uppercase random string
+* const id = generateRandomID({ caseOption: "upper" });
+* // Example output: "H0VNU6O8XV1Y30HG"
 *
-* @param cls - The class constructor (not an instance).
-* @returns A sorted array of static method names.
+* @example
+* // Generate an ID with all options customized
+* const id = generateRandomID({
+*   prefix: 'ID',
+*   suffix: 'END',
+*   timeStamp: true,
+*   length: 10,
+*   separator: '-',
+*   caseOption: "upper"
+* });
+* // Example output: "ID-1764610471474-4KSL51IB91-END"
 */
-function getStaticMethodNames(cls) {
-	return sortAnArray(Object.getOwnPropertyNames(cls).filter((method) => {
-		return method !== "prototype" && method !== "name" && method !== "length";
-	}));
+function generateRandomID(options) {
+	const { prefix = "", suffix = "", timeStamp = false, length = 16, separator = "", caseOption = null } = options || {};
+	const date = timeStamp ? Date.now() : "";
+	const randomString = Array.from({ length }, () => Math.random().toString(36).slice(2, 3)).join("");
+	const ID = [
+		prefix?.trim(),
+		date,
+		randomString,
+		suffix?.trim()
+	].filter(Boolean).join(separator);
+	switch (caseOption) {
+		case "upper": return ID.toUpperCase();
+		case "lower": return ID.toLowerCase();
+		default: return ID;
+	}
 }
 /**
-* * Counts the number of instance methods defined directly on a class prototype.
+* * Trims all whitespaces in a string or an array of strings.
 *
-* @param cls - The class constructor (not an instance).
-* @returns The number of instance methods defined on the class prototype.
+* @param input String or array of strings.
+* @returns Trimmed string or array of strings.
 */
-function countInstanceMethods(cls) {
-	return getInstanceMethodNames(cls)?.length;
+function trimString(input) {
+	if (!input) return "";
+	if (require_primitives.isNonEmptyString(input)) return input.trim().replace(/\s+/g, " ");
+	if (Array.isArray(input)) return input.map((str) => require_primitives.isNonEmptyString(str) ? str.trim().replace(/\s+/g, " ") : str);
+	throw new TypeError("Expected string or array of strings!", { cause: "Invalid Input Type" });
 }
+
+//#endregion
+//#region src/hash/utils.ts
 /**
-* * Counts the number of static methods defined directly on a class constructor.
+* * Generates random bytes in the {@link Uint8Array} format.
 *
-* @param cls - The class constructor (not an instance).
-* @returns The number of static methods defined on the class constructor.
-*/
-function countStaticMethods(cls) {
-	return getStaticMethodNames(cls)?.length;
-}
-/**
-* * Retrieves the names of all instance getters defined directly on a class prototype.
+* @param size - The length of the byte array to generate. Defaults to `8`.
+* @returns A random array of bytes.
 *
-* @param cls - The class constructor (not an instance).
-* @returns A sorted array of instance getter names.
-*/
-function getInstanceGetterNames(cls) {
-	const descriptors = Object.getOwnPropertyDescriptors(cls.prototype);
-	return sortAnArray(Object.entries(descriptors).filter(([key, desc]) => require_specials.isFunction(desc.get) && key !== "constructor").map(([key]) => key));
-}
-/**
-* * Retrieves the names of all static getters defined directly on a class constructor.
+* @example
+* ```typescript
+* const bytes = randomBytes(16);
+* // Returns something like: Uint8Array(16) [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 224, 166, 170, 224, 167, 131]
 *
-* @param cls - The class constructor (not an instance).
-* @returns A sorted array of static getter names.
-*/
-function getStaticGetterNames(cls) {
-	return sortAnArray(Object.entries(Object.getOwnPropertyDescriptors(cls)).filter(([key, desc]) => typeof desc.get === "function" && key !== "prototype").map(([key]) => key));
-}
-/**
-* * Gathers detailed information about the instance and static methods of a class.
+* // Empty array
+* const empty = randomBytes(0);
+* // Returns: Uint8Array(0) []
 *
-* @param cls - The class constructor (not an instance).
-* @returns An object containing names and counts of instance and static methods.
-*/
-function getClassDetails(cls) {
-	const instanceNames = getInstanceMethodNames(cls);
-	const staticNames = getStaticMethodNames(cls);
-	const instanceGetters = getInstanceGetterNames(cls);
-	const staticGetters = getStaticGetterNames(cls);
-	return {
-		instanceMethods: instanceNames,
-		staticMethods: staticNames,
-		instanceGetters,
-		staticGetters,
-		instanceCount: instanceNames?.length,
-		staticCount: staticNames?.length,
-		totalGetters: instanceGetters?.length + staticGetters?.length,
-		totalMethods: instanceNames?.length + staticNames?.length
-	};
-}
-/**
-* * Create a deterministic JSON string representation of any value.
-*   - The output format matches standard JSON but with guaranteed sorted keys.
+* // Zero or negative values are treated as 0
+* const zero = randomBytes(-5);
+* // Returns: Uint8Array(0) []
+* ```
 *
 * @remarks
-* - This function guarantees **stable, repeatable output** by:
-* 	 - Sorting all object keys alphabetically.
-* 	 - Recursively stabilizing nested objects and arrays.
-* 	 - Converting all `undefined` values into `null` so the output remains valid JSON.
-*   - Converting date-like objects (`Date`, `Chronos`, `Moment.js`, `Day.js`, `Luxon`, `JS-Joda`, `Temporal`) **in the same way that {@link JSON.stringify} would serialize them**, ensuring predictable and JSON-compliant output.
-*   - Falling back to native JSON serialization for primitives.
-*
-* - **Useful for:**
-*   - Hash generation (e.g., signatures, cache keys)
-*   - Deep equality checks
-*   - Producing predictable output across environments
-*
-* @param obj - The value to stringify into a deterministic JSON string.
-* @returns A stable, deterministic string representation of the input.
+* - It uses {@link crypto.getRandomValues} when available for secure randomness, and falls back to {@link Math.random} if not.
+* - If {@link crypto.getRandomValues} is available (supported environments include browser and Node.js), it is used for cryptographically secure random number generation.
+* - In environments where {@link crypto.getRandomValues} is not available, the function falls back to {@link Math.random}, which is **not** cryptographically secure.
+* - {@link crypto.getRandomValues} fills the array with random values in the range [0, 255] (inclusive).
+* - {@link Math.random} returns values in the range [0, 1) (exclusive of 1), so the values are scaled to [0, 255].
+* - If `size` is 0 or negative, an empty `Uint8Array` is returned.
 */
-function stableStringify(obj) {
-	const _replacer = (_, v) => v === void 0 ? null : v;
-	if (require_specials.isNotEmptyObject(obj)) return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k, _replacer) + ":" + (require_guards.isDateLike(obj[k]) ? JSON.stringify(obj[k]) : stableStringify(obj[k]))).join(",") + "}";
-	if (require_specials.isValidArray(obj)) return "[" + obj.map((v) => stableStringify(v)).join(",") + "]";
-	return JSON.stringify(obj, _replacer);
+function randomBytes(size = 8) {
+	if (size <= 0) return new Uint8Array(0);
+	return _fillWithRandomValues(new Uint8Array(size));
 }
 /**
-* * Remove trailing or leading garbage characters **after/before JSON object or array**.
-* @param str String to sanitize/strip.
-* @returns Sanitized/stripped JSON string.
-*/
-function stripJsonEdgeGarbage(str) {
-	if (!require_primitives.isNonEmptyString(str)) return "";
-	const lastIdx = Math.max(str.lastIndexOf("}"), str.lastIndexOf("]"));
-	const _idxOf = (sym) => str.indexOf(sym) !== -1 ? str.indexOf(sym) : Infinity;
-	const firstIdx = Math.min(_idxOf("{"), _idxOf("["));
-	if (lastIdx === -1 || firstIdx === Infinity) return str;
-	return str.slice(firstIdx, lastIdx + 1);
-}
-/**
-* * Parses any valid JSON string, optionally converting stringified primitives inside (nested) arrays or objects.
+* * Generates a random hexadecimal string of the specified length.
 *
-* @typeParam T - Expected return type (default is unknown).
-* @param value - The JSON string to parse.
-* @param parsePrimitives - Whether to convert stringified primitives (default: `true`).
-* @returns The parsed JSON value typed as `T`, or the original parsed value with optional primitive conversion.
-* - Returns `{}` if parsing fails, such as when the input is malformed or invalid JSON or passing single quoted string.
+* @param length - Number of hex characters to generate.
+* @param uppercase - Whether to return uppercase `A–F` characters. Defaults to `false` (lowercase).
 *
-* - *Unlike {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/object/parse-json-to-object parseJsonToObject}, which ensures the root value is an object,
-* this function returns any valid JSON structure such as arrays, strings, numbers, or objects.*
+* @returns A randomly generated hexadecimal string.
 *
-* This is useful when you're not sure of the root structure of the JSON, or when you expect something other than an object.
+* @remarks
+* - This function generates a random hexadecimal string of the specified length.
+* - It uses {@link crypto.getRandomValues} when available for secure randomness, and falls back to {@link Math.random} if not.
+* - The output is a string of hex characters (`0–9`, `a–f` or `A–F`) with no prefixes or separators.
+* - If `length` is `0` or negative, an empty string is returned.
 *
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/object/parse-json-to-object parseJsonToObject} for strict object-only parsing.
-*/
-const parseJSON = (value, parsePrimitives = true) => {
-	try {
-		const parsed = JSON.parse(value);
-		return parsePrimitives ? deepParsePrimitives(parsed) : parsed;
-	} catch {
-		return {};
-	}
-};
-/**
-* * Recursively parses primitive values inside objects and arrays.
+* @example
+* // 16-character lowercase hex
+* const id = randomHex(16);
 *
-* @typeParam T - Expected return type after parsing (default is unknown).
-* @param input - Any input value to parse recursively.
-* @returns Input with primitives (strings like "true", "123") converted, typed as `T`.
+* @example
+* // 8-character uppercase hex
+* const token = randomHex(8, true);
 */
-function deepParsePrimitives(input) {
-	if (Array.isArray(input)) return input?.map(deepParsePrimitives);
-	if (require_specials.isObject(input)) {
-		const result = {};
-		for (const [key, value] of Object.entries(input)) result[key] = deepParsePrimitives(value);
-		return result;
-	}
-	if (require_primitives.isString(input)) {
-		if (/^(true|false)$/i.test(input)) return input?.toLowerCase() === "true";
-		if (require_specials.isNumericString(input)) return Number(input);
-		if (input === "null") return null;
-		if (input === "undefined") return;
-		return input;
-	}
-	return input;
+function randomHex(length, uppercase = false) {
+	if (length <= 0) return "";
+	const expected = _bytesToRandomHex(new Uint8Array(Math.ceil(length / 2))).slice(0, length);
+	return uppercase ? expected.toUpperCase() : expected;
 }
 /**
-* * Defines a method on any prototype — including built-in prototypes — in a safe, idempotent manner.
-* 	 - The method is non-enumerable by default and will not overwrite an existing method unless explicitly allowed.
+* * Generates a random numeric string of the specified length.
 *
-* @param proto   The target prototype object (e.g., String.prototype).
-* @param name    The method name to define on the prototype.
-* @param impl    The function implementation for the method.
-* @param options Optional property-descriptor settings and overwrite rules.
+* @param length - Length of the numeric string. Defaults to `6`.
+* @returns A randomly generated numeric string.
 *
 * @example
-* // Safely augment prototype methods by extending the global interface:
-* declare global {
-* 	interface String {
-* 		toBang(): string;
-* 	}
-* }
-*
-* // Define a custom method on String.prototype
-* definePrototypeMethod(String.prototype, 'toBang', function (this: String) {
-* 	return this.toString().concat('!');
-* 	// or
-* 	// return this.concat('!');
-* });
-*
-* "Hi".toBang(); // "Hi!"
-*
-* // Attempting to redefine without overwrite option is ignored
-* definePrototypeMethod(String.prototype, 'toBang', () => 'x'); // ignored
-*
-* // Overwrite intentionally using the overwrite option
-* definePrototypeMethod(
-*   String.prototype,
-*   'toBang',
-*   function (this: String) { return this.concat('!!!'); },
-*   { overwrite: true }
-* );
+* ```typescript
+* const otp = randomNumeric(6);
+* // Returns something like: '123456'
+* ```
 *
-* "Hi".toBang(); // "Hi!!!"
+* @remarks
+* - If `length` is `0` or negative, an empty string is returned.
 */
-function definePrototypeMethod(proto, name, impl, options) {
-	if (Object.hasOwn(proto, name) && !options?.overwrite) return;
-	Object.defineProperty(proto, name, {
-		value: function(...args) {
-			return impl.apply(this, args);
-		},
-		enumerable: options?.enumerable ?? false,
-		configurable: options?.configurable ?? false,
-		writable: options?.writable ?? true
-	});
+function randomNumeric(length = 6) {
+	return randomBytes(length).map((byte) => byte & 10).join("");
 }
-
-//#endregion
-//#region src/hash/utils.ts
 /**
-* * Generates a random hexadecimal string of the specified length.
+* * Generates a random alphanumeric string (letters and numbers) of the specified length.
 *
-* @param length - Number of hex characters to generate.
-* @param uppercase - Whether to return uppercase `A–F` characters. Defaults to `false` (lowercase).
+* @param length - The desired length of the random string. Defaults to `8`.
+* @param uppercase - If `true`, the string will contain uppercase letters (A-Z). Defaults to `false` (lowercase).
 *
-* @returns A randomly generated hexadecimal string.
-*
-* @remarks
-* - This function generates a random hexadecimal string of the specified length.
-* - It uses {@link crypto.getRandomValues} when available for secure randomness, and falls back to {@link Math.random} if not.
-* - The output is a string of hex characters (`0–9`, `a–f` or `A–F`) with no prefixes or separators.
-* - If `length` is `0` or negative, an empty string is returned.
+* @returns A random string composed of alphanumeric characters.
 *
 * @example
-* // 16-character lowercase hex
-* const id = randomHex(16);
+* ```typescript
+* // Generate a random 8-character alphanumeric string (default: lowercase)
+* const randomStr = randomAlphaNumeric(8);
+* // Example output: "a7b2f9d1"
 *
-* @example
-* // 8-character uppercase hex
-* const token = randomHex(8, true);
+* // Generate a 12-character uppercase alphanumeric string
+* const randomUpper = randomAlphaNumeric(12, true);
+* // Example output: "X5K9P2M7H4L3"
+*
+* // Generate a 6-character string
+* const shortStr = randomAlphaNumeric(6);
+* ```
+*
+* @remarks
+* - The function generates random bytes and converts them to base-36 (0-9, a-z) characters.
+* - If `length` is `0` or negative, an empty string is returned.
 */
-function randomHex(length, uppercase = false) {
-	if (length <= 0) return "";
-	const expected = _bytesToRandomHex(new Uint8Array(Math.ceil(length / 2))).slice(0, length);
-	return uppercase ? expected.toUpperCase() : expected;
+function randomAlphaNumeric(length = 8, uppercase = false) {
+	const bytes = randomBytes(Math.ceil(length / 2));
+	let ran = "";
+	for (const byte of bytes) ran += byte.toString(36).padStart(2, "0");
+	const result = ran.slice(0, length);
+	return uppercase ? result.toUpperCase() : result;
 }
 /**
 * * Converts a UTF-8 string to a byte array (`Uint8Array`).
@@ -1644,109 +1401,435 @@ function isUUIDv5(value) {
 function isUUIDv6(value) {
 	return _checkUUIDVersion(value, "6");
 }
-/** Check if a value is UUID version 7 */
-function isUUIDv7(value) {
-	return _checkUUIDVersion(value, "7");
+/** Check if a value is UUID version 7 */
+function isUUIDv7(value) {
+	return _checkUUIDVersion(value, "7");
+}
+/** Check if a value is UUID version 8 */
+function isUUIDv8(value) {
+	return _checkUUIDVersion(value, "8");
+}
+
+//#endregion
+//#region src/array/helpers.ts
+/**
+* Safely resolves value of nested key (dot-notation key like `"user.city"`).
+*
+* @param obj - The source object
+* @param path - The nested path string (e.g. `"user.city"`)
+* @returns The resolved value or `undefined`
+*/
+function _resolveNestedKey(obj, path) {
+	if (require_specials.isNotEmptyObject(obj)) return path?.split(".").reduce((acc, key) => {
+		if (require_specials.isNotEmptyObject(acc)) return acc[key];
+	}, obj);
+}
+/**
+* Retrieves a numeric value from a nested property (dot-notation key like 'user.income.tax').
+* Falls back to 0 if value is not a number or numeric string.
+*
+* @param obj - The source object to read from.
+* @param path - The dot-notation path string like 'user.income.tax'.
+* @returns The numeric value at that path, or 0 if	 not valid.
+*/
+function _getNumericProp(obj, path) {
+	return require_utilities.normalizeNumber(_resolveNestedKey(obj, path)) ?? 0;
+}
+
+//#endregion
+//#region src/array/sort.ts
+/**
+* Compare two strings using natural sorting (e.g., `"file2"` < `"file10"`).
+* - Optionally supports case-insensitive and locale-aware string chunk comparisons.
+*
+* @param a - The first string to compare.
+* @param b - The second string to compare.
+* @param options - Optional settings to configure comparison behavior.
+* @returns A negative number if `a` comes before `b`, a positive number if `a` comes after `b`, or 0 if equal.
+*/
+function naturalSort(a, b, options) {
+	const { caseInsensitive = true, localeAware = false } = options || {};
+	/**
+	* * Splits a string into an array of number and non-number chunks.
+	* @param str - The string to split.
+	* @returns An array of string and number parts.
+	*/
+	const _createChunks = (str) => {
+		const chunks = [];
+		let current = "";
+		let isNumeric = false;
+		for (const char of str) {
+			const charIsNum = !Number.isNaN(Number(char));
+			if (current?.length === 0) {
+				current = char;
+				isNumeric = charIsNum;
+				continue;
+			}
+			if (charIsNum === isNumeric) current += char;
+			else {
+				chunks?.push(isNumeric ? Number(current) : current);
+				current = char;
+				isNumeric = charIsNum;
+			}
+		}
+		if (current?.length > 0) chunks?.push(isNumeric ? Number(current) : current);
+		return chunks;
+	};
+	const aChunks = _createChunks(a);
+	const bChunks = _createChunks(b);
+	for (let i = 0; i < Math.min(aChunks?.length, bChunks?.length); i++) {
+		let aChunk = aChunks[i];
+		let bChunk = bChunks[i];
+		if (caseInsensitive && require_primitives.isString(aChunk) && require_primitives.isString(bChunk)) {
+			aChunk = aChunk?.toLowerCase();
+			bChunk = bChunk?.toLowerCase();
+		}
+		if (typeof aChunk !== typeof bChunk) return require_primitives.isString(aChunk) ? 1 : -1;
+		if (aChunk !== bChunk) {
+			if (require_primitives.isNumber(aChunk) && require_primitives.isNumber(bChunk)) return aChunk - bChunk;
+			if (require_primitives.isString(aChunk) && require_primitives.isString(bChunk)) {
+				if (localeAware) {
+					const cmp = aChunk.localeCompare(bChunk, void 0, { sensitivity: caseInsensitive ? "accent" : "variant" });
+					if (cmp !== 0) return cmp;
+				}
+				return aChunk < bChunk ? -1 : 1;
+			}
+		}
+	}
+	return aChunks?.length - bChunks?.length;
+}
+/**
+* * Sorts an array of strings, numbers, booleans, or objects based on the provided options.
+*
+* @param array - The array to sort.
+* @param options - Sorting options.
+* @returns The sorted array.
+*/
+function sortAnArray(array, options) {
+	if (!require_specials.isValidArray(array)) return array;
+	if (require_specials.isArrayOfType(array, require_primitives.isString)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? naturalSort(b, a) : naturalSort(a, b));
+	if (require_specials.isArrayOfType(array, require_primitives.isNumber)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? b - a : a - b);
+	if (require_specials.isArrayOfType(array, require_primitives.isBoolean)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? Number(b) - Number(a) : Number(a) - Number(b));
+	if (require_specials.isArrayOfType(array, require_specials.isObject) && options && "sortByField" in options) return [...array].sort((a, b) => {
+		const _getKeyValue = (obj, path) => {
+			return path.split(".").reduce((acc, key) => acc?.[key], obj);
+		};
+		const keyA = _getKeyValue(a, options?.sortByField);
+		const keyB = _getKeyValue(b, options?.sortByField);
+		if (keyA == null || keyB == null) return keyA == null ? 1 : -1;
+		if (require_primitives.isString(keyA) && require_primitives.isString(keyB)) return options?.sortOrder === "desc" ? naturalSort(keyB, keyA) : naturalSort(keyA, keyB);
+		if (require_primitives.isNumber(keyA) && require_primitives.isNumber(keyB)) return options?.sortOrder === "desc" ? keyB - keyA : keyA - keyB;
+		if (require_primitives.isBoolean(keyA) && require_primitives.isBoolean(keyB)) return options?.sortOrder === "desc" ? Number(keyB) - Number(keyA) : Number(keyA) - Number(keyB);
+		return 0;
+	});
+	return [...array];
+}
+
+//#endregion
+//#region src/utils/index.ts
+/**
+* * Deeply compare two values (arrays, objects, or primitive values).
+*
+* @param a First value to compare.
+* @param b Second value to compare.
+* @returns Whether the values are deeply equal.
+*/
+const isDeepEqual = (a, b) => {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (a === null || b === null) return a === b;
+	if (require_specials.isArray(a) && require_specials.isArray(b)) {
+		if (a?.length !== b?.length) return false;
+		return a?.every((element, index) => isDeepEqual(element, b?.[index]));
+	}
+	if (require_specials.isObject(a) && require_specials.isObject(b)) {
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		if (aKeys?.length !== bKeys?.length) return false;
+		return aKeys?.every((key) => isDeepEqual(a?.[key], b?.[key]));
+	}
+	return false;
+};
+/**
+* * Converts an array of primitive values or objects to a string using a separator or target key.
+*
+* @param array Array to convert.
+* @param options Options for separator or key extraction from objects.
+* @returns String representation of array values.
+*/
+function convertArrayToString(array, options) {
+	if (!require_specials.isValidArray(array)) return "";
+	const { separator = ", " } = options ?? {};
+	if (require_specials.isArrayOfType(array, require_primitives.isPrimitive)) return array?.join(separator);
+	else if (require_specials.isArrayOfType(array, require_specials.isNotEmptyObject)) if (options && "target" in options) return array?.map((el) => _resolveNestedKey(el, options?.target))?.join(separator);
+	else return "";
+	return "";
+}
+/**
+* * A generic debounce function that delays the execution of a callback.
+*
+* @param callback - The function to debounce.
+* @param delay - The delay in milliseconds. Default is `300ms`.
+* @returns A debounced version of the callback function.
+*
+* @example
+* const debouncedSearch = debounceAction((query: string) => {
+*   console.log(`Searching for: ${query}`);
+* }, 300);
+*
+* debouncedSearch('laptop'); // Executes after 300ms of inactivity.
+*/
+function debounceAction(callback, delay = 300) {
+	let timeoutId;
+	return (...args) => {
+		clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			callback(...args);
+		}, delay);
+	};
+}
+/**
+* * A generic throttle function that ensures a callback is executed at most once per specified interval.
+*
+* @param callback - The function to throttle.
+* @param delay - The delay in milliseconds. Default is `150ms`.
+* @returns A throttled version of the callback function.
+*
+* @example
+* const throttledResize = throttleAction(() => {
+*   console.log('Resized');
+* }, 300);
+*
+* window.addEventListener('resize', throttledResize);
+*/
+function throttleAction(callback, delay = 150) {
+	let lastCall = 0;
+	return (...args) => {
+		const now = Date.now();
+		if (now - lastCall >= delay) {
+			lastCall = now;
+			callback(...args);
+		}
+	};
+}
+/**
+* * Retrieves the names of all instance methods defined directly on a class prototype.
+*
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of instance method names.
+*/
+function getInstanceMethodNames(cls) {
+	const prototype = cls.prototype;
+	return sortAnArray(Object.getOwnPropertyNames(prototype).filter((method) => {
+		if (method === "constructor") return false;
+		return require_specials.isMethodDescriptor(Object.getOwnPropertyDescriptor(prototype, method));
+	}));
+}
+/**
+* * Retrieves the names of all static methods defined directly on a class constructor.
+*
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of static method names.
+*/
+function getStaticMethodNames(cls) {
+	return sortAnArray(Object.getOwnPropertyNames(cls).filter((method) => {
+		return method !== "prototype" && method !== "name" && method !== "length";
+	}));
+}
+/**
+* * Counts the number of instance methods defined directly on a class prototype.
+*
+* @param cls - The class constructor (not an instance).
+* @returns The number of instance methods defined on the class prototype.
+*/
+function countInstanceMethods(cls) {
+	return getInstanceMethodNames(cls)?.length;
+}
+/**
+* * Counts the number of static methods defined directly on a class constructor.
+*
+* @param cls - The class constructor (not an instance).
+* @returns The number of static methods defined on the class constructor.
+*/
+function countStaticMethods(cls) {
+	return getStaticMethodNames(cls)?.length;
 }
-/** Check if a value is UUID version 8 */
-function isUUIDv8(value) {
-	return _checkUUIDVersion(value, "8");
+/**
+* * Retrieves the names of all instance getters defined directly on a class prototype.
+*
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of instance getter names.
+*/
+function getInstanceGetterNames(cls) {
+	const descriptors = Object.getOwnPropertyDescriptors(cls.prototype);
+	return sortAnArray(Object.entries(descriptors).filter(([key, desc]) => require_specials.isFunction(desc.get) && key !== "constructor").map(([key]) => key));
 }
-
-//#endregion
-//#region src/string/basics.ts
 /**
-* * Utility to truncate a string to a specified length.
+* * Retrieves the names of all static getters defined directly on a class constructor.
 *
-* @param str The string to truncate.
-* @param maxLength The maximum length of the truncated string.
-* @returns Truncated string with ellipsis (`...`) (only if it has more length than `maxLength`).
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of static getter names.
 */
-function truncateString(str, maxLength) {
-	if (!require_primitives.isNonEmptyString(str)) return "";
-	const trimmedString = str.trim();
-	if (!trimmedString) return "";
-	if (trimmedString.length <= maxLength) return trimmedString;
-	return trimmedString.slice(0, maxLength).concat("...");
+function getStaticGetterNames(cls) {
+	return sortAnArray(Object.entries(Object.getOwnPropertyDescriptors(cls)).filter(([key, desc]) => typeof desc.get === "function" && key !== "prototype").map(([key]) => key));
 }
 /**
-* * Generates a random alphanumeric (16 characters long, this length is customizable in the options) ID string composed of an optional `prefix`, `suffix`, a `timestamp`, `caseOption` and a customizable `separator`.
+* * Gathers detailed information about the instance and static methods of a class.
 *
-* @param options Configuration options for random ID generation.
-* @returns The generated ID string composed of the random alphanumeric string of specified length with optional `timeStamp`, `prefix`, and `suffix`, `caseOption` and `separator`.
+* @param cls - The class constructor (not an instance).
+* @returns An object containing names and counts of instance and static methods.
+*/
+function getClassDetails(cls) {
+	const instanceNames = getInstanceMethodNames(cls);
+	const staticNames = getStaticMethodNames(cls);
+	const instanceGetters = getInstanceGetterNames(cls);
+	const staticGetters = getStaticGetterNames(cls);
+	return {
+		instanceMethods: instanceNames,
+		staticMethods: staticNames,
+		instanceGetters,
+		staticGetters,
+		instanceCount: instanceNames?.length,
+		staticCount: staticNames?.length,
+		totalGetters: instanceGetters?.length + staticGetters?.length,
+		totalMethods: instanceNames?.length + staticNames?.length
+	};
+}
+/**
+* * Create a deterministic JSON string representation of any value.
+*   - The output format matches standard JSON but with guaranteed sorted keys.
 *
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/uuid uuid} for `uuid` generation
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/random-hex randomHex} for random hexadecimal string generation
+* @remarks
+* - This function guarantees **stable, repeatable output** by:
+* 	 - Sorting all object keys alphabetically.
+* 	 - Recursively stabilizing nested objects and arrays.
+* 	 - Converting all `undefined` values into `null` so the output remains valid JSON.
+*   - Converting date-like objects (`Date`, `Chronos`, `Moment.js`, `Day.js`, `Luxon`, `JS-Joda`, `Temporal`) **in the same way that {@link JSON.stringify} would serialize them**, ensuring predictable and JSON-compliant output.
+*   - Falling back to native JSON serialization for primitives.
 *
-* @example
-* // Generate an ID with all default options
-* const id = generateRandomID();
-* // Example output: "swo8ckxwsc13w7xw"
+* - **Useful for:**
+*   - Hash generation (e.g., signatures, cache keys)
+*   - Deep equality checks
+*   - Producing predictable output across environments
 *
-* @example
-* // Generate an ID with a custom prefix and separator
-* const id = generateRandomID({ prefix: 'ID', separator: '-' });
-* // Example output: "ID-eh1ymwfxzwas9jte"
+* @param obj - The value to stringify into a deterministic JSON string.
+* @returns A stable, deterministic string representation of the input.
+*/
+function stableStringify(obj) {
+	const _replacer = (_, v) => v === void 0 ? null : v;
+	if (require_specials.isNotEmptyObject(obj)) return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k, _replacer) + ":" + (require_guards.isDateLike(obj[k]) ? JSON.stringify(obj[k]) : stableStringify(obj[k]))).join(",") + "}";
+	if (require_specials.isValidArray(obj)) return "[" + obj.map((v) => stableStringify(v)).join(",") + "]";
+	return JSON.stringify(obj, _replacer);
+}
+/**
+* * Remove trailing or leading garbage characters **after/before JSON object or array**.
+* @param str String to sanitize/strip.
+* @returns Sanitized/stripped JSON string.
+*/
+function stripJsonEdgeGarbage(str) {
+	if (!require_primitives.isNonEmptyString(str)) return "";
+	const lastIdx = Math.max(str.lastIndexOf("}"), str.lastIndexOf("]"));
+	const _idxOf = (sym) => str.indexOf(sym) !== -1 ? str.indexOf(sym) : Infinity;
+	const firstIdx = Math.min(_idxOf("{"), _idxOf("["));
+	if (lastIdx === -1 || firstIdx === Infinity) return str;
+	return str.slice(firstIdx, lastIdx + 1);
+}
+/**
+* * Parses any valid JSON string, optionally converting stringified primitives inside (nested) arrays or objects.
 *
-* @example
-* // Generate an ID with a timestamp
-* const id = generateRandomID({ timeStamp: false });
-* // Example output: "1764610287501pd3r4w85qwkuulgf"
+* @typeParam T - Expected return type (default is unknown).
+* @param value - The JSON string to parse.
+* @param parsePrimitives - Whether to convert stringified primitives (default: `true`).
+* @returns The parsed JSON value typed as `T`, or the original parsed value with optional primitive conversion.
+* - Returns `{}` if parsing fails, such as when the input is malformed or invalid JSON or passing single quoted string.
 *
-* @example
-* // Generate an ID with a custom length for the random string
-* const id = generateRandomID({ length: 8 });
-* // Example output: "i623uiev"
+* - *Unlike {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/object/parse-json-to-object parseJsonToObject}, which ensures the root value is an object,
+* this function returns any valid JSON structure such as arrays, strings, numbers, or objects.*
 *
-* @example
-* // Generate an ID with a custom suffix
-* const id = generateRandomID({ suffix: 'END' });
-* // Example output: "3csf27a4800rbli9END"
+* This is useful when you're not sure of the root structure of the JSON, or when you expect something other than an object.
 *
-* @example
-* // Generate an ID with a uppercase random string
-* const id = generateRandomID({ caseOption: "upper" });
-* // Example output: "H0VNU6O8XV1Y30HG"
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/object/parse-json-to-object parseJsonToObject} for strict object-only parsing.
+*/
+const parseJSON = (value, parsePrimitives = true) => {
+	try {
+		const parsed = JSON.parse(value);
+		return parsePrimitives ? deepParsePrimitives(parsed) : parsed;
+	} catch {
+		return {};
+	}
+};
+/**
+* * Recursively parses primitive values inside objects and arrays.
 *
-* @example
-* // Generate an ID with all options customized
-* const id = generateRandomID({
-*   prefix: 'ID',
-*   suffix: 'END',
-*   timeStamp: true,
-*   length: 10,
-*   separator: '-',
-*   caseOption: "upper"
-* });
-* // Example output: "ID-1764610471474-4KSL51IB91-END"
+* @typeParam T - Expected return type after parsing (default is unknown).
+* @param input - Any input value to parse recursively.
+* @returns Input with primitives (strings like "true", "123") converted, typed as `T`.
 */
-function generateRandomID(options) {
-	const { prefix = "", suffix = "", timeStamp = false, length = 16, separator = "", caseOption = null } = options || {};
-	const date = timeStamp ? Date.now() : "";
-	const randomString = Array.from({ length }, () => Math.random().toString(36).slice(2, 3)).join("");
-	const ID = [
-		prefix?.trim(),
-		date,
-		randomString,
-		suffix?.trim()
-	].filter(Boolean).join(separator);
-	switch (caseOption) {
-		case "upper": return ID.toUpperCase();
-		case "lower": return ID.toLowerCase();
-		default: return ID;
+function deepParsePrimitives(input) {
+	if (Array.isArray(input)) return input?.map(deepParsePrimitives);
+	if (require_specials.isObject(input)) {
+		const result = {};
+		for (const [key, value] of Object.entries(input)) result[key] = deepParsePrimitives(value);
+		return result;
+	}
+	if (require_primitives.isString(input)) {
+		if (/^(true|false)$/i.test(input)) return input?.toLowerCase() === "true";
+		if (require_specials.isNumericString(input)) return Number(input);
+		if (input === "null") return null;
+		if (input === "undefined") return;
+		return input;
 	}
+	return input;
 }
 /**
-* * Trims all whitespaces in a string or an array of strings.
+* * Defines a method on any prototype — including built-in prototypes — in a safe, idempotent manner.
+* 	 - The method is non-enumerable by default and will not overwrite an existing method unless explicitly allowed.
 *
-* @param input String or array of strings.
-* @returns Trimmed string or array of strings.
+* @param proto   The target prototype object (e.g., String.prototype).
+* @param name    The method name to define on the prototype.
+* @param impl    The function implementation for the method.
+* @param options Optional property-descriptor settings and overwrite rules.
+*
+* @example
+* // Safely augment prototype methods by extending the global interface:
+* declare global {
+* 	interface String {
+* 		toBang(): string;
+* 	}
+* }
+*
+* // Define a custom method on String.prototype
+* definePrototypeMethod(String.prototype, 'toBang', function (this: String) {
+* 	return this.toString().concat('!');
+* 	// or
+* 	// return this.concat('!');
+* });
+*
+* "Hi".toBang(); // "Hi!"
+*
+* // Attempting to redefine without overwrite option is ignored
+* definePrototypeMethod(String.prototype, 'toBang', () => 'x'); // ignored
+*
+* // Overwrite intentionally using the overwrite option
+* definePrototypeMethod(
+*   String.prototype,
+*   'toBang',
+*   function (this: String) { return this.concat('!!!'); },
+*   { overwrite: true }
+* );
+*
+* "Hi".toBang(); // "Hi!!!"
 */
-function trimString(input) {
-	if (!input) return "";
-	if (require_primitives.isNonEmptyString(input)) return input.trim().replace(/\s+/g, " ");
-	if (Array.isArray(input)) return input.map((str) => require_primitives.isNonEmptyString(str) ? str.trim().replace(/\s+/g, " ") : str);
-	throw new TypeError("Expected string or array of strings!", { cause: "Invalid Input Type" });
+function definePrototypeMethod(proto, name, impl, options) {
+	if (Object.hasOwn(proto, name) && !options?.overwrite) return;
+	Object.defineProperty(proto, name, {
+		value: function(...args) {
+			return impl.apply(this, args);
+		},
+		enumerable: options?.enumerable ?? false,
+		configurable: options?.configurable ?? false,
+		writable: options?.writable ?? true
+	});
 }
 
 //#endregion
@@ -1978,12 +2061,30 @@ Object.defineProperty(exports, 'parseJSON', {
     return parseJSON;
   }
 });
+Object.defineProperty(exports, 'randomAlphaNumeric', {
+  enumerable: true,
+  get: function () {
+    return randomAlphaNumeric;
+  }
+});
+Object.defineProperty(exports, 'randomBytes', {
+  enumerable: true,
+  get: function () {
+    return randomBytes;
+  }
+});
 Object.defineProperty(exports, 'randomHex', {
   enumerable: true,
   get: function () {
     return randomHex;
   }
 });
+Object.defineProperty(exports, 'randomNumeric', {
+  enumerable: true,
+  get: function () {
+    return randomNumeric;
+  }
+});
 Object.defineProperty(exports, 'sha1', {
   enumerable: true,
   get: function () {