@xxanderwp/jstoolkit 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1459 @@
+import md5 from 'md5';
+
+/**
+ * Generate a random string of specified length
+ * @param length - Length of the string to generate
+ * @param characters - Characters to use (default: alphanumeric)
+ * @returns Random string
+ */
+function randomString(length, characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
+    let result = '';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+/**
+ * Truncate a string to a specified length and add ellipsis
+ * @param str - String to truncate
+ * @param maxLength - Maximum length
+ * @param ellipsis - Ellipsis string (default: '...')
+ * @returns Truncated string
+ */
+function truncate(str, maxLength, ellipsis = '...') {
+    if (str.length <= maxLength)
+        return str;
+    return str.slice(0, maxLength - ellipsis.length) + ellipsis;
+}
+/**
+ * Capitalize the first letter of a string
+ * @param str - String to capitalize
+ * @returns Capitalized string
+ */
+function capitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Convert string to camelCase
+ * @param str - String to convert
+ * @returns camelCase string
+ */
+function toCamelCase(str) {
+    return str
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+/**
+ * Convert string to snake_case
+ * @param str - String to convert
+ * @returns snake_case string
+ */
+function toSnakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '');
+}
+/**
+ * Convert string to kebab-case
+ * @param str - String to convert
+ * @returns kebab-case string
+ */
+function toKebabCase(str) {
+    return str
+        .replace(/([A-Z])/g, '-$1')
+        .toLowerCase()
+        .replace(/^-/, '');
+}
+/**
+ * Remove all whitespace from a string
+ * @param str - String to process
+ * @returns String without whitespace
+ */
+function removeWhitespace(str) {
+    return str.replace(/\s+/g, '');
+}
+/**
+ * Count occurrences of a substring in a string
+ * @param str - String to search in
+ * @param substring - Substring to count
+ * @returns Number of occurrences
+ */
+function countOccurrences(str, substring) {
+    if (!substring)
+        return 0;
+    return (str.match(new RegExp(substring, 'g')) || []).length;
+}
+
+var string = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    capitalize: capitalize,
+    countOccurrences: countOccurrences,
+    randomString: randomString,
+    removeWhitespace: removeWhitespace,
+    toCamelCase: toCamelCase,
+    toKebabCase: toKebabCase,
+    toSnakeCase: toSnakeCase,
+    truncate: truncate
+});
+
+/**
+ * Get a random element from an array
+ * @param arr - Array to pick from
+ * @returns Random element
+ */
+function randomElement(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+/**
+ * Get a random index from an array
+ * @param arr - Array to pick from
+ * @returns Random index
+ */
+function randomElementIndex(arr) {
+    return Math.floor(Math.random() * arr.length);
+}
+/**
+ * Shuffle an array using Fisher-Yates algorithm
+ * @param arr - Array to shuffle
+ * @returns Shuffled array (new array)
+ */
+function shuffle(arr) {
+    const result = [...arr];
+    for (let i = result.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}
+/**
+ * Split an array into chunks of specified size
+ * @param array - Array to chunk
+ * @param size - Size of each chunk
+ * @returns Array of chunks
+ */
+function chunk(array, size) {
+    const result = [];
+    for (let i = 0; i < array.length; i += size) {
+        result.push(array.slice(i, i + size));
+    }
+    return result;
+}
+/**
+ * Remove duplicate values from an array
+ * @param arr - Array to deduplicate
+ * @returns Array without duplicates
+ */
+function unique(arr) {
+    return [...new Set(arr)];
+}
+/**
+ * Get the intersection of two arrays
+ * @param arr1 - First array
+ * @param arr2 - Second array
+ * @returns Intersection array
+ */
+function intersection(arr1, arr2) {
+    const set2 = new Set(arr2);
+    return arr1.filter((item) => set2.has(item));
+}
+/**
+ * Get the difference of two arrays (elements in arr1 but not in arr2)
+ * @param arr1 - First array
+ * @param arr2 - Second array
+ * @returns Difference array
+ */
+function difference(arr1, arr2) {
+    const set2 = new Set(arr2);
+    return arr1.filter((item) => !set2.has(item));
+}
+/**
+ * Sort array in ascending or descending order
+ * @param array - Array to sort
+ * @param order - Sort order ('ASC' or 'DESC')
+ * @returns Sorted array
+ */
+function sort(array, order = 'ASC') {
+    return [...array].sort((a, b) => {
+        if (order === 'ASC') {
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
+        else {
+            return a < b ? 1 : a > b ? -1 : 0;
+        }
+    });
+}
+/**
+ * Sort array of objects by multiple properties
+ * @param array - Array to sort
+ * @param params - Sort parameters
+ * @returns Sorted array
+ */
+function sortBy(array, params) {
+    return [...array].sort((a, b) => {
+        for (const param of params) {
+            const aVal = a[param.key];
+            const bVal = b[param.key];
+            let result = 0;
+            if (param.order === 'ASC') {
+                result = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+            }
+            else {
+                result = aVal < bVal ? 1 : aVal > bVal ? -1 : 0;
+            }
+            if (result !== 0)
+                return result;
+        }
+        return 0;
+    });
+}
+/**
+ * Sort array items by key order priority
+ * @param items - Array to sort
+ * @param keyOrder - Priority order of keys
+ * @returns Sorted array
+ */
+function sortByKeys(items, keyOrder) {
+    const keyOrderMap = new Map(keyOrder.map((key, index) => [key, index]));
+    return [...items].sort((a, b) => {
+        let orderA = keyOrder.length;
+        let orderB = keyOrder.length;
+        for (const [key, index] of keyOrderMap) {
+            if (a.startsWith(key)) {
+                orderA = index;
+                break;
+            }
+        }
+        for (const [key, index] of keyOrderMap) {
+            if (b.startsWith(key)) {
+                orderB = index;
+                break;
+            }
+        }
+        return orderA - orderB;
+    });
+}
+/**
+ * Group array elements by a key function
+ * @param arr - Array to group
+ * @param keyFn - Function that returns the group key
+ * @returns Object with grouped elements
+ */
+function groupBy(arr, keyFn) {
+    return arr.reduce((result, item) => {
+        const key = keyFn(item);
+        if (!result[key]) {
+            result[key] = [];
+        }
+        result[key].push(item);
+        return result;
+    }, {});
+}
+/**
+ * Flatten nested arrays to specified depth
+ * @param arr - Array to flatten
+ * @param depth - Depth to flatten (default: 1)
+ * @returns Flattened array
+ */
+function flatten$1(arr, depth = 1) {
+    if (depth === 0)
+        return arr;
+    return arr.reduce((acc, val) => {
+        return acc.concat(Array.isArray(val) ? flatten$1(val, depth - 1) : val);
+    }, []);
+}
+
+var array = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    chunk: chunk,
+    difference: difference,
+    flatten: flatten$1,
+    groupBy: groupBy,
+    intersection: intersection,
+    randomElement: randomElement,
+    randomElementIndex: randomElementIndex,
+    shuffle: shuffle,
+    sort: sort,
+    sortBy: sortBy,
+    sortByKeys: sortByKeys,
+    unique: unique
+});
+
+/**
+ * Generate a random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ */
+function randomInt$1(min, max) {
+    if (max < min) {
+        [max, min] = [min, max];
+    }
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * Generate a random float between min and max
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random float
+ */
+function randomFloat$1(min, max) {
+    if (max < min) {
+        [max, min] = [min, max];
+    }
+    return Math.random() * (max - min) + min;
+}
+/**
+ * Round a number to specified decimal places
+ * @param value - Value to round
+ * @param decimals - Number of decimal places
+ * @param mode - Rounding mode ('round' or 'truncate')
+ * @returns Rounded number
+ */
+function round(value, decimals, mode = 'round') {
+    const factor = Math.pow(10, decimals);
+    if (mode === 'truncate') {
+        return Math.trunc(value * factor) / factor;
+    }
+    return Math.round(value * factor) / factor;
+}
+/**
+ * Linear interpolation between two values
+ * @param start - Start value
+ * @param end - End value
+ * @param amount - Interpolation amount (0-1)
+ * @returns Interpolated value
+ */
+function lerp(start, end, amount) {
+    amount = Math.max(0, Math.min(1, amount));
+    return start + (end - start) * amount;
+}
+/**
+ * Linear interpolation between two 2D points
+ * @param point1 - First point
+ * @param point2 - Second point
+ * @param amount - Interpolation amount (0-1)
+ * @returns Interpolated point
+ */
+function lerp2D(point1, point2, amount) {
+    return {
+        x: lerp(point1.x, point2.x, amount),
+        y: lerp(point1.y, point2.y, amount),
+    };
+}
+/**
+ * Linear interpolation between two 3D vectors
+ * @param vec1 - First vector
+ * @param vec2 - Second vector
+ * @param amount - Interpolation amount (0-1)
+ * @returns Interpolated vector
+ */
+function lerp3D(vec1, vec2, amount) {
+    return {
+        x: lerp(vec1.x, vec2.x, amount),
+        y: lerp(vec1.y, vec2.y, amount),
+        z: lerp(vec1.z, vec2.z, amount),
+    };
+}
+/**
+ * Calculate time-based interpolation value
+ * @param start - Start timestamp
+ * @param end - End timestamp
+ * @param current - Current timestamp (default: Date.now())
+ * @returns Interpolation value (0-1)
+ */
+function lerpTime(start, end, current = Date.now()) {
+    const duration = current - start;
+    return Math.max(0, Math.min(1, duration / (end - start)));
+}
+/**
+ * Clamp a value between min and max
+ * @param value - Value to clamp
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Clamped value
+ */
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * Map a value from one range to another
+ * @param value - Value to map
+ * @param inMin - Input range minimum
+ * @param inMax - Input range maximum
+ * @param outMin - Output range minimum
+ * @param outMax - Output range maximum
+ * @returns Mapped value
+ */
+function mapRange(value, inMin, inMax, outMin, outMax) {
+    return ((value - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;
+}
+/**
+ * Calculate percentage
+ * @param value - Value
+ * @param total - Total value
+ * @returns Percentage (0-100)
+ */
+function percentage(value, total) {
+    if (total === 0)
+        return 0;
+    return (value / total) * 100;
+}
+/**
+ * Calculate average of numbers
+ * @param numbers - Array of numbers
+ * @returns Average value
+ */
+function average(numbers) {
+    if (numbers.length === 0)
+        return 0;
+    return numbers.reduce((sum, num) => sum + num, 0) / numbers.length;
+}
+/**
+ * Calculate sum of numbers
+ * @param numbers - Array of numbers
+ * @returns Sum
+ */
+function sum(numbers) {
+    return numbers.reduce((total, num) => total + num, 0);
+}
+/**
+ * Find minimum value in array
+ * @param numbers - Array of numbers
+ * @returns Minimum value
+ */
+function min(numbers) {
+    return Math.min(...numbers);
+}
+/**
+ * Find maximum value in array
+ * @param numbers - Array of numbers
+ * @returns Maximum value
+ */
+function max(numbers) {
+    return Math.max(...numbers);
+}
+
+var math = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    average: average,
+    clamp: clamp,
+    lerp: lerp,
+    lerp2D: lerp2D,
+    lerp3D: lerp3D,
+    lerpTime: lerpTime,
+    mapRange: mapRange,
+    max: max,
+    min: min,
+    percentage: percentage,
+    randomFloat: randomFloat$1,
+    randomInt: randomInt$1,
+    round: round,
+    sum: sum
+});
+
+/**
+ * Get current Unix timestamp in seconds
+ * @returns Current timestamp
+ */
+function timestamp() {
+    return Math.floor(Date.now() / 1000);
+}
+/**
+ * Get current Unix timestamp in milliseconds
+ * @returns Current timestamp in ms
+ */
+function timestampMs() {
+    return Date.now();
+}
+/**
+ * Format a number with leading zero
+ * @param num - Number to format
+ * @returns Formatted string
+ */
+function padZero(num) {
+    return `0${num}`.slice(-2);
+}
+/**
+ * Get full date and time string
+ * @param date - Date object (default: current date)
+ * @returns Formatted date string (DD.MM.YYYY HH:MM)
+ */
+function formatDateTime(date = new Date()) {
+    return `${padZero(date.getDate())}.${padZero(date.getMonth() + 1)}.${date.getFullYear()} ${padZero(date.getHours())}:${padZero(date.getMinutes())}`;
+}
+/**
+ * Get full date and time string with seconds
+ * @param date - Date object (default: current date)
+ * @returns Formatted date string (DD.MM.YYYY HH:MM:SS)
+ */
+function formatDateTimeSeconds(date = new Date()) {
+    return `${padZero(date.getDate())}.${padZero(date.getMonth() + 1)}.${date.getFullYear()} ${padZero(date.getHours())}:${padZero(date.getMinutes())}:${padZero(date.getSeconds())}`;
+}
+/**
+ * Get date without time
+ * @param date - Date object (default: current date)
+ * @returns Formatted date string (DD.MM.YYYY)
+ */
+function formatDate(date = new Date()) {
+    return `${padZero(date.getDate())}.${padZero(date.getMonth() + 1)}.${date.getFullYear()}`;
+}
+/**
+ * Format timestamp to readable date/time string
+ * Shows only time if date is today, otherwise shows date and time
+ * @param time - Unix timestamp in seconds (default: current time)
+ * @param alwaysShowDate - Always show date even if today
+ * @returns Formatted string
+ */
+function formatTimestamp(time = timestamp(), alwaysShowDate = false) {
+    const now = new Date();
+    const date = new Date(time * 1000);
+    let result = `${padZero(date.getHours())}:${padZero(date.getMinutes())}`;
+    const isToday = now.getDate() === date.getDate() &&
+        now.getMonth() === date.getMonth() &&
+        now.getFullYear() === date.getFullYear();
+    if (alwaysShowDate || !isToday) {
+        const showYear = now.getFullYear() !== date.getFullYear() || alwaysShowDate;
+        result = `${padZero(date.getDate())}.${padZero(date.getMonth() + 1)}${showYear ? `.${date.getFullYear()}` : ''} ${result}`;
+    }
+    return result;
+}
+/**
+ * Convert seconds to formatted duration string (HH:MM:SS or D:HH:MM:SS)
+ * @param seconds - Duration in seconds
+ * @returns Formatted duration string
+ */
+function formatDuration(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+    let result = '';
+    if (days > 0) {
+        result += `${days}:`;
+    }
+    result += `${hours.toString().padStart(2, '0')}:`;
+    result += `${minutes.toString().padStart(2, '0')}:`;
+    result += `${secs.toString().padStart(2, '0')}`;
+    return result;
+}
+/**
+ * Convert milliseconds to formatted duration string with ms
+ * @param ms - Duration in milliseconds
+ * @returns Formatted duration string (HH:MM:SS.mmm)
+ */
+function formatDurationMs(ms) {
+    const seconds = Math.floor(ms / 1000);
+    let result = formatDuration(seconds);
+    const milliseconds = (ms % 1000).toString().padStart(3, '0');
+    result += `.${milliseconds}`;
+    return result;
+}
+/**
+ * Sleep/delay for specified milliseconds
+ * @param ms - Milliseconds to sleep
+ * @returns Promise that resolves after delay
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Check if a date is today
+ * @param date - Date to check
+ * @returns True if date is today
+ */
+function isToday(date) {
+    const today = new Date();
+    return (date.getDate() === today.getDate() &&
+        date.getMonth() === today.getMonth() &&
+        date.getFullYear() === today.getFullYear());
+}
+/**
+ * Check if a date is yesterday
+ * @param date - Date to check
+ * @returns True if date is yesterday
+ */
+function isYesterday(date) {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    return (date.getDate() === yesterday.getDate() &&
+        date.getMonth() === yesterday.getMonth() &&
+        date.getFullYear() === yesterday.getFullYear());
+}
+/**
+ * Get relative time string (e.g., "2 hours ago", "in 3 days")
+ * @param date - Date to compare
+ * @param now - Reference date (default: current date)
+ * @returns Relative time string
+ */
+function timeAgo(date, now = new Date()) {
+    const seconds = Math.floor((now.getTime() - date.getTime()) / 1000);
+    const isFuture = seconds < 0;
+    const absSeconds = Math.abs(seconds);
+    const intervals = [
+        { label: 'year', seconds: 31536000 },
+        { label: 'month', seconds: 2592000 },
+        { label: 'week', seconds: 604800 },
+        { label: 'day', seconds: 86400 },
+        { label: 'hour', seconds: 3600 },
+        { label: 'minute', seconds: 60 },
+    ];
+    for (const interval of intervals) {
+        const count = Math.floor(absSeconds / interval.seconds);
+        if (count >= 1) {
+            const plural = count > 1 ? 's' : '';
+            return isFuture
+                ? `in ${count} ${interval.label}${plural}`
+                : `${count} ${interval.label}${plural} ago`;
+        }
+    }
+    return 'just now';
+}
+
+var time = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    formatDate: formatDate,
+    formatDateTime: formatDateTime,
+    formatDateTimeSeconds: formatDateTimeSeconds,
+    formatDuration: formatDuration,
+    formatDurationMs: formatDurationMs,
+    formatTimestamp: formatTimestamp,
+    isToday: isToday,
+    isYesterday: isYesterday,
+    padZero: padZero,
+    sleep: sleep,
+    timeAgo: timeAgo,
+    timestamp: timestamp,
+    timestampMs: timestampMs
+});
+
+/**
+ * Encode string to Base64
+ * @param str - String to encode
+ * @returns Base64 encoded string
+ */
+function toBase64(str) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(str, 'utf-8').toString('base64');
+    }
+    // Browser environment
+    const codeUnits = new Uint16Array(str.length);
+    for (let i = 0; i < codeUnits.length; i++) {
+        codeUnits[i] = str.charCodeAt(i);
+    }
+    const uint8Array = new Uint8Array(codeUnits.buffer);
+    const chunkSize = 0x8000;
+    let result = '';
+    for (let i = 0; i < uint8Array.length; i += chunkSize) {
+        const chunk = uint8Array.subarray(i, i + chunkSize);
+        result += String.fromCharCode(...chunk);
+    }
+    return btoa(result);
+}
+/**
+ * Decode Base64 string
+ * @param encoded - Base64 encoded string
+ * @returns Decoded string
+ */
+function fromBase64(encoded) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(encoded, 'base64').toString('utf-8');
+    }
+    // Browser environment
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return String.fromCharCode(...new Uint16Array(bytes.buffer));
+}
+/**
+ * Generate MD5 hash of a string
+ * @param text - Text to hash
+ * @returns MD5 hash
+ */
+function hash(text) {
+    return md5(text);
+}
+/**
+ * Encode URI component safely
+ * @param str - String to encode
+ * @returns Encoded URI component
+ */
+function encodeUri(str) {
+    return encodeURIComponent(str);
+}
+/**
+ * Decode URI component safely
+ * @param str - String to decode
+ * @returns Decoded URI component
+ */
+function decodeUri(str) {
+    try {
+        return decodeURIComponent(str);
+    }
+    catch {
+        return str;
+    }
+}
+/**
+ * Convert ArrayBuffer to Buffer (Node.js)
+ * @param ab - ArrayBuffer to convert
+ * @returns Buffer
+ */
+function arrayBufferToBuffer(ab) {
+    const buf = Buffer.alloc(ab.byteLength);
+    const view = new Uint8Array(ab);
+    for (let i = 0; i < buf.length; i++) {
+        buf[i] = view[i];
+    }
+    return buf;
+}
+/**
+ * Convert hex string to bytes
+ * @param hex - Hex string
+ * @returns Uint8Array
+ */
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return bytes;
+}
+/**
+ * Convert bytes to hex string
+ * @param bytes - Byte array
+ * @returns Hex string
+ */
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+
+var encoding = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    arrayBufferToBuffer: arrayBufferToBuffer,
+    bytesToHex: bytesToHex,
+    decodeUri: decodeUri,
+    encodeUri: encodeUri,
+    fromBase64: fromBase64,
+    hash: hash,
+    hexToBytes: hexToBytes,
+    toBase64: toBase64
+});
+
+/**
+ * Check if a string is a valid emoji
+ * @param str - String to check
+ * @returns True if string is an emoji
+ */
+function isEmoji(str) {
+    const emojiRegex = new RegExp('^(' +
+        // Regular and compound emojis
+        '(?:\\p{Extended_Pictographic}(?:\\p{Emoji_Modifier}|\\uFE0F)?' +
+        '(?:\\u200D\\p{Extended_Pictographic}(?:\\p{Emoji_Modifier}|\\uFE0F)?)*)' +
+        '|' +
+        // Flags (regional indicator pairs)
+        '(?:\\p{Regional_Indicator}{2})' +
+        ')$', 'u');
+    return emojiRegex.test(str);
+}
+/**
+ * Check if a URL is an image link
+ * @param url - URL to check
+ * @returns True if URL points to an image
+ */
+function isImageUrl(url) {
+    const imageExtensions = /\.(jpg|jpeg|png|gif|bmp|webp|svg|ico)(\?.*)?$/i;
+    return imageExtensions.test(url);
+}
+/**
+ * Check if a string is a valid email
+ * @param email - Email string to validate
+ * @returns True if email is valid
+ */
+function isEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Check if a string is a valid URL
+ * @param url - URL string to validate
+ * @returns True if URL is valid
+ */
+function isUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a string contains only numbers
+ * @param str - String to check
+ * @returns True if string contains only numbers
+ */
+function isNumeric(str) {
+    return /^\d+$/.test(str);
+}
+/**
+ * Check if a string contains only letters
+ * @param str - String to check
+ * @returns True if string contains only letters
+ */
+function isAlpha(str) {
+    return /^[a-zA-Z]+$/.test(str);
+}
+/**
+ * Check if a string contains only letters and numbers
+ * @param str - String to check
+ * @returns True if string is alphanumeric
+ */
+function isAlphanumeric(str) {
+    return /^[a-zA-Z0-9]+$/.test(str);
+}
+/**
+ * Check if a value is empty (null, undefined, empty string, empty array, empty object)
+ * @param value - Value to check
+ * @returns True if value is empty
+ */
+function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === 'string')
+        return value.trim().length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length === 0;
+    return false;
+}
+/**
+ * Check if a value is a plain object
+ * @param value - Value to check
+ * @returns True if value is a plain object
+ */
+function isPlainObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.constructor === Object &&
+        Object.prototype.toString.call(value) === '[object Object]');
+}
+/**
+ * Extract URL information from a string
+ * @param str - String containing URL
+ * @returns URL info or null if no URL found
+ */
+function extractUrl(str) {
+    const urlRegex = /(https?:\/\/[^\s]+|www\.[^\s]+|[\w-]+\.[\w-]+[^\s]*)/i;
+    const match = str.match(urlRegex);
+    if (!match)
+        return null;
+    const rawUrl = match[0].startsWith('http') ? match[0] : `https://${match[0]}`;
+    try {
+        const parsed = new URL(rawUrl);
+        return {
+            url: parsed.href,
+            domain: parsed.hostname.replace(/^www\./, ''),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a string is a valid IPv4 address
+ * @param ip - IP address string
+ * @returns True if valid IPv4
+ */
+function isIPv4(ip) {
+    const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+    return ipv4Regex.test(ip);
+}
+/**
+ * Check if a string is a valid hex color
+ * @param color - Color string
+ * @returns True if valid hex color
+ */
+function isHexColor(color) {
+    return /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(color);
+}
+
+var validation = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    extractUrl: extractUrl,
+    isAlpha: isAlpha,
+    isAlphanumeric: isAlphanumeric,
+    isEmail: isEmail,
+    isEmoji: isEmoji,
+    isEmpty: isEmpty,
+    isHexColor: isHexColor,
+    isIPv4: isIPv4,
+    isImageUrl: isImageUrl,
+    isNumeric: isNumeric,
+    isPlainObject: isPlainObject,
+    isUrl: isUrl
+});
+
+/**
+ * Format a number with thousands separators
+ * @param num - Number to format
+ * @param removeTrailingZeros - Remove .00 from integers (default: true)
+ * @returns Formatted number string
+ */
+function formatNumber(num, removeTrailingZeros = true) {
+    if (typeof num !== 'number') {
+        num = Number(num);
+    }
+    let n = num.toFixed(2);
+    if (removeTrailingZeros) {
+        n = n.replace('.00', '');
+    }
+    return n.replace(/.+?(?=\D|$)/, (match) => {
+        return match.replace(/(\d)(?=(?:\d{3})+$)/g, '$1 ');
+    });
+}
+/**
+ * Format bytes to human-readable size
+ * @param bytes - Number of bytes
+ * @param decimals - Decimal places (default: 2)
+ * @returns Formatted size string
+ */
+function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return (parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + ' ' + sizes[i]);
+}
+/**
+ * Format a number as currency
+ * @param amount - Amount to format
+ * @param currency - Currency code (default: 'USD')
+ * @param locale - Locale for formatting (default: 'en-US')
+ * @returns Formatted currency string
+ */
+function formatCurrency(amount, currency = 'USD', locale = 'en-US') {
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency: currency,
+    }).format(amount);
+}
+/**
+ * Format a phone number (basic US format)
+ * @param phone - Phone number string
+ * @returns Formatted phone number
+ */
+function formatPhone(phone) {
+    const cleaned = phone.replace(/\D/g, '');
+    if (cleaned.length === 10) {
+        return `(${cleaned.slice(0, 3)}) ${cleaned.slice(3, 6)}-${cleaned.slice(6)}`;
+    }
+    if (cleaned.length === 11 && cleaned[0] === '1') {
+        return `+1 (${cleaned.slice(1, 4)}) ${cleaned.slice(4, 7)}-${cleaned.slice(7)}`;
+    }
+    return phone;
+}
+/**
+ * Format a credit card number with spaces
+ * @param cardNumber - Card number string
+ * @returns Formatted card number
+ */
+function formatCardNumber(cardNumber) {
+    const cleaned = cardNumber.replace(/\s/g, '');
+    const groups = cleaned.match(/.{1,4}/g);
+    return groups ? groups.join(' ') : cardNumber;
+}
+/**
+ * Mask sensitive data (show only last N characters)
+ * @param str - String to mask
+ * @param visibleChars - Number of visible characters at the end (default: 4)
+ * @param maskChar - Character to use for masking (default: '*')
+ * @returns Masked string
+ */
+function maskString(str, visibleChars = 4, maskChar = '*') {
+    if (str.length <= visibleChars)
+        return str;
+    const masked = maskChar.repeat(str.length - visibleChars);
+    return masked + str.slice(-visibleChars);
+}
+/**
+ * Format percentage
+ * @param value - Value to format
+ * @param decimals - Decimal places (default: 2)
+ * @returns Formatted percentage string
+ */
+function formatPercentage(value, decimals = 2) {
+    return `${value.toFixed(decimals)}%`;
+}
+/**
+ * Pluralize a word based on count
+ * @param count - Count number
+ * @param singular - Singular form
+ * @param plural - Plural form (optional, will add 's' if not provided)
+ * @returns Pluralized string with count
+ */
+function pluralize(count, singular, plural) {
+    const word = count === 1 ? singular : plural || `${singular}s`;
+    return `${count} ${word}`;
+}
+/**
+ * Abbreviate large numbers (1000 -> 1K, 1000000 -> 1M)
+ * @param num - Number to abbreviate
+ * @param decimals - Decimal places (default: 1)
+ * @returns Abbreviated number string
+ */
+function abbreviateNumber(num, decimals = 1) {
+    if (num < 1000)
+        return num.toString();
+    const units = ['K', 'M', 'B', 'T'];
+    const order = Math.floor(Math.log10(num) / 3);
+    const unitIndex = order - 1;
+    if (unitIndex >= units.length) {
+        return num.toExponential(decimals);
+    }
+    const value = num / Math.pow(1000, order);
+    return `${value.toFixed(decimals)}${units[unitIndex]}`;
+}
+/**
+ * Format file name with extension
+ * @param name - File name without extension
+ * @param extension - File extension
+ * @returns Formatted file name
+ */
+function formatFileName(name, extension) {
+    const cleanName = name.replace(/[^a-z0-9_-]/gi, '_');
+    const cleanExt = extension.replace(/^\./, '');
+    return `${cleanName}.${cleanExt}`;
+}
+/**
+ * Title case a string (capitalize first letter of each word)
+ * @param str - String to title case
+ * @returns Title cased string
+ */
+function titleCase(str) {
+    return str
+        .toLowerCase()
+        .split(' ')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+
+var format = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    abbreviateNumber: abbreviateNumber,
+    formatBytes: formatBytes,
+    formatCardNumber: formatCardNumber,
+    formatCurrency: formatCurrency,
+    formatFileName: formatFileName,
+    formatNumber: formatNumber,
+    formatPercentage: formatPercentage,
+    formatPhone: formatPhone,
+    maskString: maskString,
+    pluralize: pluralize,
+    titleCase: titleCase
+});
+
+/**
+ * Generate a random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ */
+function randomInt(min, max) {
+    if (max < min) {
+        [max, min] = [min, max];
+    }
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * Generate a random float between min and max
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random float
+ */
+function randomFloat(min, max) {
+    if (max < min) {
+        [max, min] = [min, max];
+    }
+    return Math.random() * (max - min) + min;
+}
+/**
+ * Generate a random boolean
+ * @param probability - Probability of true (0-1, default: 0.5)
+ * @returns Random boolean
+ */
+function randomBoolean(probability = 0.5) {
+    return Math.random() < probability;
+}
+/**
+ * Pick N random unique elements from an array
+ * @param arr - Array to pick from
+ * @param count - Number of elements to pick
+ * @returns Array of random elements
+ */
+function randomSample(arr, count) {
+    const shuffled = [...arr].sort(() => Math.random() - 0.5);
+    return shuffled.slice(0, Math.min(count, arr.length));
+}
+/**
+ * Generate a random hex color
+ * @returns Random hex color string
+ */
+function randomColor() {
+    return `#${Math.floor(Math.random() * 16777215)
+        .toString(16)
+        .padStart(6, '0')}`;
+}
+/**
+ * Generate a random UUID v4
+ * @returns UUID string
+ */
+function randomUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Generate random weighted choice based on weights
+ * @param items - Array of items
+ * @param weights - Array of weights (must match items length)
+ * @returns Random item based on weights
+ */
+function randomWeighted(items, weights) {
+    if (items.length !== weights.length) {
+        throw new Error('Items and weights arrays must have the same length');
+    }
+    const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+    let random = Math.random() * totalWeight;
+    for (let i = 0; i < items.length; i++) {
+        random -= weights[i];
+        if (random <= 0) {
+            return items[i];
+        }
+    }
+    return items[items.length - 1];
+}
+/**
+ * Generate a random date between two dates
+ * @param start - Start date
+ * @param end - End date
+ * @returns Random date
+ */
+function randomDate(start, end) {
+    return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+}
+
+var random = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    randomBoolean: randomBoolean,
+    randomColor: randomColor,
+    randomDate: randomDate,
+    randomFloat: randomFloat,
+    randomInt: randomInt,
+    randomSample: randomSample,
+    randomUUID: randomUUID,
+    randomWeighted: randomWeighted
+});
+
+/**
+ * Deep clone an object
+ * @param obj - Object to clone
+ * @returns Cloned object
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (obj instanceof Date)
+        return new Date(obj.getTime());
+    if (obj instanceof Array)
+        return obj.map((item) => deepClone(item));
+    if (obj instanceof Object) {
+        const cloned = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                cloned[key] = deepClone(obj[key]);
+            }
+        }
+        return cloned;
+    }
+    return obj;
+}
+/**
+ * Deep merge two or more objects (mutates target)
+ */
+function deepMerge(target, ...sources) {
+    for (const source of sources) {
+        if (!isObject(source))
+            continue;
+        for (const key in source) {
+            if (!Object.prototype.hasOwnProperty.call(source, key))
+                continue;
+            const sourceValue = source[key];
+            const targetValue = target[key];
+            if (isObject(sourceValue)) {
+                if (!isObject(targetValue)) {
+                    target[key] = {};
+                }
+                deepMerge(target[key], sourceValue);
+            }
+            else {
+                target[key] = sourceValue;
+            }
+        }
+    }
+    return target;
+}
+/**
+ * Get nested property value from object using path
+ * @param obj - Object to get value from
+ * @param path - Property path (e.g., 'user.address.city')
+ * @param defaultValue - Default value if path not found
+ * @returns Property value or default
+ */
+function get(obj, path, defaultValue) {
+    const keys = path.split('.');
+    let result = obj;
+    for (const key of keys) {
+        if (result && typeof result === 'object' && key in result) {
+            result = result[key];
+        }
+        else {
+            return defaultValue;
+        }
+    }
+    return result;
+}
+/**
+ * Set nested property value in object using path
+ * @param obj - Object to set value in
+ * @param path - Property path (e.g., 'user.address.city')
+ * @param value - Value to set
+ * @returns Modified object
+ */
+function set(obj, path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    let current = obj;
+    for (const key of keys) {
+        if (!(key in current) || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    current[lastKey] = value;
+    return obj;
+}
+/**
+ * Pick specific properties from object
+ * @param obj - Source object
+ * @param keys - Keys to pick
+ * @returns New object with picked properties
+ */
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+/**
+ * Omit specific properties from object
+ * @param obj - Source object
+ * @param keys - Keys to omit
+ * @returns New object without omitted properties
+ */
+function omit(obj, keys) {
+    const result = { ...obj };
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
+}
+/**
+ * Check if value is a plain object
+ * @param value - Value to check
+ * @returns True if plain object
+ */
+function isObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Flatten nested object to single level with dot notation keys
+ * @param obj - Object to flatten
+ * @param prefix - Key prefix (used internally)
+ * @returns Flattened object
+ */
+function flatten(obj, prefix = '') {
+    const result = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            if (isObject(obj[key]) && !Array.isArray(obj[key])) {
+                Object.assign(result, flatten(obj[key], newKey));
+            }
+            else {
+                result[newKey] = obj[key];
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Unflatten object with dot notation keys to nested object
+ * @param obj - Flattened object
+ * @returns Nested object
+ */
+function unflatten(obj) {
+    const result = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            set(result, key, obj[key]);
+        }
+    }
+    return result;
+}
+/**
+ * Get all keys from object including nested keys (dot notation)
+ * @param obj - Object to get keys from
+ * @param prefix - Key prefix (used internally)
+ * @returns Array of all keys
+ */
+function keys(obj, prefix = '') {
+    const result = [];
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            result.push(newKey);
+            if (isObject(obj[key]) && !Array.isArray(obj[key])) {
+                result.push(...keys(obj[key], newKey));
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Get all values from object including nested values
+ * @param obj - Object to get values from
+ * @returns Array of all values
+ */
+function values(obj) {
+    const result = [];
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (isObject(obj[key]) && !Array.isArray(obj[key])) {
+                result.push(...values(obj[key]));
+            }
+            else {
+                result.push(obj[key]);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Check if two objects are deeply equal
+ * @param obj1 - First object
+ * @param obj2 - Second object
+ * @returns True if objects are equal
+ */
+function isEqual(obj1, obj2) {
+    if (obj1 === obj2)
+        return true;
+    if (typeof obj1 !== 'object' ||
+        typeof obj2 !== 'object' ||
+        obj1 === null ||
+        obj2 === null) {
+        return false;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    for (const key of keys1) {
+        if (!keys2.includes(key) || !isEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+var object = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    deepClone: deepClone,
+    deepMerge: deepMerge,
+    flatten: flatten,
+    get: get,
+    isEqual: isEqual,
+    keys: keys,
+    omit: omit,
+    pick: pick,
+    set: set,
+    unflatten: unflatten,
+    values: values
+});
+
+// Import all modules
+// Default export - all utilities in one object (like original System class)
+const toolkit = {
+    string,
+    array,
+    math,
+    time,
+    encoding,
+    validation,
+    format,
+    random,
+    object,
+    // Convenience shortcuts at top level
+    randomString: randomString,
+    capitalize: capitalize,
+    truncate: truncate,
+    randomElement: randomElement,
+    chunk: chunk,
+    unique: unique,
+    shuffle: shuffle,
+    randomInt: randomInt$1,
+    randomFloat: randomFloat$1,
+    lerp: lerp,
+    clamp: clamp,
+    round: round,
+    timestamp: timestamp,
+    timestampMs: timestampMs,
+    formatDateTime: formatDateTime,
+    formatDuration: formatDuration,
+    sleep: sleep,
+    toBase64: toBase64,
+    fromBase64: fromBase64,
+    hash: hash,
+    isEmail: isEmail,
+    isUrl: isUrl,
+    isEmpty: isEmpty,
+    isEmoji: isEmoji,
+    formatNumber: formatNumber,
+    formatBytes: formatBytes,
+    pluralize: pluralize,
+    randomBoolean: randomBoolean,
+    randomColor: randomColor,
+    randomUUID: randomUUID,
+    deepClone: deepClone,
+    pick: pick,
+    omit: omit,
+    get: get,
+    set: set,
+};
+
+export { array, capitalize, chunk, clamp, deepClone, toolkit as default, encoding, format, formatBytes, formatDateTime, formatDuration, formatNumber, fromBase64, get, hash, isEmail, isEmoji, isEmpty, isUrl, lerp, math, object, omit, pick, pluralize, random, randomBoolean, randomColor, randomElement, randomFloat$1 as randomFloat, randomInt$1 as randomInt, randomString, randomUUID, round, set, shuffle, sleep, string, time, timestamp, timestampMs, toBase64, unique, validation };
+//# sourceMappingURL=index.esm.js.map