toolbox-x 1.2.1 → 2.0.0

package/dist/{basics-K8BDSYD6.cjs → basics-CJmdhXoo.cjs}

@@ -15,8 +15,432 @@
  */
 
 const require_primitives = require('./primitives-CBGICrDR.cjs');
-const require_specials = require('./specials-BM6cx43o.cjs');
+const require_specials = require('./specials-dkYP1Nh2.cjs');
+const require_utilities = require('./utilities-CWV1GPGY.cjs');
+const require_guards = require('./guards-Bsh6Bfdq.cjs');
 
+//#region src/array/helpers.ts
+/**
+* Safely resolves value of nested key (dot-notation key like `"user.city"`).
+*
+* @param obj - The source object
+* @param path - The nested path string (e.g. `"user.city"`)
+* @returns The resolved value or `undefined`
+*/
+function _resolveNestedKey(obj, path) {
+	if (require_specials.isNotEmptyObject(obj)) return path?.split(".").reduce((acc, key) => {
+		if (require_specials.isNotEmptyObject(acc)) return acc[key];
+	}, obj);
+}
+/**
+* Retrieves a numeric value from a nested property (dot-notation key like 'user.income.tax').
+* Falls back to 0 if value is not a number or numeric string.
+*
+* @param obj - The source object to read from.
+* @param path - The dot-notation path string like 'user.income.tax'.
+* @returns The numeric value at that path, or 0 if	 not valid.
+*/
+function _getNumericProp(obj, path) {
+	return require_utilities.normalizeNumber(_resolveNestedKey(obj, path)) ?? 0;
+}
+
+//#endregion
+//#region src/array/sort.ts
+/**
+* Compare two strings using natural sorting (e.g., `"file2"` < `"file10"`).
+* - Optionally supports case-insensitive and locale-aware string chunk comparisons.
+*
+* @param a - The first string to compare.
+* @param b - The second string to compare.
+* @param options - Optional settings to configure comparison behavior.
+* @returns A negative number if `a` comes before `b`, a positive number if `a` comes after `b`, or 0 if equal.
+*/
+function naturalSort(a, b, options) {
+	const { caseInsensitive = true, localeAware = false } = options || {};
+	/**
+	* * Splits a string into an array of number and non-number chunks.
+	* @param str - The string to split.
+	* @returns An array of string and number parts.
+	*/
+	const _createChunks = (str) => {
+		const chunks = [];
+		let current = "";
+		let isNumeric = false;
+		for (const char of str) {
+			const charIsNum = !Number.isNaN(Number(char));
+			if (current?.length === 0) {
+				current = char;
+				isNumeric = charIsNum;
+				continue;
+			}
+			if (charIsNum === isNumeric) current += char;
+			else {
+				chunks?.push(isNumeric ? Number(current) : current);
+				current = char;
+				isNumeric = charIsNum;
+			}
+		}
+		if (current?.length > 0) chunks?.push(isNumeric ? Number(current) : current);
+		return chunks;
+	};
+	const aChunks = _createChunks(a);
+	const bChunks = _createChunks(b);
+	for (let i = 0; i < Math.min(aChunks?.length, bChunks?.length); i++) {
+		let aChunk = aChunks[i];
+		let bChunk = bChunks[i];
+		if (caseInsensitive && require_primitives.isString(aChunk) && require_primitives.isString(bChunk)) {
+			aChunk = aChunk?.toLowerCase();
+			bChunk = bChunk?.toLowerCase();
+		}
+		if (typeof aChunk !== typeof bChunk) return require_primitives.isString(aChunk) ? 1 : -1;
+		if (aChunk !== bChunk) {
+			if (require_primitives.isNumber(aChunk) && require_primitives.isNumber(bChunk)) return aChunk - bChunk;
+			if (require_primitives.isString(aChunk) && require_primitives.isString(bChunk)) {
+				if (localeAware) {
+					const cmp = aChunk.localeCompare(bChunk, void 0, { sensitivity: caseInsensitive ? "accent" : "variant" });
+					if (cmp !== 0) return cmp;
+				}
+				return aChunk < bChunk ? -1 : 1;
+			}
+		}
+	}
+	return aChunks?.length - bChunks?.length;
+}
+/**
+* * Sorts an array of strings, numbers, booleans, or objects based on the provided options.
+*
+* @param array - The array to sort.
+* @param options - Sorting options.
+* @returns The sorted array.
+*/
+function sortAnArray(array, options) {
+	if (!require_specials.isValidArray(array)) return array;
+	if (require_specials.isArrayOfType(array, require_primitives.isString)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? naturalSort(b, a) : naturalSort(a, b));
+	if (require_specials.isArrayOfType(array, require_primitives.isNumber)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? b - a : a - b);
+	if (require_specials.isArrayOfType(array, require_primitives.isBoolean)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? Number(b) - Number(a) : Number(a) - Number(b));
+	if (require_specials.isArrayOfType(array, require_specials.isObject) && options && "sortByField" in options) return [...array].sort((a, b) => {
+		const _getKeyValue = (obj, path) => {
+			return path.split(".").reduce((acc, key) => acc?.[key], obj);
+		};
+		const keyA = _getKeyValue(a, options?.sortByField);
+		const keyB = _getKeyValue(b, options?.sortByField);
+		if (keyA == null || keyB == null) return keyA == null ? 1 : -1;
+		if (require_primitives.isString(keyA) && require_primitives.isString(keyB)) return options?.sortOrder === "desc" ? naturalSort(keyB, keyA) : naturalSort(keyA, keyB);
+		if (require_primitives.isNumber(keyA) && require_primitives.isNumber(keyB)) return options?.sortOrder === "desc" ? keyB - keyA : keyA - keyB;
+		if (require_primitives.isBoolean(keyA) && require_primitives.isBoolean(keyB)) return options?.sortOrder === "desc" ? Number(keyB) - Number(keyA) : Number(keyA) - Number(keyB);
+		return 0;
+	});
+	return [...array];
+}
+
+//#endregion
+//#region src/utils/index.ts
+/**
+* * Deeply compare two values (arrays, objects, or primitive values).
+*
+* @param a First value to compare.
+* @param b Second value to compare.
+* @returns Whether the values are deeply equal.
+*/
+const isDeepEqual = (a, b) => {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (a === null || b === null) return a === b;
+	if (require_specials.isArray(a) && require_specials.isArray(b)) {
+		if (a?.length !== b?.length) return false;
+		return a?.every((element, index) => isDeepEqual(element, b?.[index]));
+	}
+	if (require_specials.isObject(a) && require_specials.isObject(b)) {
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		if (aKeys?.length !== bKeys?.length) return false;
+		return aKeys?.every((key) => isDeepEqual(a?.[key], b?.[key]));
+	}
+	return false;
+};
+/**
+* * Converts an array of primitive values or objects to a string using a separator or target key.
+*
+* @param array Array to convert.
+* @param options Options for separator or key extraction from objects.
+* @returns String representation of array values.
+*/
+function convertArrayToString(array, options) {
+	if (!require_specials.isValidArray(array)) return "";
+	const { separator = ", " } = options ?? {};
+	if (require_specials.isArrayOfType(array, require_primitives.isPrimitive)) return array?.join(separator);
+	else if (require_specials.isArrayOfType(array, require_specials.isNotEmptyObject)) if (options && "target" in options) return array?.map((el) => _resolveNestedKey(el, options?.target))?.join(separator);
+	else return "";
+	return "";
+}
+/**
+* * A generic debounce function that delays the execution of a callback.
+*
+* @param callback - The function to debounce.
+* @param delay - The delay in milliseconds. Default is `300ms`.
+* @returns A debounced version of the callback function.
+*
+* @example
+* const debouncedSearch = debounceAction((query: string) => {
+*   console.log(`Searching for: ${query}`);
+* }, 300);
+*
+* debouncedSearch('laptop'); // Executes after 300ms of inactivity.
+*/
+function debounceAction(callback, delay = 300) {
+	let timeoutId;
+	return (...args) => {
+		clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			callback(...args);
+		}, delay);
+	};
+}
+/**
+* * A generic throttle function that ensures a callback is executed at most once per specified interval.
+*
+* @param callback - The function to throttle.
+* @param delay - The delay in milliseconds. Default is `150ms`.
+* @returns A throttled version of the callback function.
+*
+* @example
+* const throttledResize = throttleAction(() => {
+*   console.log('Resized');
+* }, 300);
+*
+* window.addEventListener('resize', throttledResize);
+*/
+function throttleAction(callback, delay = 150) {
+	let lastCall = 0;
+	return (...args) => {
+		const now = Date.now();
+		if (now - lastCall >= delay) {
+			lastCall = now;
+			callback(...args);
+		}
+	};
+}
+/**
+* * Retrieves the names of all instance methods defined directly on a class prototype.
+*
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of instance method names.
+*/
+function getInstanceMethodNames(cls) {
+	const prototype = cls.prototype;
+	return sortAnArray(Object.getOwnPropertyNames(prototype).filter((method) => {
+		if (method === "constructor") return false;
+		return require_specials.isMethodDescriptor(Object.getOwnPropertyDescriptor(prototype, method));
+	}));
+}
+/**
+* * Retrieves the names of all static methods defined directly on a class constructor.
+*
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of static method names.
+*/
+function getStaticMethodNames(cls) {
+	return sortAnArray(Object.getOwnPropertyNames(cls).filter((method) => {
+		return method !== "prototype" && method !== "name" && method !== "length";
+	}));
+}
+/**
+* * Counts the number of instance methods defined directly on a class prototype.
+*
+* @param cls - The class constructor (not an instance).
+* @returns The number of instance methods defined on the class prototype.
+*/
+function countInstanceMethods(cls) {
+	return getInstanceMethodNames(cls)?.length;
+}
+/**
+* * Counts the number of static methods defined directly on a class constructor.
+*
+* @param cls - The class constructor (not an instance).
+* @returns The number of static methods defined on the class constructor.
+*/
+function countStaticMethods(cls) {
+	return getStaticMethodNames(cls)?.length;
+}
+/**
+* * Retrieves the names of all instance getters defined directly on a class prototype.
+*
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of instance getter names.
+*/
+function getInstanceGetterNames(cls) {
+	const descriptors = Object.getOwnPropertyDescriptors(cls.prototype);
+	return sortAnArray(Object.entries(descriptors).filter(([key, desc]) => require_specials.isFunction(desc.get) && key !== "constructor").map(([key]) => key));
+}
+/**
+* * Retrieves the names of all static getters defined directly on a class constructor.
+*
+* @param cls - The class constructor (not an instance).
+* @returns A sorted array of static getter names.
+*/
+function getStaticGetterNames(cls) {
+	return sortAnArray(Object.entries(Object.getOwnPropertyDescriptors(cls)).filter(([key, desc]) => typeof desc.get === "function" && key !== "prototype").map(([key]) => key));
+}
+/**
+* * Gathers detailed information about the instance and static methods of a class.
+*
+* @param cls - The class constructor (not an instance).
+* @returns An object containing names and counts of instance and static methods.
+*/
+function getClassDetails(cls) {
+	const instanceNames = getInstanceMethodNames(cls);
+	const staticNames = getStaticMethodNames(cls);
+	const instanceGetters = getInstanceGetterNames(cls);
+	const staticGetters = getStaticGetterNames(cls);
+	return {
+		instanceMethods: instanceNames,
+		staticMethods: staticNames,
+		instanceGetters,
+		staticGetters,
+		instanceCount: instanceNames?.length,
+		staticCount: staticNames?.length,
+		totalGetters: instanceGetters?.length + staticGetters?.length,
+		totalMethods: instanceNames?.length + staticNames?.length
+	};
+}
+/**
+* * Create a deterministic JSON string representation of any value.
+*   - The output format matches standard JSON but with guaranteed sorted keys.
+*
+* @remarks
+* - This function guarantees **stable, repeatable output** by:
+* 	 - Sorting all object keys alphabetically.
+* 	 - Recursively stabilizing nested objects and arrays.
+* 	 - Converting all `undefined` values into `null` so the output remains valid JSON.
+*   - Converting date-like objects (`Date`, `Chronos`, `Moment.js`, `Day.js`, `Luxon`, `JS-Joda`, `Temporal`) **in the same way that {@link JSON.stringify} would serialize them**, ensuring predictable and JSON-compliant output.
+*   - Falling back to native JSON serialization for primitives.
+*
+* - **Useful for:**
+*   - Hash generation (e.g., signatures, cache keys)
+*   - Deep equality checks
+*   - Producing predictable output across environments
+*
+* @param obj - The value to stringify into a deterministic JSON string.
+* @returns A stable, deterministic string representation of the input.
+*/
+function stableStringify(obj) {
+	const _replacer = (_, v) => v === void 0 ? null : v;
+	if (require_specials.isNotEmptyObject(obj)) return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k, _replacer) + ":" + (require_guards.isDateLike(obj[k]) ? JSON.stringify(obj[k]) : stableStringify(obj[k]))).join(",") + "}";
+	if (require_specials.isValidArray(obj)) return "[" + obj.map((v) => stableStringify(v)).join(",") + "]";
+	return JSON.stringify(obj, _replacer);
+}
+/**
+* * Remove trailing or leading garbage characters **after/before JSON object or array**.
+* @param str String to sanitize/strip.
+* @returns Sanitized/stripped JSON string.
+*/
+function stripJsonEdgeGarbage(str) {
+	if (!require_primitives.isNonEmptyString(str)) return "";
+	const lastIdx = Math.max(str.lastIndexOf("}"), str.lastIndexOf("]"));
+	const _idxOf = (sym) => str.indexOf(sym) !== -1 ? str.indexOf(sym) : Infinity;
+	const firstIdx = Math.min(_idxOf("{"), _idxOf("["));
+	if (lastIdx === -1 || firstIdx === Infinity) return str;
+	return str.slice(firstIdx, lastIdx + 1);
+}
+/**
+* * Parses any valid JSON string, optionally converting stringified primitives inside (nested) arrays or objects.
+*
+* @typeParam T - Expected return type (default is unknown).
+* @param value - The JSON string to parse.
+* @param parsePrimitives - Whether to convert stringified primitives (default: `true`).
+* @returns The parsed JSON value typed as `T`, or the original parsed value with optional primitive conversion.
+* - Returns `{}` if parsing fails, such as when the input is malformed or invalid JSON or passing single quoted string.
+*
+* - *Unlike {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/object/parse-json-to-object parseJsonToObject}, which ensures the root value is an object,
+* this function returns any valid JSON structure such as arrays, strings, numbers, or objects.*
+*
+* This is useful when you're not sure of the root structure of the JSON, or when you expect something other than an object.
+*
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/object/parse-json-to-object parseJsonToObject} for strict object-only parsing.
+*/
+const parseJSON = (value, parsePrimitives = true) => {
+	try {
+		const parsed = JSON.parse(value);
+		return parsePrimitives ? deepParsePrimitives(parsed) : parsed;
+	} catch {
+		return {};
+	}
+};
+/**
+* * Recursively parses primitive values inside objects and arrays.
+*
+* @typeParam T - Expected return type after parsing (default is unknown).
+* @param input - Any input value to parse recursively.
+* @returns Input with primitives (strings like "true", "123") converted, typed as `T`.
+*/
+function deepParsePrimitives(input) {
+	if (Array.isArray(input)) return input?.map(deepParsePrimitives);
+	if (require_specials.isObject(input)) {
+		const result = {};
+		for (const [key, value] of Object.entries(input)) result[key] = deepParsePrimitives(value);
+		return result;
+	}
+	if (require_primitives.isString(input)) {
+		if (/^(true|false)$/i.test(input)) return input?.toLowerCase() === "true";
+		if (require_specials.isNumericString(input)) return Number(input);
+		if (input === "null") return null;
+		if (input === "undefined") return;
+		return input;
+	}
+	return input;
+}
+/**
+* * Defines a method on any prototype — including built-in prototypes — in a safe, idempotent manner.
+* 	 - The method is non-enumerable by default and will not overwrite an existing method unless explicitly allowed.
+*
+* @param proto   The target prototype object (e.g., String.prototype).
+* @param name    The method name to define on the prototype.
+* @param impl    The function implementation for the method.
+* @param options Optional property-descriptor settings and overwrite rules.
+*
+* @example
+* // Safely augment prototype methods by extending the global interface:
+* declare global {
+* 	interface String {
+* 		toBang(): string;
+* 	}
+* }
+*
+* // Define a custom method on String.prototype
+* definePrototypeMethod(String.prototype, 'toBang', function (this: String) {
+* 	return this.toString().concat('!');
+* 	// or
+* 	// return this.concat('!');
+* });
+*
+* "Hi".toBang(); // "Hi!"
+*
+* // Attempting to redefine without overwrite option is ignored
+* definePrototypeMethod(String.prototype, 'toBang', () => 'x'); // ignored
+*
+* // Overwrite intentionally using the overwrite option
+* definePrototypeMethod(
+*   String.prototype,
+*   'toBang',
+*   function (this: String) { return this.concat('!!!'); },
+*   { overwrite: true }
+* );
+*
+* "Hi".toBang(); // "Hi!!!"
+*/
+function definePrototypeMethod(proto, name, impl, options) {
+	if (Object.hasOwn(proto, name) && !options?.overwrite) return;
+	Object.defineProperty(proto, name, {
+		value: function(...args) {
+			return impl.apply(this, args);
+		},
+		enumerable: options?.enumerable ?? false,
+		configurable: options?.configurable ?? false,
+		writable: options?.writable ?? true
+	});
+}
+
+//#endregion
 //#region src/hash/utils.ts
 /**
 * * Generates a random hexadecimal string of the specified length.
@@ -805,13 +1229,22 @@ function _randomNode48() {
 	return (parseInt(node.slice(0, 2).join(""), 16) | 1).toString(16).padStart(2, "0") + node.slice(2).join("");
 }
 /**
-* Generates random hex string of given byte length using crypto API if available, otherwise falls back to Math.random.
+* Fills the given {@link Uint8Array} with random values using crypto API if available, otherwise falls back to {@link Math.random}.
 * @param bytes Instance of {@link Uint8Array} to fill with random values.
-* @returns Hex string representation of the random bytes.
+* @returns Random bytes. It also mutates the {@link bytes} argument.
 */
