toolbox-x 1.2.1 → 2.0.1

package/dist/{basics-1_M7UvCn.mjs → basics-CebgkY-n.mjs}

@@ -14,9 +14,433 @@
  * limitations under the License.
  */
 
-import { a as isNonEmptyString, d as isString } from "./primitives-Djsevc69.mjs";
-import { E as isObjectWithKeys, c as isHexString, m as isUUID } from "./specials-Cye93-uo.mjs";
+import { a as isNonEmptyString, c as isNumber, d as isString, m as isUndefined, n as isBoolean, u as isPrimitive } from "./primitives-Djsevc69.mjs";
+import { C as isMethodDescriptor, E as isObjectWithKeys, T as isObject, b as isFunction, c as isHexString, d as isNumericString, g as isArrayOfType, h as isArray, j as isValidArray, m as isUUID, w as isNotEmptyObject } from "./specials-Hq5Ncd6y.mjs";
+import { a as normalizeNumber } from "./utilities-DPscNbS1.mjs";
+import { t as isDateLike } from "./guards-BK1QuvFZ.mjs";
 
+//#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 (isNotEmptyObject(obj)) return path?.split(".").reduce((acc, key) => {
+		if (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 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 && isString(aChunk) && isString(bChunk)) {
+			aChunk = aChunk?.toLowerCase();
+			bChunk = bChunk?.toLowerCase();
+		}
+		if (typeof aChunk !== typeof bChunk) return isString(aChunk) ? 1 : -1;
+		if (aChunk !== bChunk) {
+			if (isNumber(aChunk) && isNumber(bChunk)) return aChunk - bChunk;
+			if (isString(aChunk) && 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 (!isValidArray(array)) return array;
+	if (isArrayOfType(array, isString)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? naturalSort(b, a) : naturalSort(a, b));
+	if (isArrayOfType(array, isNumber)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? b - a : a - b);
+	if (isArrayOfType(array, isBoolean)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? Number(b) - Number(a) : Number(a) - Number(b));
+	if (isArrayOfType(array, 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 (isString(keyA) && isString(keyB)) return options?.sortOrder === "desc" ? naturalSort(keyB, keyA) : naturalSort(keyA, keyB);
+		if (isNumber(keyA) && isNumber(keyB)) return options?.sortOrder === "desc" ? keyB - keyA : keyA - keyB;
+		if (isBoolean(keyA) && 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 (isArray(a) && isArray(b)) {
+		if (a?.length !== b?.length) return false;
+		return a?.every((element, index) => isDeepEqual(element, b?.[index]));
+	}
+	if (isObject(a) && 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 (!isValidArray(array)) return "";
+	const { separator = ", " } = options ?? {};
+	if (isArrayOfType(array, isPrimitive)) return array?.join(separator);
+	else if (isArrayOfType(array, 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 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]) => 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 (isNotEmptyObject(obj)) return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k, _replacer) + ":" + (isDateLike(obj[k]) ? JSON.stringify(obj[k]) : stableStringify(obj[k]))).join(",") + "}";
+	if (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 (!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 (isObject(input)) {
+		const result = {};
+		for (const [key, value] of Object.entries(input)) result[key] = deepParsePrimitives(value);
+		return result;
+	}
+	if (isString(input)) {
+		if (/^(true|false)$/i.test(input)) return input?.toLowerCase() === "true";
+		if (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 (!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 (!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.
@@ -1317,4 +1750,4 @@ function trimString(input) {
 }
 
 //#endregion
-export { uint8To32ArrayBE as A, bytesToUtf8 as C, intTo4BytesBE as D, hmacSha256 as E, randomHex as O, bytesToHex as S, hexToBytes as T, _constantTimeEquals as _, isUUIDv1 as a, base64ToBytes as b, isUUIDv4 as c, isUUIDv7 as d, isUUIDv8 as f, sha256 as g, sha1 as h, decodeUUID as i, utf8ToBytes as j, sha256Bytes as k, isUUIDv5 as l, md5 as m, trimString as n, isUUIDv2 as o, uuid as p, truncateString as r, isUUIDv3 as s, generateRandomID as t, isUUIDv6 as u, _padStartWith0 as v, concatBytes as w, bytesToBase64 as x, _splitByCharLength as y };
+export { uint8To32ArrayBE as A, getInstanceMethodNames as B, bytesToUtf8 as C, intTo4BytesBE as D, hmacSha256 as E, debounceAction as F, stableStringify as G, getStaticMethodNames as H, deepParsePrimitives as I, naturalSort as J, stripJsonEdgeGarbage as K, definePrototypeMethod as L, convertArrayToString as M, countInstanceMethods as N, randomHex as O, countStaticMethods as P, getClassDetails as R, bytesToHex as S, hexToBytes as T, isDeepEqual as U, getStaticGetterNames as V, parseJSON as W, _getNumericProp as X, sortAnArray as Y, _resolveNestedKey as Z, _constantTimeEquals as _, isUUIDv1 as a, base64ToBytes as b, isUUIDv4 as c, isUUIDv7 as d, isUUIDv8 as f, sha256 as g, sha1 as h, decodeUUID as i, utf8ToBytes as j, sha256Bytes as k, isUUIDv5 as l, md5 as m, trimString as n, isUUIDv2 as o, uuid as p, throttleAction as q, truncateString as r, isUUIDv3 as s, generateRandomID as t, isUUIDv6 as u, _padStartWith0 as v, concatBytes as w, bytesToBase64 as x, _splitByCharLength as y, getInstanceGetterNames as z };

package/dist/{case-uKFzt5TY.cjs → case-Bd7QLHYw.cjs}

@@ -132,11 +132,11 @@ function convertStringCase(value, format, options) {
 			return start.concat(body, end);
 		}
 		case "snake_case": {
-			const body = tokens.map((token) => lowerCase(token)).join("_");
+			const body = tokens.map(lowerCase).join("_");
 			return start.concat(body, end);
 		}
 		case "kebab-case": {
-			const body = tokens.map((token) => lowerCase(token)).join("-");
+			const body = tokens.map(lowerCase).join("-");
 			return start.concat(body, end);
 		}
 		case "Title Case": {
@@ -195,7 +195,7 @@ function _getDelimiterRegex(delims) {
 /** Normalizes delimiters + splits the string */
 function _normalizeDelimiters(str, delims) {
 	const delRegExp = _getDelimiterRegex(delims);
-	return str.replace(/(\p{Ll}?\d+|(?<=\p{Lu}))(\p{Lu})/gu, "$1 $2").replace(delRegExp, " ").replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+	return str.replace(/(\p{Ll}?\d+|(?<=\p{Lu}|\p{Ll}))(\p{Lu})/gu, "$1 $2").replace(delRegExp, " ").replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
 }
 /** Capitalize a string (first letter capital, rest lowercase) */
 function _capitalize(str) {

package/dist/{case-KdrBKjjK.d.mts → case-Bkkm6Mqi.d.mts}

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { B as TitleCase, I as SentenceCase, L as SnakeCase, M as PascalSnakeCase, N as PathCase, T as DotCase, V as TrainCase, f as CamelCase, g as ConstantCase, j as PascalCase, k as KebabCase, m as CaseFormat, p as CapitalizeOptions, z as StringCaseOptions } from "./string-CkwTVFeL.mjs";
+import { A as KebabCase, B as StringCaseOptions, E as DotCase, H as TrainCase, L as SentenceCase, M as PascalCase, N as PascalSnakeCase, P as PathCase, R as SnakeCase, V as TitleCase, _ as ConstantCase, h as CaseFormat, m as CapitalizeOptions, p as CamelCase, u as $WidenEmpty } from "./string-_1ImwUJT.mjs";
 
 //#region src/string/case.d.ts
 /**
@@ -124,7 +124,7 @@ declare function capitalizeString(string: string, options?: CapitalizeOptions):
  * @param del Additional delimiter characters to recognize.
  * @returns The `camelCase` formatted string.
  */
-declare function toCamelCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): CamelCase<Str, Del>;
+declare function toCamelCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<CamelCase<Str, Del>>;
 /**
  * * Converts a string into `PascalCase`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -145,7 +145,7 @@ declare function toCamelCase<Str extends string, Del extends string = ''>(str: S
  * @param del Additional delimiter characters to recognize.
  * @returns The `PascalCase` formatted string.
  */
-declare function toPascalCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): PascalCase<Str, Del>;
+declare function toPascalCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<PascalCase<Str, Del>>;
 /**
  * * Converts a string into `snake_case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -165,7 +165,7 @@ declare function toPascalCase<Str extends string, Del extends string = ''>(str:
  * @param del Additional delimiter characters to recognize.
  * @returns The `snake_case` formatted string.
  */
-declare function toSnakeCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): SnakeCase<Str, Del>;
+declare function toSnakeCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<SnakeCase<Str, Del>>;
 /**
  * * Converts a string into `kebab-case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -185,7 +185,7 @@ declare function toSnakeCase<Str extends string, Del extends string = ''>(str: S
  * @param del Additional delimiter characters to recognize.
  * @returns The `kebab-case` formatted string.
  */
-declare function toKebabCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): KebabCase<Str, Del>;
+declare function toKebabCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<KebabCase<Str, Del>>;
 /**
  * * Converts a string into `Train-Case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -204,7 +204,7 @@ declare function toKebabCase<Str extends string, Del extends string = ''>(str: S
  * @param del Additional delimiter characters to recognize.
  * @returns The `Train-Case` formatted string.
  */
-declare function toTrainCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): TrainCase<Str, Del>;
+declare function toTrainCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<TrainCase<Str, Del>>;
 /**
  * * Converts a string into `dot.case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -223,7 +223,7 @@ declare function toTrainCase<Str extends string, Del extends string = ''>(str: S
  * @param del Additional delimiter characters to recognize.
  * @returns The `dot.case` formatted string.
  */
-declare function toDotCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): DotCase<Str, Del>;
+declare function toDotCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<DotCase<Str, Del>>;
 /**
  * * Converts a string into `path/case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -242,7 +242,7 @@ declare function toDotCase<Str extends string, Del extends string = ''>(str: Str
  * @param del Additional delimiter characters to recognize.
  * @returns The `path/case` formatted string.
  */
-declare function toPathCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): PathCase<Str, Del>;
+declare function toPathCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<PathCase<Str, Del>>;
 /**
  * * Converts a string into `CONSTANT_CASE`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -261,7 +261,7 @@ declare function toPathCase<Str extends string, Del extends string = ''>(str: St
  * @param del Additional delimiter characters to recognize.
  * @returns The `CONSTANT_CASE` formatted string.
  */
-declare function toConstantCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): ConstantCase<Str, Del>;
+declare function toConstantCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<ConstantCase<Str, Del>>;
 /**
  * * Converts a string into `Pascal_Snake_Case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -280,7 +280,7 @@ declare function toConstantCase<Str extends string, Del extends string = ''>(str
  * @param del Additional delimiter characters to recognize.
  * @returns The `Pascal_Snake_Case` formatted string.
  */
-declare function toPascalSnakeCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): PascalSnakeCase<Str, Del>;
+declare function toPascalSnakeCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<PascalSnakeCase<Str, Del>>;
 /**
  * * Converts a string into `Title Case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -301,7 +301,7 @@ declare function toPascalSnakeCase<Str extends string, Del extends string = ''>(
  * @param del Additional delimiter characters to recognize.
  * @returns The `Title Case` formatted string.
  */
-declare function toTitleCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): TitleCase<Str, Del>;
+declare function toTitleCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<TitleCase<Str, Del>>;
 /**
  * * Converts a string into `Sentence case`, using the optional custom delimiters in addition to the default delimiters.
  *
@@ -322,6 +322,6 @@ declare function toTitleCase<Str extends string, Del extends string = ''>(str: S
  * @param del Additional delimiter characters to recognize.
  * @returns The `Sentence case` formatted string.
  */
-declare function toSentenceCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): SentenceCase<Str, Del>;
+declare function toSentenceCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): $WidenEmpty<SentenceCase<Str, Del>>;
 //#endregion
 export { toDotCase as a, toPascalSnakeCase as c, toSnakeCase as d, toTitleCase as f, toConstantCase as i, toPathCase as l, convertStringCase as n, toKebabCase as o, toTrainCase as p, toCamelCase as r, toPascalCase as s, capitalizeString as t, toSentenceCase as u };