toolbox-x 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2357 @@
+/**
+ * Copyright 2026 - present Nazmul Hassan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { a as isNonEmptyString, c as isNumber, d as isString, i as isInteger, m as isUndefined } from "./primitives-KsFUp3kQ.mjs";
+import { n as convertStringCase, t as capitalizeString } from "./case-BWIt8Ash.mjs";
+import { c as ORDINAL_UNDER_TEEN, d as TENS, f as THOUSANDS, l as PREFIX_MULTIPLIERS, o as ONES, s as ORDINAL_TO_CARDINAL, t as BN_DIGITS, u as TEENS } from "./constants-BwbHnXlM.mjs";
+import { t as COUNTRIES } from "./countries-Cy0xiqS3.mjs";
+import { T as isObject, b as isFunction, d as isNumericString, j as isValidArray, w as isNotEmptyObject } from "./specials-uhDuRg8H.mjs";
+import { a as normalizeNumber, i as getRandomFloat, n as formatCurrency, o as roundToNearest, r as getOrdinal, t as clampNumber } from "./utilities-m5yFKqLd.mjs";
+import { a as flattenObjectKeyValue, c as parseJsonToObject, i as flattenObjectDotNotation, l as parseObjectValues, n as extractUpdatedAndNewFields, o as mergeAndFlattenObjects, r as extractUpdatedFields, s as mergeObjects, t as extractNewFields, u as sanitizeData } from "./objectify-CDs0Fbr1.mjs";
+import { _ as naturalSort, a as deepParsePrimitives, b as _resolveNestedKey, c as getInstanceGetterNames, d as getStaticMethodNames, f as isDeepEqual, g as throttleAction, h as stripJsonEdgeGarbage, i as debounceAction, l as getInstanceMethodNames, m as stableStringify, n as countInstanceMethods, o as definePrototypeMethod, p as parseJSON, r as countStaticMethods, s as getClassDetails, t as convertArrayToString, u as getStaticGetterNames, v as sortAnArray, y as _getNumericProp } from "./utils-ClW9LA6f.mjs";
+import { n as trimString, r as truncateString, t as generateRandomID } from "./basics-Dp_aEK81.mjs";
+import { a as normalizeString, c as slugifyString, i as maskString, l as areInvalidNumbers, n as extractURLs, o as replaceAllInString, p as isOdd, r as formatUnitWithPlural, s as reverseString, t as extractEmails, u as isEven } from "./convert-Bn4jFomQ.mjs";
+
+//#region src/string/anagram.ts
+/** `WeakMap` to cache user provided dictionary array */
+const DICT_CACHE = /* @__PURE__ */ new WeakMap();
+/** Get cached dictionary `Set` */
+function _getDictSet(dict) {
+	if (DICT_CACHE.has(dict)) return DICT_CACHE.get(dict);
+	const dictSet = new Set(dict.map((w) => w.toLowerCase()));
+	DICT_CACHE.set(dict, dictSet);
+	return dictSet;
+}
+/**
+* * Generates unique anagrams of a given word. Optionally looks up valid anagrams inside a provided dictionary.
+*
+* @param word The word from which to generate anagrams. Converted to lowercase internally.
+*
+* @param options Controls the output limit and optional dictionary lookup.
+*
+* @returns A list of unique, lowercase anagrams. The original word (lowercased) is always included as the first element.
+*
+* @remarks
+* - When a dictionary is provided, only anagrams found inside that dictionary are returned.
+* - The dictionary is cached internally (with converting to lowercase) using a `WeakMap`, allowing garbage collection of unused inputs.
+* - Repeated letters are handled efficiently using a per-level set to avoid duplicate permutations.
+*
+* @example
+* generateAnagrams("east", { limit: 10 });
+*
+* @example
+* generateAnagrams("tone", {
+*   dictionary: ["tone", "note", "one"],
+*   limit: "all"
+* });
+*/
+function generateAnagrams(word, options) {
+	if (!isNonEmptyString(word)) return [];
+	if (word?.length === 1) return [word?.toLowerCase()];
+	const { limit = 100, dictionary = false } = options || {};
+	const outSet = /* @__PURE__ */ new Set();
+	const dictSet = isValidArray(dictionary) ? _getDictSet(dictionary) : void 0;
+	/** Helper function to generate permutations. */
+	const _permute = (current, remaining) => {
+		if (!remaining.length) {
+			if (!dictSet || dictSet.has(current)) outSet.add(current);
+			return;
+		}
+		const usedSet = /* @__PURE__ */ new Set();
+		for (let i = 0; i < remaining.length; i++) {
+			const char = remaining[i];
+			if (usedSet.has(char)) continue;
+			usedSet.add(char);
+			if (limit !== "all" && outSet.size >= limit) return;
+			_permute(current + char, remaining.slice(0, i) + remaining.slice(i + 1));
+		}
+	};
+	_permute("", word.toLowerCase());
+	return [...outSet];
+}
+
+//#endregion
+//#region src/string/utilities.ts
+/**
+* * Extracts all numbers from a string as array of numbers.
+* @param input - The string to extract numbers from.
+* @returns An array of numbers found in the string.
+*/
+const extractNumbersFromString = (input) => {
+	return (input.match(/\d+/g) || [])?.map(Number);
+};
+/**
+* * Computes the Levenshtein distance between two strings (space optimized).
+* @param str1 - First string to compare.
+* @param str2 - Second string to compare.
+* @returns The Levenshtein distance between the two strings.
+*
+* @remarks
+* - The Levenshtein distance is the minimum number of single-character edits (insertions, deletions, or substitutions) required to change one string into the other.
+* - This implementation uses only O(min(len(a), len(b))) space by keeping only the current and previous rows of the distance matrix.
+*
+* @example
+* const distance = getLevenshteinDistance('kitten', 'sitting');
+* console.log(distance); // Output: 3
+*/
+const getLevenshteinDistance = (str1, str2) => {
+	if (str1 === str2) return 0;
+	const lenA = str1?.length;
+	const lenB = str2?.length;
+	if (lenA < lenB) return getLevenshteinDistance(str2, str1);
+	let prev = Array.from({ length: lenB + 1 }, (_, j) => j);
+	let curr = new Array(lenB + 1);
+	for (let i = 1; i <= lenA; i++) {
+		curr[0] = i;
+		for (let j = 1; j <= lenB; j++) curr[j] = str1[i - 1] === str2[j - 1] ? prev[j - 1] : 1 + Math.min(prev[j], curr[j - 1], prev[j - 1]);
+		[prev, curr] = [curr, prev];
+	}
+	return prev[lenB];
+};
+/**
+* * Counts the number of words in a string, supporting multiple languages and scripts.
+*
+* @param text - The input string to count words from.
+* @returns Number of words (Unicode-aware).
+*/
+function countWords(text) {
+	return (text?.match(/\p{L}[\p{L}\p{M}\p{Pd}'’]*|\p{N}+/gu) || [])?.length;
+}
+
+//#endregion
+//#region src/string/helpers.ts
+/**
+* Calculates the similarity between two strings using the Levenshtein edit distance.
+*
+* @param str1 The first string to compare.
+* @param str2 The second string to compare.
+* @returns A score between `0` and `1`, where `1` means identical and `0` means completely different.
+*/
+function _calculateSimilarity(str1, str2) {
+	if (str1 === str2) return 1;
+	const maxLen = Math.max(str1.length, str2.length);
+	if (maxLen === 0) return 1;
+	return 1 - getLevenshteinDistance(str1, str2) / maxLen;
+}
+/**
+* Builds an LCS (Longest Common Subsequence) table for two strings at the character level.
+*
+* @param original The original string.
+* @param modified The modified string.
+* @returns A 2D matrix where each cell `[i][j]` holds the LCS length of `original[0..i-1]` and `modified[0..j-1]`.
+*/
+function _buildCharLcsTable(original, modified) {
+	const origLen = original.length;
+	const modLen = modified.length;
+	const lcs = Array(origLen + 1).fill(null).map(() => Array(modLen + 1).fill(0));
+	for (let i = 1; i <= origLen; i++) for (let j = 1; j <= modLen; j++) if (original[i - 1] === modified[j - 1]) lcs[i][j] = lcs[i - 1][j - 1] + 1;
+	else lcs[i][j] = Math.max(lcs[i - 1][j], lcs[i][j - 1]);
+	return lcs;
+}
+/**
+* Backtracks through an LCS table to extract matched character indices in both strings.
+*
+* @param original The original string.
+* @param modified The modified string.
+* @param lcs The precomputed LCS table from {@link buildCharLcsTable}.
+* @returns A tuple `[origMatched, modMatched]` — sets of matched character indices for the original and modified strings respectively.
+*/
+function _getLcsIndices(original, modified, lcs) {
+	const origLen = original.length;
+	const modLen = modified.length;
+	const origMatched = /* @__PURE__ */ new Set();
+	const modMatched = /* @__PURE__ */ new Set();
+	let i = origLen;
+	let j = modLen;
+	while (i > 0 && j > 0) if (original[i - 1] === modified[j - 1]) {
+		origMatched.add(i - 1);
+		modMatched.add(j - 1);
+		i--;
+		j--;
+	} else if (lcs[i - 1][j] > lcs[i][j - 1]) i--;
+	else j--;
+	return [origMatched, modMatched];
+}
+
+//#endregion
+//#region src/string/diff.ts
+/**
+* * Computes a line-based text diff between two strings using the Longest Common Subsequence (LCS) algorithm.
+*
+* @remarks
+* - Lines are classified as `added`, `removed`, `modified`, or `unchanged`.
+* - Detects and pairs similar `removed` and `added` lines as `modified` when their similarity exceeds the threshold.
+*
+* @param originalText The original (before) text.
+* @param modifiedText The modified (after) text.
+* @returns A {@link DiffResult} with the list of diff lines and summary statistics.
+*
+* @example
+* const result = computeTextDiff('hello\nworld', 'hello\nearth');
+* // result.stats → { linesAdded: 1, linesRemoved: 1, linesChanged: 0, linesUnchanged: 1 }
+*
+* @example
+* const result = computeTextDiff('foo\nbar', 'foo\nbaz\nqux');
+* result.stats.linesAdded;   // 1
+* result.stats.linesChanged; // 1
+*/
+function computeTextDiff(originalText, modifiedText) {
+	const originalLines = originalText.split("\n");
+	const modifiedLines = modifiedText.split("\n");
+	const originalLen = originalLines.length;
+	const modifiedLen = modifiedLines.length;
+	const lcs = Array(originalLen + 1).fill(null).map(() => Array(modifiedLen + 1).fill(0));
+	for (let i = 1; i <= originalLen; i++) for (let j = 1; j <= modifiedLen; j++) if (originalLines[i - 1] === modifiedLines[j - 1]) lcs[i][j] = lcs[i - 1][j - 1] + 1;
+	else lcs[i][j] = Math.max(lcs[i - 1][j], lcs[i][j - 1]);
+	const diffLines = [];
+	let i = originalLen;
+	let j = modifiedLen;
+	while (i > 0 || j > 0) if (i > 0 && j > 0 && originalLines[i - 1] === modifiedLines[j - 1]) {
+		diffLines.unshift({
+			type: "unchanged",
+			original: originalLines[i - 1],
+			modified: modifiedLines[j - 1],
+			originalLineNum: i,
+			modifiedLineNum: j
+		});
+		i--;
+		j--;
+	} else if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
+		diffLines.unshift({
+			type: "added",
+			modified: modifiedLines[j - 1],
+			modifiedLineNum: j
+		});
+		j--;
+	} else if (i > 0) {
+		diffLines.unshift({
+			type: "removed",
+			original: originalLines[i - 1],
+			originalLineNum: i
+		});
+		i--;
+	}
+	const processedLines = [];
+	const usedIndices = /* @__PURE__ */ new Set();
+	const SIMILARITY_THRESHOLD = .6;
+	for (let idx = 0; idx < diffLines.length; idx++) {
+		if (usedIndices.has(idx)) continue;
+		const line = diffLines[idx];
+		if (line.type === "removed") {
+			for (let jdx = idx + 1; jdx < diffLines.length; jdx++) {
+				if (usedIndices.has(jdx)) continue;
+				const nextLine = diffLines[jdx];
+				if (nextLine.type === "added") {
+					if (_calculateSimilarity(line.original || "", nextLine.modified || "") >= SIMILARITY_THRESHOLD) {
+						processedLines.push({
+							type: "modified",
+							original: line.original,
+							modified: nextLine.modified,
+							originalLineNum: line.originalLineNum,
+							modifiedLineNum: nextLine.modifiedLineNum
+						});
+						usedIndices.add(idx);
+						usedIndices.add(jdx);
+						break;
+					}
+				}
+			}
+			if (!usedIndices.has(idx)) {
+				processedLines.push(line);
+				usedIndices.add(idx);
+			}
+		} else if (line.type !== "added" || !usedIndices.has(idx)) {
+			if (line.type !== "added" || !usedIndices.has(idx)) {
+				processedLines.push(line);
+				usedIndices.add(idx);
+			}
+		}
+	}
+	let linesAdded = 0;
+	let linesRemoved = 0;
+	let linesChanged = 0;
+	let linesUnchanged = 0;
+	for (const line of processedLines) if (line.type === "added") linesAdded++;
+	else if (line.type === "removed") linesRemoved++;
+	else if (line.type === "modified") linesChanged++;
+	else if (line.type === "unchanged") linesUnchanged++;
+	return {
+		lines: processedLines,
+		stats: {
+			linesAdded,
+			linesRemoved,
+			linesChanged,
+			linesUnchanged
+		}
+	};
+}
+/**
+* * Highlights character-level differences between two strings using the LCS algorithm.
+*
+* @remarks
+* - The function returns two arrays of characters for the original and modified strings.
+* - Each character in both strings is annotated with a `highlighted` flag indicating whether it differs from the other string.
+*
+* @param original The original string to compare from.
+* @param modified The modified string to compare to.
+* @returns A {@link CharDiffResult} with annotated character arrays for both strings.
+*
+* @example
+* const diff = getCharacterDifferences('cat', 'car');
+* diff.original; // [{ text: 'c', highlighted: false }, { text: 'a', highlighted: false }, { text: 't', highlighted: true }]
+* diff.modified; // [{ text: 'c', highlighted: false }, { text: 'a', highlighted: false }, { text: 'r', highlighted: true }]
+*
+* @example
+* // When one string is empty, all characters in the other are highlighted
+* getCharacterDifferences('', 'hi');
+* // { original: [], modified: [{ text: 'h', highlighted: true }, { text: 'i', highlighted: true }] }
+*
+* @example
+* const diff = getCharacterDifferences('hello world', 'hello earth');
+* // Characters unique to each string will have highlighted: true
+*/
+function getCharacterDifferences(original, modified) {
+	const result = {
+		original: [],
+		modified: []
+	};
+	if (!original && !modified) return result;
+	if (!original) return {
+		original: [],
+		modified: modified.split("").map((text) => ({
+			text,
+			highlighted: true
+		}))
+	};
+	if (!modified) return {
+		original: original.split("").map((text) => ({
+			text,
+			highlighted: true
+		})),
+		modified: []
+	};
+	const [origMatched, modMatched] = _getLcsIndices(original, modified, _buildCharLcsTable(original, modified));
+	for (let i = 0; i < original.length; i++) result.original.push({
+		text: original[i],
+		highlighted: !origMatched.has(i)
+	});
+	for (let j = 0; j < modified.length; j++) result.modified.push({
+		text: modified[j],
+		highlighted: !modMatched.has(j)
+	});
+	return result;
+}
+
+//#endregion
+//#region src/number/helpers.ts
+/**
+* Apply multiples of a number if there is any.
+* @param array Array of numbers to apply the condition on.
+* @param multiples The multiples of which number.
+* @returns Array of multiples of the desired number
+*/
+const _applyMultiples = (array, multiples) => {
+	if (!multiples) return array;
+	return array?.filter((n) => n % multiples === 0);
+};
+/**
+* - Converts a number less than 1000 to words.
+* @param num - The number to convert (less than 1000).
+* @param isLast - Whether this is the last group (thousands, millions, etc.).
+* @returns Numbers less than 1000 in words.
+*/
+function _convertLessThanThousand(num, isLast) {
+	if (num < 10) return ONES[num];
+	if (num < 20) return TEENS[num - 10];
+	let result = TENS[Math.floor(num / 10)];
+	const remainder = num % 10;
+	if (remainder > 0) result += `-${ONES[remainder]}`;
+	if (num >= 100) {
+		const hundredsPart = `${ONES[Math.floor(num / 100)]} hundred`;
+		return num % 100 === 0 ? hundredsPart : `${hundredsPart} ${isLast ? "and" : ""} ${_convertLessThanThousand(num % 100, false)}`;
+	}
+	return result;
+}
+/**
+* * Calculate the HCF (Highest Common Factor) of two numbers using the Euclidean algorithm.
+*
+* @param a - First number.
+* @param b - Second number.
+* @returns The HCF of the two numbers.
+*/
+const _find2NumbersHCF = (a, b) => {
+	let x = Math.abs(a);
+	let y = Math.abs(b);
+	while (y !== 0) {
+		const temp = y;
+		y = x % y;
+		x = temp;
+	}
+	return x;
+};
+/**
+* * Calculate the LCM (Least Common Multiple) of two numbers using the Euclidean algorithm.
+*
+* @param a - First number.
+* @param b - Second number.
+* @returns The LCM of the two numbers.
+*/
+const _find2NumbersLCM = (a, b) => {
+	const x = Math.abs(a);
+	const y = Math.abs(b);
+	return x * y / _find2NumbersHCF(x, y);
+};
+
+//#endregion
+//#region src/number/basics.ts
+/**
+* * Utility to generate a random number between a given range.
+* * If no options are provided, it will generate a random number between `0` and `100` (inclusive).
+* * If `min` is greater than `max`, it will swap the values and generate a random number.
+*
+* @param options - Options for configuring random number generator.
+* @returns Random number.
+*/
+const getRandomNumber = (options) => {
+	const { min = 0, max = 100, includeMin = true, includeMax = true } = options || {};
+	let minimum = min, maximum = max;
+	if (min > max) {
+		[minimum, maximum] = [max, min];
+		return getRandomNumber({
+			min: minimum,
+			max: maximum,
+			includeMin,
+			includeMax
+		});
+	}
+	if (min === max) return min;
+	if (includeMin && includeMax) return Math.floor(Math.random() * (max - min + 1)) + min;
+	if (!includeMin && !includeMax) return Math.floor(Math.random() * (max - min - 1)) + min + 1;
+	if (includeMin && !includeMax) return Math.floor(Math.random() * (max - min)) + min;
+	if (!includeMin && includeMax) return Math.floor(Math.random() * (max - min)) + min + 1;
+	return 0;
+};
+/**
+* * Utility to round a number to given decimal places.
+*
+* @param input - Number or `stringified` number to round.
+* @param options - Options for rounding behavior, including decimal places and return type.
+* @returns Converted number as `number` (default) or `string` (if `isString` is `true`).
+*/
+const convertToDecimal = (input, options) => {
+	const { decimalPlaces = 2, isString = false } = options || {};
+	const parsed = normalizeNumber(input);
+	if (isUndefined(parsed)) throw new TypeError(`Invalid numeric input!`, { cause: `${input} cannot be converted to a number.` });
+	return isString ? parsed.toFixed(decimalPlaces) : Number(parsed.toFixed(decimalPlaces));
+};
+/**
+* * Calculates the HCF/GCD of multiple numbers.
+*
+* @param numbers - List of numbers to find the HCF/GCD for.
+* @returns The HCF/GCD of all the provided numbers.
+*/
+const calculateHCF = (...numbers) => {
+	const converted = numbers?.map(Number);
+	if (converted?.length === 0) return 0;
+	let hcf = converted[0];
+	for (let i = 1; i < converted?.length; i++) hcf = _find2NumbersHCF(hcf, converted[i]);
+	return hcf;
+};
+/**
+* * Calculates the LCM/LCD of multiple numbers.
+*
+* @param numbers - List of numbers to find the LCM/LCD for.
+* @returns The LCM/LCD of all the provided numbers.
+*/
+const calculateLCM = (...numbers) => {
+	const converted = numbers?.map(Number);
+	if (converted?.length === 0) return 0;
+	let lcm = converted[0];
+	for (let i = 1; i < converted?.length; i++) lcm = _find2NumbersLCM(lcm, converted[i]);
+	return lcm;
+};
+/**
+* * Computes the factorial of a non-negative numeric value (integer).
+*
+* @param int - A numeric input value (integer) whose factorial should be calculated.
+*
+* @returns The factorial result as a number if valid, otherwise `undefined`.
+*
+* @example
+* factorial(5); // → 120
+* factorial(0); // → 1
+* factorial(-3); // → undefined
+* factorial(undefined); // → undefined
+* factorial(5.5); // → undefined
+*
+* @remarks
+* - Factorial of `0` and `1` is `1`.
+* - Uses recursive approach internally.
+* - Input is normalized via `normalizeNumber` before computation.
+* - May return large values quickly due to factorial growth rate.
+* - Returns `undefined` if the input is negative, not numeric, non-integer, or `undefined`.
+*/
+function factorial(int) {
+	const num = normalizeNumber(int);
+	if (!isNumber(num) || num < 0 || !Number.isInteger(num)) return;
+	else if (num === 0 || num === 1) return 1;
+	else return num * (factorial(num - 1) ?? 1);
+}
+/**
+* * Efficiently computes all positive integer factors (divisors) of a number.
+*
+* @param int - Numeric value to find factors for. Non-integer or negative values return an empty array.
+*
+* @returns An array of positive factors in ascending order.
+*
+* @example
+* getFactors(12); // → [1, 2, 3, 4, 6, 12]
+* getFactors(7);  // → [1, 7]
+* getFactors(-4); // → []
+* getFactors(undefined); // → []
+*
+* @remarks
+* - Uses the square root method for better performance (`O(√n)`).
+* - Returns an empty array for invalid, negative, or non-integer input.
+*/
+function getFactors(int) {
+	const num = normalizeNumber(int);
+	if (!isNumber(num) || num <= 0 || !Number.isInteger(num)) return [];
+	if (num === 1) return [1];
+	const factors = new Set([1, num]);
+	const sqrt = Math.floor(Math.sqrt(num));
+	for (let i = 2; i <= sqrt; i++) if (num % i === 0) {
+		factors.add(i);
+		factors.add(num / i);
+	}
+	return [...factors].sort((a, b) => a - b);
+}
+/**
+* * Sums up all digits of a number.
+*
+* @param num The input number.
+* @returns The sum of its digits.
+*/
+function sumDigits(num) {
+	return Math.abs(Number(num)).toString().split("").reduce((sum, digit) => sum + Number(digit), 0);
+}
+/**
+* * Sums up numbers.
+*
+* @param numbers The input numbers.
+* @returns The sum of the numbers.
+*/
+function sumNumbers(...numbers) {
+	return numbers?.map((num) => Number(num))?.reduce((sum, number) => sum + number, 0);
+}
+/**
+* * Reverses a number (e.g., `123` → `321`).
+*
+* @param num The number to reverse.
+* @returns The reversed number.
+*/
+function reverseNumber(num) {
+	const reversed = parseInt(Math.abs(Number(num)).toString().split("").reverse().join(""), 10);
+	return Number(num) < 0 ? -reversed : reversed;
+}
+/**
+* * Calculates the average of a set of numbers.
+*
+* @param numbers - A list of numbers for which to calculate the average.
+* @returns The average of the provided numbers. Returns `NaN` if no numbers are valid.
+*/
+function getAverage(...numbers) {
+	let sum = 0;
+	let count = 0;
+	for (const n of numbers) {
+		const num = Number(n);
+		if (isNumber(num)) {
+			sum += num;
+			count++;
+		}
+	}
+	return count === 0 ? NaN : Math.round(sum / count * 1e3) / 1e3;
+}
+/**
+* * Rounds a number to a specified number of decimal places.
+*
+* @param number - The number to round.
+* @param roundTo - The number of decimal places to round to (default is `2`).
+* - If `roundTo` is negative, the number is rounded to the left of the decimal point (e.g., `-1` rounds to the nearest 10, `-2` to nearest 100 etc.).
+* @returns The rounded number, either in float or integer (if a whole number).
+*
+* @example
+* roundNumber(1234.56, -2); // 1200
+* roundNumber(1234.56, 1);  // 1234.6
+*/
+function roundNumber(number, roundTo = 2) {
+	const factor = Math.pow(10, roundTo);
+	const num = isNumber(number) ? number : Number(number);
+	return Math.round(num * factor) / factor;
+}
+
+//#endregion
+//#region src/number/Currency.ts
+/**
+* * A utility class for handling currency operations like formatting and conversion.
+*
+* - Supports formatting based on locale and currency code.
+* - Converts between **fiat currencies supported by `api.frankfurter.app`**.
+* - Automatically caches conversion rates to reduce redundant API calls.
+* - Intended for use with numeric inputs (number or numeric string).
+*/
+var Currency = class Currency {
+	#amount;
+	#code;
+	/**
+	* * The formatted currency string (e.g., `$1,000.00`).
+	*
+	* - Generated using the `en-US` locale during construction.
+	* - This is a display-friendly version of the currency value.
+	* - For formatting with other locales, use the `format()` method.
+	*/
+	currency;
+	/**
+	* Creates an instance of the Currency class.
+	*
+	* @param amount - The numeric amount of currency (e.g., `100`, `'99.99'`).
+	* @param code - The ISO 4217 currency code representing the currency (e.g., `'USD'`, `'EUR'`).
+	*/
+	constructor(amount, code) {
+		this.#amount = Number(amount);
+		this.#code = code;
+		this.currency = this.format("en-US");
+	}
+	static #RATE_CACHE = /* @__PURE__ */ new Map();
+	/** * Clears cached rates that were fetched previously. */
+	static clearRateCache() {
+		Currency.#RATE_CACHE.clear();
+	}
+	/**
+	* @instance Formats the stored amount as a localized currency string.
+	*
+	* @param locale - Optional. A BCP 47 locale string (e.g., `'de-DE'`, `'en-US'`). Defaults to `'en-US'` if not provided.
+	* @param code - Optional. An ISO 4217 currency code (e.g., `'USD'`, `'EUR'`) used solely for formatting purposes.
+	*            _This does not alter the internal currency code set during instantiation._
+	* @returns A string representing the formatted currency value according to the specified locale and currency code.
+	*/
+	format(locale, code) {
+		return formatCurrency(this.#amount, code ?? this.#code, locale);
+	}
+	/**
+	* @instance Converts the current currency amount to a target currency using real-time exchange rates.
+	*
+	* - Uses {@link https://api.frankfurter.app/latest api.frankfurter.app} to fetch live exchange rates.
+	* - Supports **only the following fiat currencies**:
+	*   `AUD`, `BGN`, `BRL`, `CAD`, `CHF`, `CNY`, `CZK`, `DKK`, `EUR`, `GBP`, `HKD`, `HUF`, `IDR`, `ILS`, `INR`, `ISK`, `JPY`,
+	*   `KRW`, `MXN`, `MYR`, `NOK`, `NZD`, `PHP`, `PLN`, `RON`, `SEK`, `SGD`, `THB`, `TRY`, `USD`, `ZAR`.
+	* - Uses cached rates unless `forceRefresh` is set to `true`.
+	* - If API fails or currency not supported, falls back to `fallbackRate` if provided.
+	* - Use {@link convertSync} method to convert to other currencies using custom exchange rate.
+	*
+	* @param to - The target currency code (must be one of the supported ones, e.g., `'EUR'`, `'USD'`).
+	* @param options - Optional settings:
+	*   - `fallbackRate`: A manual exchange rate to use if the API call fails or currency is not supported.
+	*   - `forceRefresh`: If true, ignores cached rates and fetches fresh data.
+	* @returns A new `Currency` instance with the converted amount in the target currency.
+	* @throws Will throw error if the API call fails and no `fallbackRate` is provided.
+	*
+	* @example
+	* await new Currency(100, 'USD').convert('EUR');
+	*/
+	async convert(to, options) {
+		const key = `${this.#code}->${to}`;
+		if (!options?.forceRefresh && Currency.#RATE_CACHE.has(key)) {
+			const cachedRate = Currency.#RATE_CACHE.get(key);
+			return new Currency(this.#amount * cachedRate, to);
+		}
+		try {
+			const rate = await this.#fetchFromFrankfurter(to);
+			Currency.#RATE_CACHE.set(key, rate);
+			return new Currency(this.#amount * rate, to);
+		} catch (error) {
+			if (options?.fallbackRate != null) {
+				console.warn(`Currency conversion failed (${this.#code} → ${to}): ${error?.message}. Using fallback rate...`);
+				return new Currency(this.#amount * options.fallbackRate, to);
+			} else throw new Error(`Currency conversion failed (${this.#code} → ${to}): ${error?.message}`);
+		}
+	}
+	/**
+	* @instance Converts the current currency amount to a target currency using either a cached rate or a manual exchange rate.
+	*
+	* - This method is **synchronous** and does **not perform any network requests**.
+	* - If a cached rate exists for the currency pair, it is used.
+	* - If no cached rate is found, `rate` is used as a manual exchange rate.
+	* - If neither are available, the original instance is returned unchanged.
+	*
+	* @param to - The target currency code to convert to.
+	* @param rate - A manual exchange rate to use if no cached rate is available.
+	* @returns A new `Currency` instance with the converted amount, or the original instance if no rate is available.
+	*
+	* @example
+	* const usd = new Currency(100, 'USD');
+	* const eur = usd.convertSync('EUR', 0.92);
+	*
+	* console.log(eur.currency); // €92.00
+	*/
+	convertSync(to, rate) {
+		const key = `${this.#code}->${to}`;
+		const cachedRate = Currency.#RATE_CACHE.get(key);
+		if (cachedRate) return new Currency(this.#amount * cachedRate, to);
+		else if (rate) return new Currency(this.#amount * rate, to);
+		else return this;
+	}
+	/**
+	* @private Attempts to fetch rate from frankfurter.app
+	* @param to - Target currency code
+	* @returns Exchange rate (multiplier)
+	*/
+	async #fetchFromFrankfurter(to) {
+		const url = `https://api.frankfurter.app/latest?amount=1&from=${this.#code}`;
+		try {
+			const res = await fetch(url, { redirect: "error" });
+			if (!res.ok) throw new Error(`FrankFurter Error: ${res.status}. "${res.statusText}"`);
+			const data = await res.json();
+			if (!data.rates?.[to]) throw new Error(`Currency "${to}" is not found in FrankFurter Database!`);
+			return data.rates[to];
+		} catch (error) {
+			throw new Error(error?.message || `Failed to fetch data from FrankFurter API`);
+		}
+	}
+};
+
+//#endregion
+//#region src/number/Unit.ts
+/**
+* @class Class to handle conversions between various types of units.
+*
+* Includes static methods for:
+* - Length: meters, feet, kilometers, miles
+* - Mass: kilograms, pounds, grams, ounces
+* - Temperature: Celsius, Fahrenheit, Kelvin
+* - Volume: liters, gallons
+* - Area: square meters, square feet
+* - Speed: km/h, mph
+* - Time: hours, minutes, seconds, days
+* - Digital Storage: kilobytes, megabytes, gigabytes
+* - Energy: joules, calories
+* - Pressure: atm, pascals
+* - Frequency: Hz, kHz
+*
+* @remarks For more robust unit conversion, please use the `Converter` function which provides category-specific conversion classes.
+*/
+var Unit = class Unit {
+	#value;
+	#unit;
+	/**
+	* * Creates an instance of the Unit class.
+	* @param value The numeric value to work with.
+	* @param unit The unit type of the value (e.g., 'kg', 'm', 'kb').
+	*/
+	constructor(value, unit) {
+		this.#value = value;
+		this.#unit = unit;
+	}
+	/**
+	* @instance Returns the original value with unit (if passed in the constructor).
+	* @returns A string in the format "value unit".
+	*/
+	toString() {
+		return ` ${this.#value} ${this.#unit ?? ""}`.trim();
+	}
+	/**
+	* @instance Converts using scientific prefixes (e.g., kB to MB, mg to g).
+	*
+	* @param fromPrefix The SI prefix of the source unit.
+	* @param toPrefix The SI prefix of the target unit.
+	* @returns The converted numeric value.
+	*/
+	convertByPrefix(fromPrefix, toPrefix) {
+		return Unit.convertByPrefix(this.#value, fromPrefix, toPrefix);
+	}
+	/**
+	* @instance Converts from prefixed unit string to another (e.g., kB to MB, mg to g).
+	*
+	* @param from Prefixed unit string (e.g., 'kB', 'mg').
+	* @param to Target prefixed unit string (e.g., 'MB', 'g').
+	* @returns The converted numeric value.
+	*/
+	convertFromTo(from, to) {
+		return Unit.convertFromTo(this.#value, from, to);
+	}
+	/**
+	* @instance Converts the value using a static method name from the `Unit` class.
+	*
+	* - **N.B.** *Provides IntelliSense and type safety for method selection.*
+	*
+	* @param methodName - A static `Unit` method that accepts a number and returns a number.
+	* @returns The converted numeric value.
+	*/
+	convert(methodName) {
+		const method = Unit[methodName];
+		if (typeof method !== "function") throw new Error(`Method ${methodName} is not a valid method!`);
+		return method(this.#value);
+	}
+	/**
+	* @static Converts a value using scientific prefixes (e.g., kB to MB, mg to g).
+	*
+	* @param value The value to convert.
+	* @param fromPrefix The SI prefix of the source unit.
+	* @param toPrefix The SI prefix of the target unit.
+	* @returns The converted numeric value.
+	*/
+	static convertByPrefix(value, fromPrefix, toPrefix) {
+		const fromMultiplier = PREFIX_MULTIPLIERS[fromPrefix];
+		const toMultiplier = PREFIX_MULTIPLIERS[toPrefix];
+		return value * fromMultiplier / toMultiplier;
+	}
+	/**
+	* @static Converts from prefixed unit string to another (e.g., kB to MB, mg to g).
+	*
+	* @param value The numeric value.
+	* @param from Prefixed unit string (e.g., 'kB', 'mg').
+	* @param to Target prefixed unit string (e.g., 'MB', 'g').
+	* @returns The converted numeric value.
+	*/
+	static convertFromTo(value, from, to) {
+		const extractPrefix = (str) => {
+			const match = str.match(/^(da|[yzafpnμumcdhkMGTPEZY]?)(.+)$/);
+			if (!match) throw new Error(`Invalid unit format: ${str}`);
+			return [match[1], match[2]];
+		};
+		const [fromPrefix, fromUnit] = extractPrefix(from);
+		const [toPrefix, toUnit] = extractPrefix(to);
+		if (fromUnit !== toUnit) throw new Error(`Mismatched units: ${fromUnit} vs ${toUnit}`);
+		return Unit.convertByPrefix(value, fromPrefix, toPrefix);
+	}
+	/** Converts meters to feet. */
+	static metersToFeet(m) {
+		return m * 3.28084;
+	}
+	/** Converts feet to meters. */
+	static feetToMeters(ft) {
+		return ft / 3.28084;
+	}
+	/** Converts kilometers to miles. */
+	static kmToMiles(km) {
+		return km * .621371;
+	}
+	/** Converts miles to kilometers. */
+	static milesToKm(mi) {
+		return mi / .621371;
+	}
+	/** Converts kilograms to pounds. */
+	static kgToLbs(kg) {
+		return kg * 2.20462;
+	}
+	/** Converts pounds to kilograms. */
+	static lbsToKg(lbs) {
+		return lbs / 2.20462;
+	}
+	/** Converts grams to ounces. */
+	static gramsToOunces(g) {
+		return g * .035274;
+	}
+	/** Converts ounces to grams. */
+	static ouncesToGrams(oz) {
+		return oz / .035274;
+	}
+	/** Converts Celsius to Fahrenheit. */
+	static celsiusToFahrenheit(c) {
+		return c * 9 / 5 + 32;
+	}
+	/** Converts Fahrenheit to Celsius. */
+	static fahrenheitToCelsius(f) {
+		return (f - 32) * 5 / 9;
+	}
+	/** Converts Celsius to Kelvin. */
+	static celsiusToKelvin(c) {
+		return c + 273.15;
+	}
+	/** Converts Kelvin to Celsius. */
+	static kelvinToCelsius(k) {
+		return k - 273.15;
+	}
+	/** Converts Fahrenheit to Kelvin. */
+	static fahrenheitToKelvin(f) {
+		return (f - 32) * 5 / 9 + 273.15;
+	}
+	/** Converts Kelvin to Fahrenheit. */
+	static kelvinToFahrenheit(k) {
+		return (k - 273.15) * 9 / 5 + 32;
+	}
+	/** Converts milliliters to liters. */
+	static mlToLiters(ml) {
+		return ml / 1e3;
+	}
+	/** Converts liters to milliliters. */
+	static litersToMl(l) {
+		return l * 1e3;
+	}
+	/** Converts gallons to milliliters. */
+	static gallonsToMl(gal) {
+		return gal * 3785.41;
+	}
+	/** Converts milliliters to gallons. */
+	static mlToGallons(ml) {
+		return ml / 3785.41;
+	}
+	/** Converts liters to gallons. */
+	static litersToGallons(l) {
+		return l * .264172;
+	}
+	/** Converts gallons to liters. */
+	static gallonsToLiters(gal) {
+		return gal / .264172;
+	}
+	/** Converts square meters to square feet. */
+	static sqmToSqft(sqm) {
+		return sqm * 10.7639;
+	}
+	/** Converts square feet to square meters. */
+	static sqftToSqm(sqft) {
+		return sqft / 10.7639;
+	}
+	/** Converts kilometers per hour to miles per hour. */
+	static kmphToMph(kmph) {
+		return kmph * .621371;
+	}
+	/** Converts miles per hour to kilometers per hour. */
+	static mphToKmph(mph) {
+		return mph / .621371;
+	}
+	/** Converts minutes to hours. */
+	static minutesToHours(min) {
+		return min / 60;
+	}
+	/** Converts seconds to minutes. */
+	static secondsToMinutes(sec) {
+		return sec / 60;
+	}
+	/** Converts hours to days. */
+	static hoursToDays(hr) {
+		return hr / 24;
+	}
+	/** Converts hours to minutes. */
+	static hoursToMinutes(h) {
+		return h * 60;
+	}
+	/** Converts minutes to seconds. */
+	static minutesToSeconds(m) {
+		return m * 60;
+	}
+	/** Converts days to hours. */
+	static daysToHours(d) {
+		return d * 24;
+	}
+	/** Converts megabytes to gigabytes. */
+	static mbToGb(mb) {
+		return mb / 1024;
+	}
+	/** Converts gigabytes to megabytes. */
+	static gbToMb(gb) {
+		return gb * 1024;
+	}
+	/** Converts kilobytes to megabytes. */
+	static kbToMb(kb) {
+		return kb / 1024;
+	}
+	/** Converts kilobytes to gigabytes. */
+	static kbToGb(kb) {
+		return kb / (1024 * 1024);
+	}
+	/** Converts gigabytes to kilobytes. */
+	static gbToKb(gb) {
+		return gb * 1024 * 1024;
+	}
+	/** Converts bytes to kilobytes. */
+	static bytesToKb(bytes) {
+		return bytes / 1024;
+	}
+	/** Converts kilobytes to bytes. */
+	static kbToBytes(kb) {
+		return kb * 1024;
+	}
+	/** Converts megabytes to kilobytes. */
+	static mbToKb(mb) {
+		return mb * 1024;
+	}
+	/** Converts gigabytes to terabytes. */
+	static gbToTb(gb) {
+		return gb / 1024;
+	}
+	/** Converts terabytes to gigabytes. */
+	static tbToGb(tb) {
+		return tb * 1024;
+	}
+	/** Converts joules to calories. */
+	static joulesToCalories(j) {
+		return j * .239006;
+	}
+	/** Converts calories to joules. */
+	static caloriesToJoules(cal) {
+		return cal / .239006;
+	}
+	/** Converts calories to kilojoules. */
+	static caloriesToKJoules(cal) {
+		return cal / .239006 / 1e3;
+	}
+	/** Converts kilojoules to calories. */
+	static kJoulesToCalories(kj) {
+		return kj * 1e3 * .239006;
+	}
+	/** Converts atmospheres to pascals. */
+	static atmToPascal(atm) {
+		return atm * 101325;
+	}
+	/** Converts pascals to atmospheres. */
+	static pascalToAtm(pa) {
+		return pa / 101325;
+	}
+	/** Converts bar to pascals. */
+	static barToPascal(bar) {
+		return bar * 1e5;
+	}
+	/** Converts pascals to bar. */
+	static pascalToBar(pa) {
+		return pa / 1e5;
+	}
+	/** Converts hertz to kilohertz. */
+	static hzToKHz(hz) {
+		return hz / 1e3;
+	}
+	/** Converts kilohertz to hertz. */
+	static kHzToHz(khz) {
+		return khz * 1e3;
+	}
+	/** Converts hertz to megahertz. */
+	static hzToMHz(hz) {
+		return hz / 1e6;
+	}
+	/** Converts megahertz to hertz. */
+	static mHzToHz(mhz) {
+		return mhz * 1e6;
+	}
+	/** Converts kilohertz to megahertz. */
+	static kHzToMHz(khz) {
+		return khz / 1e3;
+	}
+	/** Converts megahertz to kilohertz. */
+	static mHzToKHz(mhz) {
+		return mhz * 1e3;
+	}
+	/** Converts centimeters to meters. */
+	static cmToMeters(cm) {
+		return cm / 100;
+	}
+	/** Converts meters to centimeters. */
+	static metersToCm(m) {
+		return m * 100;
+	}
+	/** Converts millimeters to meters. */
+	static mmToMeters(mm) {
+		return mm / 1e3;
+	}
+	/** Converts meters to millimeters. */
+	static metersToMm(m) {
+		return m * 1e3;
+	}
+	/** Converts square kilometers to square meters. */
+	static sqkmToSqm(sqkm) {
+		return sqkm * 1e6;
+	}
+	/** Converts square meters to square kilometers. */
+	static sqmToSqkm(sqm) {
+		return sqm / 1e6;
+	}
+	/** Converts square feet to square inches. */
+	static sqftToSqin(sqft) {
+		return sqft * 144;
+	}
+	/** Converts square inches to square feet. */
+	static sqinToSqft(sqin) {
+		return sqin / 144;
+	}
+	/** Converts watts to kilowatts. */
+	static wattsToKw(w) {
+		return w / 1e3;
+	}
+	/** Converts kilowatts to watts. */
+	static kwToWatts(kw) {
+		return kw * 1e3;
+	}
+};
+
+//#endregion
+//#region src/number/percent.ts
+/**
+* * Performs a percentage-related calculation based on the given mode and inputs.
+*
+* - `get-percent`: Calculates what percentage the `part` is of the `total`.
+* - `get-value`: Calculates the value from a given `percentage` of a `total`.
+* - `get-original`: Calculates the original value from a known `value` and `percentage`.
+* - `get-change-percent`: Percent increase/decrease from `oldValue` to `newValue`.
+* - `apply-percent-change`: Applies increase/decrease by `percentage` to `baseValue`.
+* - `get-percent-difference`: Absolute percent difference between two values.
+* - `inverse-percent`: What percent `total` is of `part`.
+*
+* @param options - The calculation mode and inputs required for the operation.
+* @returns The calculated number rounded to three decimal places, or `NaN` if input is invalid.
+*/
+function calculatePercentage(options) {
+	const { roundTo = 3 } = options;
+	/**
+	* - Rounds a number to the specified number of decimal places.
+	*
+	* @param num - The number to round.
+	* @returns The rounded number.
+	*/
+	const _roundNumber = (num) => {
+		const factor = Math.pow(10, roundTo);
+		return Math.round(num * factor) / factor;
+	};
+	switch (options?.mode) {
+		case "get-percent": {
+			const { part, total } = options;
+			if (areInvalidNumbers(part, total) || total === 0) return NaN;
+			return _roundNumber(part / total * 100);
+		}
+		case "get-value": {
+			const { percentage, total } = options;
+			if (areInvalidNumbers(percentage, total) || total === 0) return NaN;
+			return _roundNumber(percentage / 100 * total);
+		}
+		case "get-original": {
+			const { percentage, value } = options;
+			if (areInvalidNumbers(percentage, value) || percentage === 0) return NaN;
+			return _roundNumber(value / percentage * 100);
+		}
+		case "get-change-percent": {
+			const { oldValue, newValue } = options;
+			if (areInvalidNumbers(oldValue, newValue) || oldValue === 0) return NaN;
+			return _roundNumber((newValue - oldValue) / oldValue * 100);
+		}
+		case "apply-percent-change": {
+			const { baseValue, percentage } = options;
+			if (areInvalidNumbers(baseValue, percentage)) return NaN;
+			return _roundNumber(baseValue * (1 + percentage / 100));
+		}
+		case "get-percent-difference": {
+			const { value1, value2 } = options;
+			if (areInvalidNumbers(value1, value2)) return NaN;
+			const avg = getAverage(value1, value2);
+			if (avg === 0) return NaN;
+			return _roundNumber(Math.abs(value1 - value2) / avg * 100);
+		}
+		case "inverse-percent": {
+			const { part, total } = options;
+			if (areInvalidNumbers(part, total) || part === 0) return NaN;
+			return _roundNumber(total / part * 100);
+		}
+		default: return NaN;
+	}
+}
+
+//#endregion
+//#region src/number/fibonacci.ts
+/**
+* * Generates the first `limit` Fibonacci numbers.
+*
+* @param limit The number of Fibonacci numbers to generate.
+* @returns An array containing the first `limit` Fibonacci numbers.
+*/
+function getFibonacciSeries(limit) {
+	const cLimit = Number(limit);
+	if (!Number.isFinite(cLimit) || cLimit <= 0) return [];
+	if (cLimit === 1) return [0];
+	const series = [0, 1];
+	for (let i = 2; i < cLimit; i++) series.push(series[i - 1] + series[i - 2]);
+	return series;
+}
+/**
+* * Generates the first `limit` Fibonacci numbers using recursion with memoization.
+*
+* @param limit - The number of Fibonacci numbers to generate.
+* @returns An array containing the first `limit` Fibonacci numbers.
+*/
+function getFibonacciSeriesMemo(limit) {
+	const cLimit = Number(limit);
+	if (!Number.isFinite(cLimit) || cLimit <= 0) return [];
+	if (cLimit === 1) return [0];
+	const memo = new Map([[0, 0], [1, 1]]);
+	const fib = (n) => {
+		if (memo.has(n)) return memo.get(n);
+		const val = fib(n - 1) + fib(n - 2);
+		memo.set(n, val);
+		return val;
+	};
+	return Array.from({ length: cLimit }, (_, i) => fib(i));
+}
+/**
+* * Generator function for Fibonacci sequence up to a given limit.
+*
+* @param limit - Number of Fibonacci numbers to generate.
+* @param onYield - Optional callback triggered on each yield with the current value and index.
+* @returns A generator yielding Fibonacci numbers one by one.
+*/
+function* fibonacciGenerator(limit, onYield) {
+	const cLimit = Number(limit);
+	if (!Number.isFinite(cLimit) || cLimit < 0) return;
+	let a = 0;
+	let b = 1;
+	for (let i = 0; i < cLimit; i++) {
+		onYield?.(a, i);
+		yield a;
+		[a, b] = [b, a + b];
+	}
+}
+/**
+* * Calculates the `n`th Fibonacci number using optimized space.
+*
+* @param index - The index (0-based) of the Fibonacci number.
+* @returns The index=`n`th Fibonacci number.
+*/
+function getNthFibonacci(index) {
+	const n = Number(index);
+	if (!Number.isFinite(n) || n < 0) return NaN;
+	if (n === 0) return 0;
+	if (n === 1) return 1;
+	let a = 0, b = 1;
+	for (let i = 2; i <= n; i++) [a, b] = [b, a + b];
+	return b;
+}
+
+//#endregion
+//#region src/number/convert.ts
+/**
+* * Converts a numeric value into its corresponding English word representation.
+* @warning ***Supports numeric values up to `10e19` or `10^20` (one hundred quintillion).***
+* @warning ***Decimal values are ignored; only the integer part is converted.***
+* @param number - The number to convert into words.
+* @returns The number converted in words.
+*/
+function numberToWords(num) {
+	let number = Math.trunc(Number(num));
+	if (!Number.isFinite(number) || isNaN(number)) return "Invalid Number!";
+	const isNegative = number < 0;
+	if (number === 0) return "zero";
+	number = Math.abs(number);
+	let i = 0;
+	let result = "";
+	while (number > 0) {
+		if (i >= THOUSANDS.length) return `Number exceeds supported range (max is 10e19 aka 10^20)`;
+		if (number % 1e3 !== 0) {
+			const isLastGroup = i === 0 && number % 100 < 100;
+			result = `${_convertLessThanThousand(number % 1e3, isLastGroup)} ${THOUSANDS[i]} ${result}`;
+		}
+		number = Math.floor(number / 1e3);
+		i++;
+	}
+	const finalResult = result.trim().replace(/\s+/g, " ");
+	return isNegative ? `minus ${finalResult}` : finalResult;
+}
+/**
+* * Converts a number to an uppercase Roman numeral.
+* @param value - The number to convert. Number must be an integer and `between 1 and 3999`.
+* @returns The Roman numeral representation in uppercase.
+*
+* @example convertToRomanNumerals(29) // → "XXIX"
+*/
+const convertToRomanNumerals = (value) => {
+	let num = normalizeNumber(value);
+	if (!isInteger(num) || num <= 0 || num >= 4e3) throw new RangeError("Value must be an integer and between 1 and 3999");
+	const romanMap = [
+		[1e3, "M"],
+		[900, "CM"],
+		[500, "D"],
+		[400, "CD"],
+		[100, "C"],
+		[90, "XC"],
+		[50, "L"],
+		[40, "XL"],
+		[10, "X"],
+		[9, "IX"],
+		[5, "V"],
+		[4, "IV"],
+		[1, "I"]
+	];
+	let result = "";
+	for (const [value, numeral] of romanMap) while (num >= value) {
+		result += numeral;
+		num -= value;
+	}
+	return result;
+};
+/**
+* * Converts a Roman numeral to its Arabic numeric representation.
+* @param roman - The Roman numeral to convert. Case-insensitive but must represent a valid Roman numeral (`I`–`MMMCMXCIX`) otherwise throws runtime error.
+* @returns The numeric (Arabic system) representation of the Roman numeral.
+*
+* @example
+* romanToInteger("XXIX") // → 29
+* romanToInteger("mmxxv") // → 2025
+*/
+const romanToInteger = (roman) => {
+	const romanMap = {
+		I: 1,
+		V: 5,
+		X: 10,
+		L: 50,
+		C: 100,
+		D: 500,
+		M: 1e3
+	};
+	if (!isNonEmptyString(roman) || !roman?.trim()) throw new TypeError("Input must be a non-empty string");
+	const upperRoman = roman?.toUpperCase()?.trim();
+	let total = 0;
+	let prevValue = 0;
+	for (let i = upperRoman.length - 1; i >= 0; i--) {
+		const char = upperRoman[i];
+		const value = romanMap[char];
+		if (!value) throw new Error(`Invalid Roman numeral character: '${char}'`);
+		if (value < prevValue) total -= value;
+		else {
+			total += value;
+			prevValue = value;
+		}
+	}
+	if (total <= 0 || total >= 4e3) throw new RangeError("Resulting number must be between 1 and 3999");
+	if (convertToRomanNumerals(total) !== upperRoman) throw new Error("Invalid or malformed Roman numeral!");
+	return total;
+};
+/**
+* * Converts a number, numeric string, or cardinal word string into its ordinal word representation.
+*
+* @param number - A number (e.g. `42`), numeric string (e.g. `"42"`), or cardinal word (e.g. `"forty-two"`).
+* @returns The ordinal word form (always in lowercase) of the input.
+*
+* @example
+* numberToWordsOrdinal(1); // "first"
+* numberToWordsOrdinal("23"); // "twenty-third"
+* numberToWordsOrdinal("twenty-three"); // "twenty-third"
+*/
+function numberToWordsOrdinal(number) {
+	const TEEN_OR_HUNDRED = /(teen|hundred|thousand|(m|b|tr|quadr)illion)$/;
+	const UNDER_TEEN = /(zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)$/;
+	const _fixUnderTeen = (cardinal) => {
+		return ORDINAL_UNDER_TEEN[cardinal];
+	};
+	const wordNumber = isNumericString(number) || isNumber(number) ? numberToWords(number) : number?.trim()?.toLowerCase();
+	if (TEEN_OR_HUNDRED.test(wordNumber)) return wordNumber + "th";
+	else if (/y$/.test(wordNumber)) return wordNumber.replace(/y$/, "ieth");
+	else if (UNDER_TEEN.test(wordNumber)) return wordNumber.replace(UNDER_TEEN, _fixUnderTeen);
+	else return wordNumber;
+}
+/**
+* * Convert an English cardinal/ordinal word string into a number.
+*
+* - Accepts hyphenated words, "and", ordinals (first, second, etc.), negatives, and large scales (thousand, million etc.).
+*
+* @example
+* wordsToNumber('forty-two') // 42
+* wordsToNumber('one hundred and seven') // 107
+* wordsToNumber('two thousand three hundred') // 2300
+* wordsToNumber('twenty-first') // 21
+* wordsToNumber('negative five') // -5
+*
+* @param word - A human readable number (cardinal or ordinal) in words
+* @returns Numeric value of the word or NaN if cannot parse
+*
+* @remarks
+* **NOTE** - *For very large numbers (e.g. more than quintillion) results may not always be correct.*
+*/
+function wordsToNumber(word) {
+	if (!isNonEmptyString(word)) return NaN;
+	const trimmed = word.trim();
+	if (/^[+-]?\d{1,3}(,\d{3})*(\.\d+)?$/.test(trimmed)) return Number(trimmed.replace(/,/g, ""));
+	if (/^[+-]?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+	let input = trimmed.toLowerCase();
+	let negative = false;
+	input = input.replace(/^\s*(minus|negative)\s+/, () => {
+		negative = true;
+		return "";
+	});
+	input = input.replace(/-/g, " ").replace(/\s+and\s+/g, " ").replace(/\s+/g, " ").trim();
+	if (!input) return NaN;
+	const onesMap = new Map(ONES.map((w, i) => [w === "" ? "zero" : w, i]));
+	const teensMap = new Map(TEENS.map((w, i) => [w, 10 + i]));
+	const tensMap = new Map(TENS.map((w, i) => [w, i * 10]));
+	const scalesMap = new Map(THOUSANDS.map((w, i) => [w, i === 0 ? 1 : 1e3 ** i]));
+	const PROTECTED_TOKENS = new Set([
+		...ONES,
+		...TEENS,
+		...TENS,
+		...THOUSANDS,
+		"hundred",
+		"zero"
+	].filter(Boolean));
+	const tokens = input.split(" ").map((token) => {
+		if (ORDINAL_TO_CARDINAL[token]) return ORDINAL_TO_CARDINAL[token];
+		if (PROTECTED_TOKENS.has(token)) return token;
+		return token.replace(/(teenth|tieth|ieth|th|st|nd|rd)$/i, "");
+	}).filter(Boolean);
+	if (tokens.length === 0) return NaN;
+	let total = 0;
+	let currentNumber = 0;
+	let hasInvalidToken = false;
+	for (const token of tokens) {
+		if (hasInvalidToken) break;
+		if (onesMap.has(token)) {
+			currentNumber += onesMap.get(token);
+			continue;
+		}
+		if (teensMap.has(token)) {
+			currentNumber += teensMap.get(token);
+			continue;
+		}
+		if (tensMap.has(token)) {
+			currentNumber += tensMap.get(token);
+			continue;
+		}
+		if (token === "hundred") {
+			currentNumber = (currentNumber || 1) * 100;
+			continue;
+		}
+		if (scalesMap.has(token)) {
+			const scale = scalesMap.get(token);
+			if (scale > 1) {
+				total += (currentNumber || 1) * scale;
+				currentNumber = 0;
+				continue;
+			}
+		}
+		if (/^\d+$/.test(token)) {
+			currentNumber += Number(token);
+			continue;
+		}
+		hasInvalidToken = true;
+	}
+	if (hasInvalidToken) return NaN;
+	total += currentNumber;
+	return negative ? -total : total;
+}
+/**
+* * Converts Bangla (Arabic system) digits to Latin (Arabic system) digits.
+*
+* @remarks
+* - Behavior depends on the `forceNumber` flag:
+*   - When `forceNumber` is `true`, always returns a `number` (strips non-digit characters).
+* 	   - Returns `NaN` if the input is non empty string or does not include any numeric string.
+*   - When `forceNumber` is `false`, always returns a string, including non-digit characters.
+* 	   - Returns empty string if the input is non empty string.
+*
+* @param bnDigit - A string containing Bangla (Arabic system) digits.
+* @param forceNumber - Whether to force number conversion even if the input includes non-digit character(s). Default is `false`.
+*
+* @example
+* banglaToDigit('১২৩abc'); // 123
+* banglaToDigit(''); // NaN
+* banglaToDigit('৪৫৬');    // 456
+*
+* @example
+* banglaToDigit('১২৩', false);	// "123"
+* banglaToDigit('১২৩abc', false);	// "123abc"
+*/
+function banglaToDigit(bnDigit, forceNumber = true) {
+	if (!isNonEmptyString(bnDigit)) return forceNumber ? NaN : "";
+	const digitStr = bnDigit.replace(/[০১২৩৪৫৬৭৮৯]/g, (d) => String(BN_DIGITS[d]));
+	if (forceNumber) return Number(digitStr.split("").filter((dig) => !isNaN(Number(dig))).join(""));
+	return digitStr;
+}
+/**
+* * Converts Latin (Arabic system) digits to Bangla digits (Arabic system).
+*
+* @remarks
+* - Accepts numbers or numeric strings including non-digit characters.
+* - When `preserveNonDigit` is `true`, non-digit characters are preserved in the output.
+* - When `preserveNonDigit` is `false`, non-numeric strings are stripped.
+* - Returns empty string for invalid input.
+*
+* @param digit - A number or string containing Latin (Arabic system) digits.
+* @param preserveNonDigit - Whether to preserve non-digit characters in the output. Default is `true`.
+*
+* @example
+* digitToBangla(123);          // "১২৩"
+* digitToBangla('456');        // "৪৫৬"
+*
+* @example
+* digitToBangla('12ab', false);	// "১২"
+* digitToBangla('12ab');		// "১২ab"
+*/
+function digitToBangla(digit, preserveNonDigit = true) {
+	const banglaDigits = Object.keys(BN_DIGITS);
+	const _matchAndConvert = (value) => {
+		return value.replace(/\d/g, (dig) => banglaDigits[Number(dig)]);
+	};
+	if (isNumber(digit)) return _matchAndConvert(String(digit));
+	if (isNonEmptyString(digit)) {
+		const bnDigStr = _matchAndConvert(digit);
+		if (preserveNonDigit || isNumericString(digit)) return bnDigStr;
+		return bnDigStr.split("").filter((dig) => banglaDigits.includes(dig)).join("");
+	}
+	return "";
+}
+
+//#endregion
+//#region src/number/prime.ts
+/**
+* * Checks if a number is prime.
+*
+* @param number The number to check.
+* @returns Boolean: `true` if the number is prime, otherwise `false`.
+*/
+const isPrime = (number) => {
+	if (number < 2) return false;
+	if (number === 2 || number === 3) return true;
+	if (number % 2 === 0 || number % 3 === 0) return false;
+	for (let i = 5; i * i <= number; i += 6) if (number % i === 0 || number % (i + 2) === 0) return false;
+	return true;
+};
+/**
+* * Find prime numbers in a given range.
+*
+* @param start The starting number of the range. Default is `1`.
+* @param end The ending number of the range. Default is `1000`.
+* @returns An array of prime numbers within the range (inclusive).
+*/
+const findPrimeNumbers = (start = 1, end = 1e3) => {
+	let startNumber = start, endNumber = end;
+	if (start > end) [startNumber, endNumber] = [end, start];
+	return Array.from({ length: endNumber - startNumber + 1 }, (_, i) => startNumber + i).filter(isPrime);
+};
+
+//#endregion
+//#region src/array/basics.ts
+/**
+* * Flattens a nested array recursively or wraps any non-array data type in an array.
+*
+* @param input - The input value, which can be a nested array or a non-array value.
+* @returns A fully flattened array of type `Flatten<T>`. If the input is not an array, it wraps it in a single-element array.
+*/
+const flattenArray = (input) => {
+	if (!Array.isArray(input)) return [input];
+	return input.reduce((acc, item) => {
+		return acc.concat(Array.isArray(item) ? flattenArray(item) : [item]);
+	}, []);
+};
+/**
+* @deprecated _Please, use `findAll` instance method from `Finder` class for **more advanced filtering and searching.**_
+*
+* * Filters an array of objects based on multiple conditions for specified keys.
+* @param array - The array of objects to filter.
+* @param conditions - An object where keys represent the property names and values represent filter conditions.
+*                     The conditions can be a function `(value: T[K]) => boolean`.
+* @returns The filtered array of objects.
+* @throws `Error` If the input is not a valid array.
+*/
+const filterArrayOfObjects = (array, conditions) => {
+	if (!Array.isArray(array)) throw new Error("The provided input is not a valid array!");
+	return array?.filter((item) => Object.entries(conditions)?.every(([key, conditionFn]) => {
+		if (typeof conditionFn === "function") return conditionFn(item[key]);
+		return true;
+	}));
+};
+/**
+* * Checks if a value is an empty array or an array with only empty values.
+*
+* @param value - The value to check.
+* @returns `true` if the value is not an array, an empty array, or an array containing only `null`, `undefined`, empty objects, or empty arrays.
+*/
+const isInvalidOrEmptyArray = (value) => {
+	if (!Array.isArray(value)) return true;
+	if (value?.length === 0) return true;
+	return value?.every((item) => item == null || Array.isArray(item) && item?.length === 0 || typeof item === "object" && Object.keys(item || {})?.length === 0);
+};
+/**
+* * Shuffle the elements of an array.
+*
+* @param array Array to shuffle.
+* @returns Shuffled array.
+*/
+const shuffleArray = (array) => {
+	if (isInvalidOrEmptyArray(array)) return array;
+	const shuffled = [...array];
+	for (let i = shuffled?.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+	}
+	return shuffled;
+};
+/**
+* * Get the last element of an array.
+*
+* @param array Array to get the last element from.
+* @returns The last element or `undefined` if the array is empty.
+*/
+const getLastArrayElement = (array) => {
+	return array?.length > 0 ? array[array?.length - 1] : void 0;
+};
+
+//#endregion
+//#region src/number/range.ts
+/**
+* * Function to get numbers within a range based on the provided {@link NumberType} and options.
+*
+* @remarks Returns either string or array of numbers based on the {@link RangeOptions.getAsString getAsString} option.
+*
+* @param type - The type of numbers to generate ('random', 'prime', etc.).
+* @param options - Options to configure number generation, including range and formatting.
+* @returns The numbers in the range based on {@link type} and {@link options} either as string or array of numbers.
+*/
+function getNumbersInRange(type = "any", options) {
+	const { getAsString = false, min = 0, max = 100, includeMin = true, includeMax = true, separator = ", ", multiplesOf } = options || {};
+	let output = [];
+	/**
+	* Helper function to apply range and get array of numbers in that range.
+	*
+	* @param start The start of the range.
+	* @param end The end of the range.
+	* @returns The array of numbers in the range.
+	*/
+	const _applyRangeOptions = (start, end) => {
+		let startNumber = start;
+		let endNumber = end;
+		if (start > end) [startNumber, endNumber] = [end, start];
+		const numbers = [];
+		for (let i = startNumber; i <= endNumber; i++) if (i >= startNumber && i <= endNumber && (includeMin || i > startNumber) && (includeMax || i < endNumber)) numbers.push(i);
+		return numbers;
+	};
+	if (type === "prime" && !isUndefined(multiplesOf)) console.warn("Warning: The \"multiplesOf\" option is ignored when the type is \"prime\"!");
+	switch (type) {
+		case "random":
+			output = shuffleArray(_applyRangeOptions(min, max).map((n) => getRandomNumber({
+				min: n,
+				max: n,
+				includeMin,
+				includeMax
+			})));
+			break;
+		case "prime":
+			output = _applyRangeOptions(min, max).filter(isPrime);
+			break;
+		case "odd":
+			output = _applyRangeOptions(min, max).filter(isOdd);
+			break;
+		case "even":
+			output = _applyRangeOptions(min, max).filter(isEven);
+			break;
+		case "natural":
+			output = _applyRangeOptions(Math.max(min, 1), max);
+			break;
+		default:
+			output = _applyRangeOptions(min, max);
+			break;
+	}
+	if (type !== "prime") output = _applyMultiples(output, multiplesOf);
+	return getAsString ? convertArrayToString(output, { separator }) : output;
+}
+
+//#endregion
+//#region src/array/transform.ts
+/**
+* * Converts an array of objects into a formatted array of options.
+*
+* @param data - An array of objects to convert into options.
+* @param config - The configuration object to specify the keys for the `value` (firstFieldName) and `label` (secondFieldName) fields and rename as needed.
+* @returns An array of options, where each option has `value` and `label` fields as default or as specified by user in the config options.
+*/
+function createOptionsArray(data, config) {
+	const { firstFieldKey, secondFieldKey, firstFieldName = "value", secondFieldName = "label", retainNumberValue = false } = config || {};
+	if (data && data?.length) return data?.map((datum) => {
+		const firstValue = retainNumberValue && isNumber(datum[firstFieldKey]) ? datum[firstFieldKey] : String(datum[firstFieldKey] ?? "");
+		return {
+			[firstFieldName]: firstValue,
+			[secondFieldName]: String(datum[secondFieldKey] ?? "")
+		};
+	});
+	else return [];
+}
+/**
+* * Removes duplicate values from an array, supporting deep comparison for objects and arrays.
+*
+* @param array - The array from which duplicates need to be removed.
+* @returns A new array with duplicates removed.
+*/
+function removeDuplicatesFromArray(array) {
+	return array?.filter((item, index, self) => index === self?.findIndex((el) => isDeepEqual(el, item)));
+}
+/**
+* * Finds duplicate values in an array, runs deep comparison for objects and arrays.
+*
+* @param array - The array in which to find duplicates.
+* @returns An array containing all duplicate entries (each one only once).
+*/
+function getDuplicates(array) {
+	const seen = [];
+	const duplicates = [];
+	for (const item of array) {
+		const hasSeen = seen?.find((el) => isDeepEqual(el, item));
+		const hasDuplicate = duplicates?.find((el) => isDeepEqual(el, item));
+		if (hasSeen && !hasDuplicate) duplicates?.push(item);
+		else if (!hasSeen) seen?.push(item);
+	}
+	return duplicates;
+}
+/**
+* * Finds elements missing from one array compared to another using deep comparison.
+*
+* @param options - Configuration to specify which array to compare and direction of check.
+* @returns An array of missing elements based on the comparison direction.
+*/
+/**
+* * Finds elements missing from one array compared to another using deep comparison.
+*
+* @param array1 The first array to compare.
+* @param array2 The second array to compare.
+* @param missingFrom Which direction to compare for missing values:.
+*					  - `'from-first'` → values in `array1` missing in `array2`.
+*					  - `'from-second'` → values in `array2` missing in `array1`.
+* @returns An array of missing elements based on the comparison direction.
+*/
+function findMissingElements(array1, array2, missingFrom) {
+	const source = (missingFrom === "from-first" ? array1 : array2) ?? [];
+	const target = (missingFrom === "from-first" ? array2 : array1) ?? [];
+	return source.filter((s) => !target?.some((t) => isDeepEqual(t, s)));
+}
+/**
+* * Splits an array into chunks of a given size.
+*
+* @param arr The array to split.
+* @param chunkSize The size of each chunk.
+* @returns An array of chunked arrays.
+*/
+function splitArray(arr, chunkSize) {
+	const result = [];
+	for (let i = 0; i < arr?.length; i += chunkSize) result.push(arr.slice(i, i + chunkSize));
+	return result;
+}
+/**
+* * Group an array of objects by a specified key, returning only arrays of grouped objects.
+*
+* @param source - The source array of objects to group.
+* @param property - The property to group the array by. Property can be a string, number, boolean, undefined or null. Supports nested dot notation.
+*
+* @returns An array of grouped arrays. Each sub-array contains objects that share the same value for the specified property.
+*
+* @example
+* splitArrayByProperty([{ type: 'a' }, { type: 'b' }, { type: 'a' }, { type: undefined }], 'type')
+* // => [ [{ type: 'a' }, { type: 'a' }], [{ type: 'b' }], [{ type: undefined }] ]
+*
+* @notes
+* - Returns an empty array if the input is invalid or empty.
+* - Groups objects even when the group key is `undefined` or `null` (object with `null` & `undefined` property-values are grouped together).
+*/
+function splitArrayByProperty(source, property) {
+	if (!isValidArray(source)) return [];
+	const grouped = {};
+	source.forEach((item) => {
+		const rawKey = _resolveNestedKey(item, property);
+		const key = rawKey != null ? String(rawKey) : "__undefined__";
+		if (!grouped[key]) grouped[key] = [];
+		grouped[key].push(item);
+	});
+	return Object.values(grouped);
+}
+/**
+* * Rotates an array left or right by a given number of steps.
+*
+* @param arr The array to rotate.
+* @param steps The number of positions to rotate (positive: right, negative: left).
+* @returns The rotated array.
+*/
+function rotateArray(arr, steps) {
+	const length = arr?.length;
+	if (length === 0) return arr;
+	const offset = (steps % length + length) % length;
+	return arr.slice(-offset).concat(arr.slice(0, -offset));
+}
+/**
+* * Moves an element within an array from one index to another.
+*
+* @param arr The array to modify.
+* @param fromIndex The index of the element to move.
+* @param toIndex The new index for the element.
+* @returns A new array with the element moved.
+*/
+function moveArrayElement(arr, fromIndex, toIndex) {
+	const newArr = [...arr];
+	const [item] = newArr.splice(fromIndex, 1);
+	newArr.splice(toIndex, 0, item);
+	return newArr;
+}
+
+//#endregion
+//#region src/array/calc.ts
+/**
+* * Calculates the sum of differences between two numeric fields for each item in the array.
+*
+* @param data - The array of objects to process.
+* @param first - The field name to subtract **from** (minuend), supports nested dot notation.
+* @param second - The field name to subtract (subtrahend), supports nested dot notation.
+* @param roundTo - Decimal places to round the result to. Defaults to 2.
+* @returns The total sum of differences between the two fields across all items.
+*
+* @example
+* sumFieldDifference([{ buy: 10, sell: 3 }, { buy: 8, sell: 5 }], 'buy', 'sell');
+* // => 10
+*/
+function sumFieldDifference(data, first, second, roundTo = 2) {
+	if (!isValidArray(data)) return 0;
+	const total = data?.reduce((acc, item) => {
+		return acc + (_getNumericProp(item, first) - _getNumericProp(item, second));
+	}, 0);
+	return roundNumber(total, roundTo);
+}
+/**
+* * Calculates the total sum of a numeric field across all items.
+*
+* @param data - The array of objects to process.
+* @param field - The field to sum values from. Supports nested dot notation.
+* @param roundTo - Decimal places to round the result to. Defaults to 2.
+* @returns The rounded total sum.
+*
+* @example
+* sumByField([{ a: 5 }, { a: 3 }], 'a');
+* // => 8
+*/
+function sumByField(data, field, roundTo = 2) {
+	if (!isValidArray(data)) return 0;
+	const total = data?.reduce((acc, item) => acc + _getNumericProp(item, field), 0);
+	return roundNumber(total, roundTo);
+}
+/**
+* * Calculates the average of a numeric field across all items.
+*
+* @param data - The array of objects to process.
+* @param field - The field to calculate the average from. Supports nested dot notation.
+* @param roundTo - Decimal places to round the result to. Defaults to 2.
+* @returns The rounded average.
+*
+* @example
+* averageByField([{ a: 4 }, { a: 6 }], 'a');
+* // => 5
+*/
+function averageByField(data, field, roundTo = 2) {
+	if (!isValidArray(data)) return 0;
+	const total = data?.reduce((acc, item) => acc + _getNumericProp(item, field), 0);
+	return roundNumber(total / data.length, roundTo);
+}
+/**
+* * Groups an array of objects by a primitive field and sums another numeric field per group.
+*
+* @param data - The array of objects to group.
+* @param groupBy - The field to group by. Supports nested dot notation.
+* @param sumBy - The numeric field to sum within each group. Supports nested dot notation.
+* @param roundTo - Decimal places to round each group’s result to. Defaults to 2.
+* @returns An array of records, each with the group key and its corresponding summed value.
+*
+* @example
+* groupAndSumByField([{ type: 'A', val: 2 }, { type: 'A', val: 3 }, { type: 'B', val: 1 }], 'type', 'val');
+* // => [{ A: 5 }, { B: 1 }]
+*/
+function groupAndSumByField(data, groupBy, sumBy, roundTo = 2) {
+	if (!isValidArray(data)) return [];
+	return splitArrayByProperty(data, groupBy).map((group) => ({ [`${_resolveNestedKey(group[0], groupBy)}`]: sumByField(group, sumBy, roundTo) }));
+}
+/**
+* * Groups an array of objects by a primitive field and averages another numeric field per group.
+*
+* @param data - The array of objects to group.
+* @param groupBy - The field to group by. Supports nested dot notation.
+* @param averageBy - The numeric field to average within each group. Supports nested dot notation.
+* @param roundTo - Decimal places to round each group’s average to. Defaults to 2.
+* @returns An array of records, each with the group key and its corresponding average value.
+*
+* @example
+* groupAndAverageByField([{ type: 'A', val: 2 }, { type: 'A', val: 4 }, { type: 'B', val: 6 }], 'type', 'val');
+* // => [{ A: 3 }, { B: 6 }]
+*/
+function groupAndAverageByField(data, groupBy, averageBy, roundTo = 2) {
+	if (!isValidArray(data)) return [];
+	return splitArrayByProperty(data, groupBy).map((group) => ({ [`${_resolveNestedKey(group[0], groupBy)}`]: averageByField(group, averageBy, roundTo) }));
+}
+
+//#endregion
+//#region src/array/Finder.ts
+/**
+* @class `Finder` performs optimized searching on arrays.
+*      - It supports binary search, fuzzy search, and smart caching with TTL.
+*/
+var Finder = class Finder {
+	static #DEFAULT_TTL = 1e3 * 60 * 5;
+	#cachedResult = /* @__PURE__ */ new Map();
+	#sortedCache = /* @__PURE__ */ new Map();
+	#ttl;
+	#items;
+	/**
+	* * Creates a new `Finder` instance.
+	*
+	* @param data The initial array of items or a callback returning them.
+	* @param ttl Time-to-live (in milliseconds) for cached search results. Defaults to {@link Finder.#DEFAULT_TTL 5 Minutes}.
+	*/
+	constructor(data, ttl = Finder.#DEFAULT_TTL) {
+		this.#ttl = ttl;
+		this.#items = isFunction(data) ? data() : data;
+	}
+	/**
+	* @instance Clears cache globally or for a specific key.
+	* @param key Optional key to clear only a specific cache entry.
+	*/
+	clearCache(key) {
+		if (key) this.#cachedResult.delete(key);
+		else this.#cachedResult.clear();
+	}
+	/**
+	* @instance Finds all items that match the provided matcher using optional caching or fuzzy logic.
+	* @param matcher The value to match against.
+	* @param keySelector Property key or selector function.
+	* @param options Optional settings for search behavior and source list.
+	*/
+	findAll(matcher, keySelector, options) {
+		const { fuzzy = false, needSorting = true, cacheKey = "finder-cache", forceBinary = false, caseInsensitive = true, data } = options ?? {};
+		const source = isFunction(data) ? data() : data ?? this.#items;
+		if (!source?.length) return [];
+		const rawGetKey = typeof keySelector === "function" ? keySelector : (item) => item[keySelector];
+		const getKey = Finder.#createMemoizedKeyGetter(rawGetKey);
+		const normalizedMatcher = caseInsensitive && isString(matcher) ? matcher.toLowerCase() : matcher;
+		if (cacheKey) {
+			const entry = this.#cachedResult.get(cacheKey);
+			if (entry && Date.now() - entry.timestamp < this.#ttl) return entry.result;
+			else this.#cachedResult.delete(cacheKey);
+		}
+		let results = [];
+		if (source.length < 100 && !forceBinary) results = source.filter((item) => {
+			const key = getKey(item);
+			return (caseInsensitive && isString(key) ? key.toLowerCase() : key) === normalizedMatcher;
+		});
+		else {
+			const sorted = needSorting ? this.#sortAndCache(source, getKey, cacheKey) : source;
+			const firstMatch = this.binarySearch(sorted, normalizedMatcher, getKey, caseInsensitive);
+			if (firstMatch) {
+				const baseKey = getKey(firstMatch);
+				const base = caseInsensitive && isString(baseKey) ? baseKey.toLowerCase() : baseKey;
+				results = sorted.filter((item) => {
+					const key = getKey(item);
+					return (caseInsensitive && isString(key) ? key.toLowerCase() : key) === base;
+				});
+			}
+		}
+		if (!results.length && fuzzy && isString(normalizedMatcher)) results = source.filter((item) => {
+			const rawKey = getKey(item);
+			const key = caseInsensitive && isString(rawKey) ? rawKey.toLowerCase() : String(rawKey);
+			return this.#match(key, normalizedMatcher);
+		});
+		if (cacheKey) this.#cachedResult.set(cacheKey, {
+			result: results,
+			timestamp: Date.now()
+		});
+		return results;
+	}
+	/**
+	* @instance Finds first matching item that matches the provided matcher using optional caching or fuzzy logic.
+	* @param matcher The value to match.
+	* @param keySelector Property key or selector function.
+	* @param options Optional behavior flags and item source.
+	*/
+	findOne(matcher, keySelector, options) {
+		const { fuzzy = false, needSorting = true, cacheKey = "finder-cache", forceBinary = false, caseInsensitive = true, data } = options ?? {};
+		const source = isFunction(data) ? data() : data ?? this.#items;
+		if (!source?.length) return void 0;
+		const rawGetKey = typeof keySelector === "function" ? keySelector : (item) => item[keySelector];
+		const getKey = Finder.#createMemoizedKeyGetter(rawGetKey);
+		const normalizedMatcher = caseInsensitive && isString(matcher) ? matcher.toLowerCase() : matcher;
+		if (cacheKey) {
+			const entry = this.#cachedResult.get(cacheKey);
+			if (entry && Date.now() - entry.timestamp < this.#ttl) return entry.result[0];
+			else this.#cachedResult.delete(cacheKey);
+		}
+		let result;
+		if (source?.length < 100 && !forceBinary) result = source?.find((item) => {
+			const key = getKey(item);
+			return (caseInsensitive && isString(key) ? key.toLowerCase() : key) === normalizedMatcher;
+		});
+		else result = this.binarySearch(needSorting ? this.#sortAndCache(source, getKey, cacheKey) : source, normalizedMatcher, getKey, caseInsensitive);
+		if (!result && fuzzy && isString(normalizedMatcher)) return this.fuzzySearch(source, normalizedMatcher, getKey, caseInsensitive);
+		if (cacheKey && result) this.#cachedResult.set(cacheKey, {
+			result: [result],
+			timestamp: Date.now()
+		});
+		return result;
+	}
+	/**
+	* @instance Asynchronous variant of `findAll` that accepts a promise-based data supplier.
+	* @param supplier Async function resolving the items list.
+	* @param matcher The value to match.
+	* @param keySelector Property key or selector function.
+	* @param options Optional settings for search behavior and cache.
+	*/
+	async findAllAsync(supplier, matcher, keySelector, options) {
+		const items = await supplier();
+		return this.findAll(matcher, keySelector, {
+			...options,
+			data: items
+		});
+	}
+	/**
+	* @instance Asynchronous variant of `findOne`.
+	* @param supplier Async function resolving the items list.
+	* @param matcher The value to match.
+	* @param keySelector Property key or selector function.
+	* @param options Optional settings for behavior and cache.
+	*/
+	async findOneAsync(supplier, matcher, keySelector, options) {
+		const items = await supplier();
+		return this.findOne(matcher, keySelector, {
+			...options,
+			data: items
+		});
+	}
+	/**
+	* @instance Performs a binary search on a sorted array using a custom key selector.
+	*
+	* @param sorted - The sorted array of items to search.
+	* @param matcher - The value to search for.
+	* @param keySelector - A function that extracts the comparable key from each item.
+	* @param caseInsensitive - Whether to compare string keys ignoring case.
+	* @returns The first matching item if found; otherwise, undefined.
+	*/
+	binarySearch(sorted, matcher, keySelector, caseInsensitive) {
+		let min = 0, max = sorted?.length - 1;
+		while (min <= max) {
+			const mid = Math.floor((min + max) / 2);
+			const midKey = keySelector(sorted[mid]);
+			const key = caseInsensitive && isString(midKey) ? midKey.toLowerCase() : midKey;
+			if (key === matcher) return sorted[mid];
+			if (key < matcher) min = mid + 1;
+			else max = mid - 1;
+		}
+	}
+	/**
+	* @instance Performs a fuzzy search on an array by matching characters in sequence.
+	*
+	* @param array - The array of items to search.
+	* @param matcher - The fuzzy search string to match against.
+	* @param keySelector - A function that extracts the key to search from each item.
+	* @param caseInsensitive - Whether to compare ignoring case for string values.
+	* @returns The first fuzzy-matching item if found; otherwise, undefined.
+	*/
+	fuzzySearch(array, matcher, keySelector, caseInsensitive) {
+		for (const item of array) {
+			const rawKey = keySelector(item);
+			const key = caseInsensitive && isString(rawKey) ? rawKey.toLowerCase() : String(rawKey);
+			if (this.#match(key, matcher)) return item;
+		}
+	}
+	/**
+	* @private Checks if the characters in the target string appear in order within the source string.
+	* @param source Source string to search within.
+	* @param target Target string to match against the source string.
+	* @returns True if the target string is a fuzzy match within the source string; otherwise, false.
+	*/
+	#match(source, target) {
+		let i = 0;
+		for (const char of target) {
+			i = source?.indexOf(char, i);
+			if (i === -1) return false;
+			i++;
+		}
+		return true;
+	}
+	/**
+	* @private Sorts an array and caches the result for a specified time-to-live (TTL).
+	* @param data Data to sort and cache.
+	* @param getKey Key extraction function.
+	* @param cacheKey Optional cache key for storing the result.
+	* @returns
+	*/
+	#sortAndCache(data, getKey, cacheKey) {
+		if (cacheKey) {
+			const entry = this.#sortedCache.get(cacheKey);
+			if (entry && Date.now() - entry.timestamp < this.#ttl) return entry.result;
+			else this.#sortedCache.delete(cacheKey);
+		}
+		const sorted = [...data].sort((a, b) => {
+			const keyA = getKey(a);
+			const keyB = getKey(b);
+			return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+		});
+		if (cacheKey) this.#sortedCache.set(cacheKey, {
+			result: sorted,
+			timestamp: Date.now()
+		});
+		return sorted;
+	}
+	/**
+	* @static @private Creates a memoized version of a key extractor.
+	* @param getKey Original key extraction function
+	*/
+	static #createMemoizedKeyGetter(getKey) {
+		const cache = /* @__PURE__ */ new Map();
+		return (item) => {
+			if (cache.has(item)) return cache.get(item);
+			const key = getKey(item);
+			cache.set(item, key);
+			return key;
+		};
+	}
+};
+
+//#endregion
+//#region src/object/basics.ts
+/**
+* * Deep clone an object using `structuredClone` or deterministic *JSON serialization*.
+*
+* @param obj Object to clone.
+* @param serialize Whether to force deterministic JSON serialization instead of using `structuredClone`. Defaults to `false`.
+* @returns Deep cloned object.
+*
+* @remarks
+* **Primary behavior**
+* - By default (`serialize = false`), the function uses {@link https://developer.mozilla.org/docs/Web/API/Window/structuredClone structuredClone} when available. This supports:
+*   - Circular references
+*   - `Date` objects
+*   - `Map` / `Set`
+*   - `RegExp`
+*   - Typed arrays
+*   - Most built-in JavaScript types
+*   - Preserves `undefined` values
+*
+* - **Note:** `structuredClone` **does not preserve class prototypes**, even though it preserves data types like `Date`, `Map`, and `Set`.
+*
+* **Deterministic serialization mode**
+* - When `serialize = true`, or when `structuredClone` is unavailable, the function falls back to **stable JSON serialization** via `stableStringify`. This guarantees:
+*   - All object keys are sorted alphabetically.
+*   - Consistent output across environments (deterministic).
+*   - All `undefined` values are converted to `null`.
+*   - 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.
+*
+* - This mode is ideal for:
+*   - Hashing
+*   - Signature generation
+*   - Deep equality checks
+*   - Anything requiring deterministic, environment-neutral output
+*
+* **Deterministic mode limitations**
+* - JSON serialization will:
+*   - Drop functions and `Symbol` values.
+*   - Lose prototype and class instance information.
+*   - Convert all date-like objects into strings.
+*   - Fail on circular references.
+*
+* **Final safety fallback**
+* - If JSON serialization fails (e.g., due to circular references), the function returns a **shallow clone** (`{ ...obj }`) to ensure the cloning never throws.
+*/
+function cloneObject(obj, serialize = false) {
+	try {
+		if (!serialize && typeof structuredClone === "function") return structuredClone(obj);
+		return JSON.parse(stableStringify(obj));
+	} catch {
+		return { ...obj };
+	}
+}
+/**
+* * Count the number of fields in an object.
+*
+* @param obj Object to check.
+* @returns Number of fields in the object.
+*/
+function countObjectFields(obj) {
+	if (obj != null) return Object.keys(obj)?.length;
+	return 0;
+}
+function extractObjectKeys(obj, tuple) {
+	const keys = isNotEmptyObject(obj) ? Object.keys(obj) : [];
+	return tuple ? keys : keys;
+}
+/**
+* * Recursively extracts all nested keys from an object as an array.
+*
+* @remarks
+* - Returns an empty array (`[]`) for an empty object or a non-object value.
+* - For only top-level keys, use {@link extractObjectKeys}.
+*
+* @param obj The object from which to extract the keys.
+* @returns An array of all the nested keys (string literals) from the specified object.
+*/
+function extractObjectKeysDeep(obj) {
+	function _getDeepKeys(candidate) {
+		let result = [];
+		for (const key in candidate) {
+			result.push(key);
+			if (isNotEmptyObject(candidate[key])) result = [...result, ..._getDeepKeys(candidate[key])];
+		}
+		return result;
+	}
+	return isNotEmptyObject(obj) ? _getDeepKeys(obj) : [];
+}
+
+//#endregion
+//#region src/object/convert.ts
+/**
+* * Converts the values of specified keys in an object or array of objects to either string or number.
+* * Supports nested objects using dot-notation keys.
+*
+* @param data The object or array of objects to convert.
+* @param options Options object specifying the conversion mapping.
+*   - `keys`: The keys in the object to be converted (dot-notation supported).
+*   - `convertTo`: The target type, either "string" or "number".
+* @returns The modified object or array of objects with the converted values, with updated types.
+*/
+function convertObjectValues(data, options) {
+	const { keys, convertTo } = options || {};
+	/** * Helper function to resolve a dot-notation key path and modify the corresponding value in the object. */
+	const _setValueAtPath = (obj, path, convertTo) => {
+		const segments = path.split(".");
+		let current = obj;
+		segments?.forEach((key, index) => {
+			if (index === segments?.length - 1) {
+				const value = current?.[key];
+				if (convertTo === "string" && !isString(value)) current[key] = String(value);
+				else if (convertTo === "number" && !isNumber(value)) current[key] = Number(value);
+			} else if (isObject(current?.[key])) current = current?.[key];
+			else {
+				current[key] = {};
+				current = current?.[key];
+			}
+		});
+		return obj;
+	};
+	/** * Recursively process a single object. */
+	const _convertValue = (obj) => {
+		let newObj = { ...obj };
+		keys?.forEach((key) => {
+			newObj = _setValueAtPath(newObj, key, convertTo);
+		});
+		return newObj;
+	};
+	if (Array.isArray(data)) return data?.map(_convertValue);
+	return _convertValue(data);
+}
+/**
+* * Pick specific fields from an object and create a new object with specified fields.
+*
+* @description This function creates a new object containing only the specified fields from the source object.
+* It is useful for creating a new object with a subset of properties from an existing object.
+*
+* @param T The type of the source object.
+* @param U The type of the keys to pick from the source object.
+*
+* @param source The source object from which to pick fields.
+* @param keys The keys of the fields to pick from the source object.
+*
+* @returns An object containing only the picked fields.
+*/
+function pickFields(source, keys) {
+	const result = {};
+	keys?.forEach((key) => {
+		result[key] = source?.[key];
+	});
+	return result;
+}
+/**
+* * Create a new object by removing specific keys from the source object.
+*
+* @param source - The original (source) object from which to delete fields.
+* @param keys - An array of keys (fields) to remove from the object.
+*
+* @returns A new object without the specified keys.
+*
+* @example
+* deleteFields({ a: 1, b: 2, c: 3 }, ['b'])
+* // => { a: 1, c: 3 }
+*
+* @notes
+* - Does not mutate the original object.
+* - Useful for excluding sensitive or unwanted fields.
+*/
+function deleteFields(source, keys) {
+	const result = {};
+	for (const key in source) if (!keys.includes(key)) result[key] = source?.[key];
+	return result;
+}
+/**
+* * Pick specific fields from an object based on a given condition.
+*
+* @description This function creates a new object containing only the fields that satisfy the given condition.
+* The condition can be based on the field's value or type, depending on the implementation.
+*
+* @param T The type of the source object.
+*
+* @param source The source object from which to pick fields.
+* @param condition A function that takes the key and value of a property and returns a boolean indicating whether the property should be picked.
+*
+* @returns An object containing only the fields that satisfy the condition.
+*/
+function pickObjectFieldsByCondition(source, condition) {
+	const result = {};
+	Object.entries(source)?.forEach(([key, value]) => {
+		if (condition(key, value)) result[key] = value;
+	});
+	return result;
+}
+/**
+* * Remap fields from one object to another.
+* @description This function creates a new object with fields remapped from the source object to the target object based on the provided field map.
+*
+* @param source The source object from which to remap fields.
+* @param fieldMap  An object that maps target keys to source keys.
+* @returns An object with fields remapped according to the field map.
+*/
+function remapFields(source, fieldMap) {
+	const result = {};
+	for (const targetKey in fieldMap) {
+		const sourceKey = fieldMap?.[targetKey];
+		result[targetKey] = source?.[sourceKey];
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/xtras.ts
+/**
+* @function `getCountryByPhone` Get country details by matching the country code in the given phone number.
+* @param phone - The phone number to look up, can be a string or a number. It will be normalized by removing any non-digit character before matching against the country codes.
+* @returns An array of country details that match the provided phone number. Each country detail includes the country name, country code, ISO short code, and ISO code. If the input is invalid (not a primitive value or an empty string), an empty array will be returned.
+*
+* @remarks
+* - The function uses the {@link COUNTRIES} constant, which is an array of country details, to find matches based on the normalized phone number.
+* - The normalization process removes any non-digit character from the input phone number to ensure consistent matching against the country codes.
+* - The function checks if the input is neither an empty string nor a finite number before proceeding with the normalization and matching process. If the input is invalid, it returns an empty array.
+* - If multiple countries share the same country code, all matching countries will be included in the returned array.
+* - **`IMPORTANT:`** If a phone number does not start with a country code (plain local number), the function will return an empty array since it cannot determine the country. But if the number matches the country code of any country, it will return the corresponding country details even if the number is a local number.
+*
+* @example
+* ```typescript
+* const country = getCountryByPhone('+8801623732187');
+* console.info(country);
+* // Output: [
+* //   {
+* //     country_name: 'Bangladesh',
+* //     country_code: '880',
+* //     iso_code_short: 'BD',
+* //     iso_code: 'BGD'
+* //   }
+* // ]
+* ```
+*/
+function getCountryByPhone(phone) {
+	if (!isNonEmptyString(phone) && !isNumber(phone)) return [];
+	const normalized = (isString(phone) ? phone : String(phone)).replace(/\D/g, "");
+	return COUNTRIES.filter((country) => normalized.startsWith(country.country_code.replace(/-/g, "")));
+}
+
+//#endregion
+export { Currency, Finder, Unit, Unit as UnitConverter, convertToRomanNumerals as arabicToRoman, convertToRomanNumerals, convertToRomanNumerals as integerToRoman, convertToRomanNumerals as numberToRoman, convertToRomanNumerals as numericToRoman, convertToRomanNumerals as toRoman, convertToRomanNumerals as toRomanNumeral, averageByField, averageByField as avgByField, banglaToDigit, getAverage as calculateAverage, getAverage, getAverage as getAverageOfNumbers, factorial as calculateFactorial, factorial, factorial as getFactorial, calculateHCF as calculateGCD, calculateHCF, calculateLCM as calculateLCD, calculateLCM, calculatePercentage, capitalizeString, getOrdinal as cardinalToOrdinal, getOrdinal as convertNumberToOrdinal, getOrdinal as convertToOrdinal, getOrdinal, getOrdinal as getOrdinalNumber, getOrdinal as numberToOrdinal, numberToWordsOrdinal as cardinalWordsToOrdinal, numberToWordsOrdinal as convertNumberToWordsOrdinal, numberToWordsOrdinal, clampNumber, cloneObject, naturalSort as compareNaturally, naturalSort as compareSorter, naturalSort, naturalSort as naturalSortForString, computeTextDiff, convertArrayToString, convertArrayToString as joinArrayElements, formatCurrency as convertNumberToCurrency, formatCurrency, numberToWords as convertNumberToWords, numberToWords, convertObjectValues, romanToInteger as convertRomanToArabic, romanToInteger as convertRomanToInteger, romanToInteger as convertRomanToNumeric, romanToInteger as romanToArabic, romanToInteger, romanToInteger as romanToNumeric, convertStringCase, convertToDecimal, convertToDecimal as convertToFixed, wordsToNumber as convertWordToNumber, wordsToNumber as convertWordsToNumber, wordsToNumber as wordToNumber, wordsToNumber, countInstanceMethods, countInstanceMethods as getInstanceMethodsCount, countObjectFields, countStaticMethods, countStaticMethods as getStaticMethodsCount, countWords, countWords as countWordsInString, countWords as wordCount, createOptionsArray, debounceAction, deepParsePrimitives, deepParsePrimitives as parsePrimitivesDeep, definePrototypeMethod, deleteFields, deleteFields as deleteObjectFields, deleteFields as omitFields, deleteFields as omitObjectFields, deleteFields as removeFields, deleteFields as removeObjectFields, digitToBangla, getDuplicates as extractDuplicates, getDuplicates as extractDuplicatesFromArray, getDuplicates, getDuplicates as getDuplicatesFromArray, extractEmails, extractObjectKeys as extractKeys, extractObjectKeys, extractObjectKeysDeep as extractKeysDeep, extractObjectKeysDeep, findMissingElements as extractMissingElements, findMissingElements, findMissingElements as getMissingElements, extractNewFields, extractNumbersFromString as extractNumbers, extractNumbersFromString, extractNumbersFromString as parseNumbersFromText, extractURLs, extractUpdatedAndNewFields, extractUpdatedFields, getFactors as factorsOf, getFactors as getDivisors, getFactors, fibonacciGenerator, fibonacciGenerator as generateFibonacci, filterArrayOfObjects, findPrimeNumbers, findPrimeNumbers as getPrimeNumbers, flattenArray, flattenObjectDotNotation, flattenObjectKeyValue, formatUnitWithPlural as formatNumberWithPluralUnit, formatUnitWithPlural, formatUnitWithPlural as formatWithPlural, generateAnagrams, generateRandomID, getCharacterDifferences, getClassDetails, getCountryByPhone, getFibonacciSeries as getFibonacci, getFibonacciSeries as getFibonacciNumbers, getFibonacciSeries, getFibonacciSeriesMemo, getFibonacciSeriesMemo as getMemoizedFibonacci, getFibonacciSeriesMemo as getMemoizedFibonacciSeries, getInstanceGetterNames, getInstanceMethodNames, getLastArrayElement, getLevenshteinDistance, getLevenshteinDistance as levenshteinDistance, getNthFibonacci, getNumbersInRange, getRandomFloat as getRandomDecimal, getRandomFloat, getRandomNumber as getRandomInt, getRandomNumber, getStaticGetterNames, getStaticMethodNames, sumNumbers as getSumOfNumbers, sumNumbers, sumNumbers as sumOfNumbers, groupAndAverageByField, groupAndAverageByField as groupAndAvgByField, groupAndSumByField, splitArrayByProperty as groupArrayByProperty, splitArrayByProperty, isDeepEqual, isInvalidOrEmptyArray, isInvalidOrEmptyArray as isValidEmptyArray, isPrime, isPrime as isPrimeNumber, maskString, mergeAndFlattenObjects, mergeObjects, moveArrayElement, normalizeNumber, normalizeString, parseJSON, parseJSON as parseJsonDeep, parseJsonToObject, parseObjectValues, parseObjectValues as parseStringifiedObjectValues, pickFields, pickFields as pickObjectFields, pickObjectFieldsByCondition as pickFieldsByCondition, pickObjectFieldsByCondition, remapFields, remapFields as remapObjectFields, removeDuplicatesFromArray as removeDuplicates, removeDuplicatesFromArray, replaceAllInString, reverseNumber, reverseString, rotateArray, roundNumber, roundNumber as roundToDecimal, roundToNearest as roundNumberToNearestInterval, roundToNearest, roundToNearest as roundToNearestInterval, sanitizeData, shuffleArray, slugifyString, sortAnArray, splitArray, stableStringify, stripJsonEdgeGarbage, sumByField, sumDigits, sumFieldDifference, sumFieldDifference as totalDeltaByField, throttleAction, trimString, truncateString };