-function _bytesToRandomHex(bytes) {
-	if (crypto?.getRandomValues) crypto.getRandomValues(bytes);
+function _fillWithRandomValues(bytes) {
+	if (!require_primitives.isUndefined(crypto) && crypto?.getRandomValues) crypto.getRandomValues(bytes);
 	else for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+	return bytes;
+}
+/**
+* Generates random hex string of given byte length using crypto API if available, otherwise falls back to {@link Math.random}.
+* @param bytes Instance of {@link Uint8Array} to fill with random values.
+* @returns Hex string representation of the random bytes. It also mutates the {@link bytes} argument.
+*/
+function _bytesToRandomHex(bytes) {
+	_fillWithRandomValues(bytes);
 	let hex = "";
 	for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
 	return hex;
@@ -1031,9 +1464,9 @@ function sha1(msg) {
 * // Returns: '7037e204b825b83553ba336a6ec35b796d505599286ae864729ed6cb33ae9fe1'
 * ```
 *
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utilities/hash/encoding#sha256bytes sha256Bytes} for hashing raw bytes
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utilities/hash/encoding#utf8tobytes utf8ToBytes} for converting string to bytes
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utilities/hash/encoding#bytestohex bytesToHex} for converting bytes to a hexadecimal string
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/encoding#sha256bytes sha256Bytes} for hashing raw bytes
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/encoding#utf8tobytes utf8ToBytes} for converting string to bytes
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/encoding#bytestohex bytesToHex} for converting bytes to a hexadecimal string
 */
 function sha256(msg) {
 	if (!require_primitives.isString(msg)) throw new TypeError("Input must be of type string!");
@@ -1087,7 +1520,7 @@ function sha256(msg) {
 *   - `v7`: Millisecond precision; extremely high throughput may still cause rare collisions.
 *   - `v8`: Uses a simple timestamp + randomness layout; custom layouts are not supported here.
 *
-* - Use {@link https://toolbox-x.nazmul-nhb.dev/docs/utilities/string/generateRandomID generateRandomID} for customized id generation or {@link https://toolbox-x.nazmul-nhb.dev/docs/utilities/hash/randomHex randomHex} for hex-only random string with custom length.
+* - Use {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/string/generate-random-id generateRandomID} for customized id generation or {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/random-hex randomHex} for hex-only random string with custom length.
 */
 function uuid(options) {
 	const { version = "v4", uppercase = false } = options || {};
@@ -1242,8 +1675,8 @@ function truncateString(str, maxLength) {
 * @param options Configuration options for random ID generation.
 * @returns The generated ID string composed of the random alphanumeric string of specified length with optional `timeStamp`, `prefix`, and `suffix`, `caseOption` and `separator`.
 *
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utilities/hash/uuid uuid} for `uuid` generation
-* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utilities/hash/randomHex randomHex} for random hexadecimal string generation
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/uuid uuid} for `uuid` generation
+* @see {@link https://toolbox-x.nazmul-nhb.dev/docs/utils/hash/random-hex randomHex} for random hexadecimal string generation
 *
 * @example
 * // Generate an ID with all default options
@@ -1292,10 +1725,10 @@ function generateRandomID(options) {
 	const date = timeStamp ? Date.now() : "";
 	const randomString = Array.from({ length }, () => Math.random().toString(36).slice(2, 3)).join("");
 	const ID = [
-		prefix && prefix.trim(),
+		prefix?.trim(),
 		date,
 		randomString,
-		suffix && suffix.trim()
+		suffix?.trim()
 	].filter(Boolean).join(separator);
 	switch (caseOption) {
 		case "upper": return ID.toUpperCase();
@@ -1304,7 +1737,7 @@ function generateRandomID(options) {
 	}
 }
 /**
-* * Trims all the words in a string or an array of strings.
+* * Trims all whitespaces in a string or an array of strings.
 *
 * @param input String or array of strings.
 * @returns Trimmed string or array of strings.
@@ -1323,12 +1756,24 @@ Object.defineProperty(exports, '_constantTimeEquals', {
     return _constantTimeEquals;
   }
 });
+Object.defineProperty(exports, '_getNumericProp', {
+  enumerable: true,
+  get: function () {
+    return _getNumericProp;
+  }
+});
 Object.defineProperty(exports, '_padStartWith0', {
   enumerable: true,
   get: function () {
     return _padStartWith0;
   }
 });
+Object.defineProperty(exports, '_resolveNestedKey', {
+  enumerable: true,
+  get: function () {
+    return _resolveNestedKey;
+  }
+});
 Object.defineProperty(exports, '_splitByCharLength', {
   enumerable: true,
   get: function () {
@@ -1365,18 +1810,84 @@ Object.defineProperty(exports, 'concatBytes', {
     return concatBytes;
   }
 });
+Object.defineProperty(exports, 'convertArrayToString', {
+  enumerable: true,
+  get: function () {
+    return convertArrayToString;
+  }
+});
+Object.defineProperty(exports, 'countInstanceMethods', {
+  enumerable: true,
+  get: function () {
+    return countInstanceMethods;
+  }
+});
+Object.defineProperty(exports, 'countStaticMethods', {
+  enumerable: true,
+  get: function () {
+    return countStaticMethods;
+  }
+});
+Object.defineProperty(exports, 'debounceAction', {
+  enumerable: true,
+  get: function () {
+    return debounceAction;
+  }
+});
 Object.defineProperty(exports, 'decodeUUID', {
   enumerable: true,
   get: function () {
     return decodeUUID;
   }
 });
+Object.defineProperty(exports, 'deepParsePrimitives', {
+  enumerable: true,
+  get: function () {
+    return deepParsePrimitives;
+  }
+});
+Object.defineProperty(exports, 'definePrototypeMethod', {
+  enumerable: true,
+  get: function () {
+    return definePrototypeMethod;
+  }
+});
 Object.defineProperty(exports, 'generateRandomID', {
   enumerable: true,
   get: function () {
     return generateRandomID;
   }
 });
+Object.defineProperty(exports, 'getClassDetails', {
+  enumerable: true,
+  get: function () {
+    return getClassDetails;
+  }
+});
+Object.defineProperty(exports, 'getInstanceGetterNames', {
+  enumerable: true,
+  get: function () {
+    return getInstanceGetterNames;
+  }
+});
+Object.defineProperty(exports, 'getInstanceMethodNames', {
+  enumerable: true,
+  get: function () {
+    return getInstanceMethodNames;
+  }
+});
+Object.defineProperty(exports, 'getStaticGetterNames', {
+  enumerable: true,
+  get: function () {
+    return getStaticGetterNames;
+  }
+});
+Object.defineProperty(exports, 'getStaticMethodNames', {
+  enumerable: true,
+  get: function () {
+    return getStaticMethodNames;
+  }
+});
 Object.defineProperty(exports, 'hexToBytes', {
   enumerable: true,
   get: function () {
@@ -1395,6 +1906,12 @@ Object.defineProperty(exports, 'intTo4BytesBE', {
     return intTo4BytesBE;
   }
 });
+Object.defineProperty(exports, 'isDeepEqual', {
+  enumerable: true,
+  get: function () {
+    return isDeepEqual;
+  }
+});
 Object.defineProperty(exports, 'isUUIDv1', {
   enumerable: true,
   get: function () {
@@ -1449,6 +1966,18 @@ Object.defineProperty(exports, 'md5', {
     return md5;
   }
 });
+Object.defineProperty(exports, 'naturalSort', {
+  enumerable: true,
+  get: function () {
+    return naturalSort;
+  }
+});
+Object.defineProperty(exports, 'parseJSON', {
+  enumerable: true,
+  get: function () {
+    return parseJSON;
+  }
+});
 Object.defineProperty(exports, 'randomHex', {
   enumerable: true,
   get: function () {
@@ -1473,6 +2002,30 @@ Object.defineProperty(exports, 'sha256Bytes', {
     return sha256Bytes;
   }
 });
+Object.defineProperty(exports, 'sortAnArray', {
+  enumerable: true,
+  get: function () {
+    return sortAnArray;
+  }
+});
+Object.defineProperty(exports, 'stableStringify', {
+  enumerable: true,
+  get: function () {
+    return stableStringify;
+  }
+});
+Object.defineProperty(exports, 'stripJsonEdgeGarbage', {
+  enumerable: true,
+  get: function () {
+    return stripJsonEdgeGarbage;
+  }
+});
+Object.defineProperty(exports, 'throttleAction', {
+  enumerable: true,
+  get: function () {
+    return throttleAction;
+  }
+});
 Object.defineProperty(exports, 'trimString', {
   enumerable: true,
   get: function () {