artytext/dist/index.js

A comprehensive utility library for text manipulation, slug generation, password generation, case conversion, and more. Works with both TypeScript and JavaScript.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

const UPPERCASE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const LOWERCASE_CHARS = 'abcdefghijklmnopqrstuvwxyz';
const NUMBERS = '0123456789';
const SYMBOLS = '!@#$%^&*()_+-=[]{}|;:,.<>?';
const SIMILAR_CHARS = 'il1Lo0O';
const AMBIGUOUS_CHARS = '{}[]()/\\\'"`~,;:.<>';
/**
 * Generate a random password with specified options
 * @param options - Password generation options
 * @returns Generated password string
 */
function generatePassword(options = {}) {
    const { length = 12, includeUppercase = true, includeLowercase = true, includeNumbers = true, includeSymbols = false, excludeSimilar = false, excludeAmbiguous = false, } = options;
    let charset = '';
    if (includeUppercase)
        charset += UPPERCASE_CHARS;
    if (includeLowercase)
        charset += LOWERCASE_CHARS;
    if (includeNumbers)
        charset += NUMBERS;
    if (includeSymbols)
        charset += SYMBOLS;
    if (excludeSimilar) {
        charset = charset.split('').filter(char => !SIMILAR_CHARS.includes(char)).join('');
    }
    if (excludeAmbiguous) {
        charset = charset.split('').filter(char => !AMBIGUOUS_CHARS.includes(char)).join('');
    }
    if (charset.length === 0) {
        throw new Error('No character set available with the given options');
    }
    let password = '';
    // Ensure at least one character from each selected character set (after exclusions)
    const requiredChars = [];
    if (includeUppercase) {
        const upperChars = excludeSimilar ? UPPERCASE_CHARS.split('').filter(char => !SIMILAR_CHARS.includes(char)).join('') : UPPERCASE_CHARS;
        const upperCharsFiltered = excludeAmbiguous ? upperChars.split('').filter(char => !AMBIGUOUS_CHARS.includes(char)).join('') : upperChars;
        if (upperCharsFiltered)
            requiredChars.push(upperCharsFiltered[Math.floor(Math.random() * upperCharsFiltered.length)]);
    }
    if (includeLowercase) {
        const lowerChars = excludeSimilar ? LOWERCASE_CHARS.split('').filter(char => !SIMILAR_CHARS.includes(char)).join('') : LOWERCASE_CHARS;
        const lowerCharsFiltered = excludeAmbiguous ? lowerChars.split('').filter(char => !AMBIGUOUS_CHARS.includes(char)).join('') : lowerChars;
        if (lowerCharsFiltered)
            requiredChars.push(lowerCharsFiltered[Math.floor(Math.random() * lowerCharsFiltered.length)]);
    }
    if (includeNumbers) {
        const numChars = excludeSimilar ? NUMBERS.split('').filter(char => !SIMILAR_CHARS.includes(char)).join('') : NUMBERS;
        const numCharsFiltered = excludeAmbiguous ? numChars.split('').filter(char => !AMBIGUOUS_CHARS.includes(char)).join('') : numChars;
        if (numCharsFiltered)
            requiredChars.push(numCharsFiltered[Math.floor(Math.random() * numCharsFiltered.length)]);
    }
    if (includeSymbols) {
        const symChars = excludeSimilar ? SYMBOLS.split('').filter(char => !SIMILAR_CHARS.includes(char)).join('') : SYMBOLS;
        const symCharsFiltered = excludeAmbiguous ? symChars.split('').filter(char => !AMBIGUOUS_CHARS.includes(char)).join('') : symChars;
        if (symCharsFiltered)
            requiredChars.push(symCharsFiltered[Math.floor(Math.random() * symCharsFiltered.length)]);
    }
    // Add required characters first
    for (let i = 0; i < Math.min(requiredChars.length, length); i++) {
        password += requiredChars[i];
    }
    // Fill the rest with random characters
    for (let i = password.length; i < length; i++) {
        const randomIndex = Math.floor(Math.random() * charset.length);
        password += charset[randomIndex];
    }
    // Shuffle the password
    return password.split('').sort(() => Math.random() - 0.5).join('');
}
/**
 * Generate a memorable password using words
 * @param wordCount - Number of words to use (default: 4)
 * @param separator - Separator between words (default: '-')
 * @param includeNumbers - Whether to include numbers (default: true)
 * @returns Memorable password string
 */
function generateMemorablePassword(wordCount = 4, separator = '-', includeNumbers = true) {
    const words = [
        'apple', 'banana', 'cherry', 'dragon', 'eagle', 'forest', 'garden', 'house',
        'island', 'jungle', 'knight', 'lemon', 'mountain', 'ocean', 'planet', 'queen',
        'river', 'star', 'tiger', 'umbrella', 'village', 'water', 'xylophone', 'yellow',
        'zebra', 'adventure', 'beautiful', 'creative', 'delicious', 'excellent'
    ];
    const selectedWords = [];
    for (let i = 0; i < wordCount; i++) {
        const randomIndex = Math.floor(Math.random() * words.length);
        selectedWords.push(words[randomIndex]);
    }
    let password = selectedWords.join(separator);
    if (includeNumbers) {
        const randomNumber = Math.floor(Math.random() * 1000);
        password += randomNumber.toString();
    }
    return password;
}
/**
 * Check password strength and return a score
 * @param password - Password to check
 * @returns Object with score (0-100) and feedback
 */
function checkPasswordStrength(password) {
    const feedback = [];
    let score = 0;
    // Length check
    if (password.length < 8) {
        feedback.push('Password should be at least 8 characters long');
    }
    else if (password.length >= 12) {
        score += 25;
    }
    else {
        score += 15;
    }
    // Character variety checks
    if (/[a-z]/.test(password))
        score += 10;
    else
        feedback.push('Include lowercase letters');
    if (/[A-Z]/.test(password))
        score += 10;
    else
        feedback.push('Include uppercase letters');
    if (/[0-9]/.test(password))
        score += 10;
    else
        feedback.push('Include numbers');
    if (/[^A-Za-z0-9]/.test(password))
        score += 15;
    else
        feedback.push('Include special characters');
    // Complexity checks
    if (/(.)\1{2,}/.test(password)) {
        score -= 10;
        feedback.push('Avoid repeated characters');
    }
    if (/^(.)\1+$/.test(password)) {
        score -= 20;
        feedback.push('Avoid using the same character repeatedly');
    }
    // Common patterns (only exact matches or common sequences)
    if (/123|abc|qwe|admin/i.test(password) || /^password$/i.test(password)) {
        score -= 15;
        feedback.push('Avoid common patterns');
    }
    // Determine strength level
    let strength;
    if (score < 30)
        strength = 'weak';
    else if (score < 50)
        strength = 'fair';
    else if (score < 65)
        strength = 'good';
    else if (score < 85)
        strength = 'strong';
    else
        strength = 'very-strong';
    return { score: Math.max(0, Math.min(100, score)), feedback, strength };
}

/**
 * Generate a URL-friendly slug from a string
 * @param text - Text to convert to slug
 * @param options - Slug generation options
 * @returns URL-friendly slug string
 */
function generateSlug(text, options = {}) {
    const { separator = '-', lowercase = true, removeSpecialChars = true, maxLength, } = options;
    if (!text)
        return '';
    let slug = text;
    // Convert to lowercase if specified
    if (lowercase) {
        slug = slug.toLowerCase();
    }
    // Remove special characters and replace with separator
    if (removeSpecialChars) {
        // Replace spaces and special characters with separator
        slug = slug
            .replace(/[^\w\s-]/g, '') // Remove special characters except spaces and hyphens
            .replace(/[\s_-]+/g, separator) // Replace spaces, underscores, and multiple hyphens with separator
            .replace(new RegExp(`^${separator}|${separator}$`, 'g'), ''); // Remove leading/trailing separators
    }
    else {
        // Only replace spaces with separator
        slug = slug
            .replace(/\s+/g, separator)
            .replace(new RegExp(`^${separator}|${separator}$`, 'g'), '');
    }
    // Apply max length if specified
    if (maxLength && slug.length > maxLength) {
        slug = slug.substring(0, maxLength);
        // Remove trailing separator if it exists
        if (slug.endsWith(separator)) {
            slug = slug.slice(0, -separator.length);
        }
    }
    return slug;
}
/**
 * Generate a slug with timestamp for unique URLs
 * @param text - Text to convert to slug
 * @param options - Slug generation options
 * @returns Unique slug with timestamp
 */
function generateUniqueSlug(text, options = {}) {
    const baseSlug = generateSlug(text, options);
    const timestamp = Date.now().toString(36);
    return `${baseSlug}-${timestamp}`;
}
/**
 * Generate a slug with random suffix for unique URLs
 * @param text - Text to convert to slug
 * @param options - Slug generation options
 * @param suffixLength - Length of random suffix (default: 6)
 * @returns Unique slug with random suffix
 */
function generateRandomSlug(text, options = {}, suffixLength = 6) {
    const baseSlug = generateSlug(text, options);
    const randomSuffix = Math.random().toString(36).substring(2, 2 + suffixLength);
    return `${baseSlug}-${randomSuffix}`;
}
/**
 * Convert a slug back to readable text
 * @param slug - Slug to convert back
 * @param separator - Separator used in the slug (default: '-')
 * @returns Readable text
 */
function slugToText(slug, separator = '-') {
    if (!slug)
        return '';
    return slug
        .replace(new RegExp(separator, 'g'), ' ')
        .replace(/\b\w/g, l => l.toUpperCase());
}
/**
 * Check if a string is a valid slug
 * @param slug - String to check
 * @param separator - Expected separator (default: '-')
 * @returns True if valid slug
 */
function isValidSlug(slug, separator = '-') {
    if (!slug)
        return false;
    // Escape special regex characters in separator
    const escapedSeparator = separator.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    const slugRegex = new RegExp(`^[a-z0-9${escapedSeparator}]+$`);
    return slugRegex.test(slug) && !slug.startsWith(separator) && !slug.endsWith(separator);
}

/**
 * Generate a random integer between min and max (inclusive)
 * @param min - Minimum value (default: 0)
 * @param max - Maximum value (default: 100)
 * @returns Random integer
 */
function randomInt(min = 0, max = 100) {
    // Handle single parameter case (treat as max)
    if (arguments.length === 1) {
        max = min;
        min = 0;
    }
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
/**
 * Generate a random float between min and max
 * @param min - Minimum value (default: 0)
 * @param max - Maximum value (default: 1)
 * @param decimals - Number of decimal places (default: 2)
 * @returns Random float
 */
function randomFloat(min = 0, max = 1, decimals = 2) {
    const random = Math.random() * (max - min) + min;
    return Number(random.toFixed(decimals));
}
/**
 * Generate a random string with specified options
 * @param options - Random string generation options
 * @returns Random string
 */
function randomString(options = {}) {
    const { length = 10, charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', } = options;
    let result = '';
    for (let i = 0; i < length; i++) {
        result += charset.charAt(Math.floor(Math.random() * charset.length));
    }
    return result;
}
/**
 * Generate a random number string
 * @param length - Length of the number string (default: 6)
 * @returns Random number string
 */
function randomNumberString(length = 6) {
    return randomString({ length, charset: '0123456789' });
}
/**
 * Generate a random hexadecimal string
 * @param length - Length of the hex string (default: 8)
 * @param uppercase - Whether to use uppercase letters (default: false)
 * @returns Random hex string
 */
function randomHex(length = 8, uppercase = false) {
    const hex = randomString({ length, charset: '0123456789abcdef' });
    return uppercase ? hex.toUpperCase() : hex;
}
/**
 * Generate a random UUID (version 4)
 * @returns Random UUID string
 */
function randomUUID() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
        const r = Math.random() * 16 | 0;
        const v = c === 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
    });
}
/**
 * Generate a random color in hex format
 * @param includeHash - Whether to include # prefix (default: true)
 * @returns Random hex color
 */
function randomColor(includeHash = true) {
    const color = Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0');
    return includeHash ? `#${color}` : color;
}
/**
 * Generate a random RGB color
 * @returns Random RGB color object
 */
function randomRGB() {
    return {
        r: randomInt(0, 255),
        g: randomInt(0, 255),
        b: randomInt(0, 255),
    };
}
/**
 * Generate a random item from an array
 * @param array - Array to pick from
 * @returns Random item from array
 */
function randomItem(array) {
    if (array.length === 0) {
        throw new Error('Cannot pick random item from empty array');
    }
    return array[Math.floor(Math.random() * array.length)];
}
/**
 * Generate multiple random items from an array
 * @param array - Array to pick from
 * @param count - Number of items to pick
 * @param allowDuplicates - Whether to allow duplicate picks (default: false)
 * @returns Array of random items
 */
function randomItems(array, count, allowDuplicates = false) {
    if (array.length === 0) {
        throw new Error('Cannot pick random items from empty array');
    }
    if (count > array.length && !allowDuplicates) {
        throw new Error(`Cannot pick ${count} unique items from array of length ${array.length}`);
    }
    if (allowDuplicates) {
        const result = [];
        for (let i = 0; i < count; i++) {
            result.push(randomItem(array));
        }
        return result;
    }
    else {
        const shuffled = [...array].sort(() => Math.random() - 0.5);
        return shuffled.slice(0, count);
    }
}
/**
 * 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;
}
/**
 * Generate a random date within a range
 * @param startDate - Start date (default: 1 year ago)
 * @param endDate - End date (default: now)
 * @returns Random date
 */
function randomDate(startDate, endDate) {
    const start = startDate || new Date(Date.now() - 365 * 24 * 60 * 60 * 1000);
    const end = endDate || new Date();
    return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
}

/**
 * Convert text to different case formats
 * @param text - Text to convert
 * @param options - Case conversion options
 * @returns Converted text
 */
function changeCase(text, options) {
    const { type, preserveWords = false } = options;
    if (!text)
        return '';
    switch (type) {
        case 'lowercase':
            return text.toLowerCase();
        case 'uppercase':
            return text.toUpperCase();
        case 'camelCase':
            return toCamelCase(text, preserveWords);
        case 'kebab-case':
            return toKebabCase(text, preserveWords);
        case 'snake_case':
            return toSnakeCase(text, preserveWords);
        case 'pascalCase':
            return toPascalCase(text, preserveWords);
        case 'titleCase':
            return toTitleCase(text, preserveWords);
        case 'sentenceCase':
            return toSentenceCase(text, preserveWords);
        default:
            return text;
    }
}
/**
 * Convert to camelCase
 * @param text - Text to convert
 * @param preserveWords - Whether to preserve word boundaries
 * @returns camelCase text
 */
function toCamelCase(text, preserveWords = false) {
    if (!text)
        return '';
    const words = splitIntoWords(text, preserveWords);
    return words
        .map((word, index) => {
        if (index === 0) {
            return word.toLowerCase();
        }
        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
    })
        .join('');
}
/**
 * Convert to kebab-case
 * @param text - Text to convert
 * @param preserveWords - Whether to preserve word boundaries
 * @returns kebab-case text
 */
function toKebabCase(text, preserveWords = false) {
    if (!text)
        return '';
    const words = splitIntoWords(text, preserveWords);
    return words.map(word => word.toLowerCase()).join('-');
}
/**
 * Convert to snake_case
 * @param text - Text to convert
 * @param preserveWords - Whether to preserve word boundaries
 * @returns snake_case text
 */
function toSnakeCase(text, preserveWords = false) {
    if (!text)
        return '';
    const words = splitIntoWords(text, preserveWords);
    return words.map(word => word.toLowerCase()).join('_');
}
/**
 * Convert to PascalCase
 * @param text - Text to convert
 * @param preserveWords - Whether to preserve word boundaries
 * @returns PascalCase text
 */
function toPascalCase(text, preserveWords = false) {
    if (!text)
        return '';
    const words = splitIntoWords(text, preserveWords);
    return words
        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
        .join('');
}
/**
 * Convert to Title Case
 * @param text - Text to convert
 * @param preserveWords - Whether to preserve word boundaries
 * @returns Title Case text
 */
function toTitleCase(text, preserveWords = false) {
    if (!text)
        return '';
    const words = splitIntoWords(text, preserveWords);
    return words
        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
        .join(' ');
}
/**
 * Convert to Sentence case
 * @param text - Text to convert
 * @param preserveWords - Whether to preserve word boundaries
 * @returns Sentence case text
 */
function toSentenceCase(text, preserveWords = false) {
    if (!text)
        return '';
    const sentences = text.split(/[.!?]+/).filter(sentence => sentence.trim());
    return sentences
        .map(sentence => {
        const trimmed = sentence.trim();
        if (!trimmed)
            return '';
        const words = splitIntoWords(trimmed, preserveWords);
        const firstWord = words[0];
        const restWords = words.slice(1);
        return (firstWord.charAt(0).toUpperCase() + firstWord.slice(1).toLowerCase() +
            restWords.map(word => word.toLowerCase()).join(' '));
    })
        .join('. ') + (text.endsWith('.') ? '.' : '');
}
/**
 * Split text into words based on various delimiters
 * @param text - Text to split
 * @param preserveWords - Whether to preserve existing word boundaries
 * @returns Array of words
 */
function splitIntoWords(text, preserveWords = false) {
    if (preserveWords) {
        // Split by spaces, hyphens, underscores, and camelCase boundaries
        return text
            .split(/[\s\-_]+|(?=[A-Z][a-z])/)
            .filter(word => word.length > 0);
    }
    else {
        // Split by any non-alphanumeric character
        return text
            .split(/[^a-zA-Z0-9]+/)
            .filter(word => word.length > 0);
    }
}
/**
 * Convert text to alternating case (aLtErNaTiNg)
 * @param text - Text to convert
 * @returns Alternating case text
 */
function toAlternatingCase(text) {
    if (!text)
        return '';
    return text
        .split('')
        .map((char, index) => {
        if (index % 2 === 0) {
            return char.toLowerCase();
        }
        else {
            return char.toUpperCase();
        }
    })
        .join('');
}
/**
 * Convert text to sponge case (mOcKiNg)
 * @param text - Text to convert
 * @returns Sponge case text
 */
function toSpongeCase(text) {
    if (!text)
        return '';
    return text
        .split('')
        .map(char => {
        if (Math.random() > 0.5) {
            return char.toUpperCase();
        }
        else {
            return char.toLowerCase();
        }
    })
        .join('');
}
/**
 * Convert text to dot.case
 * @param text - Text to convert
 * @returns dot.case text
 */
function toDotCase(text) {
    if (!text)
        return '';
    const words = splitIntoWords(text);
    return words.map(word => word.toLowerCase()).join('.');
}
/**
 * Convert text to CONSTANT_CASE
 * @param text - Text to convert
 * @returns CONSTANT_CASE text
 */
function toConstantCase(text) {
    if (!text)
        return '';
    const words = splitIntoWords(text);
    return words.map(word => word.toUpperCase()).join('_');
}

/**
 * Truncate text to a specified length
 * @param text - Text to truncate
 * @param options - Truncation options
 * @returns Truncated text
 */
function truncate(text, options) {
    const { length, suffix = '...', preserveWords = false, separator = ' ', } = options;
    if (!text || text.length <= length) {
        return text;
    }
    if (preserveWords) {
        const words = text.split(separator);
        let result = '';
        for (const word of words) {
            if ((result + word + suffix).length <= length) {
                result += (result ? separator : '') + word;
            }
            else {
                break;
            }
        }
        return result + suffix;
    }
    else {
        return text.substring(0, length - suffix.length) + suffix;
    }
}
/**
 * Reverse a string
 * @param text - Text to reverse
 * @returns Reversed text
 */
function reverse(text) {
    if (!text)
        return '';
    return text.split('').reverse().join('');
}
/**
 * Count words in text
 * @param text - Text to count words in
 * @returns Number of words
 */
function countWords(text) {
    if (!text)
        return 0;
    return text.trim().split(/\s+/).filter(word => word.length > 0).length;
}
/**
 * Count characters in text (with or without spaces)
 * @param text - Text to count characters in
 * @param includeSpaces - Whether to include spaces in count (default: true)
 * @returns Number of characters
 */
function countCharacters(text, includeSpaces = true) {
    if (!text)
        return 0;
    return includeSpaces ? text.length : text.replace(/\s/g, '').length;
}
/**
 * Remove duplicate characters from text
 * @param text - Text to remove duplicates from
 * @param caseSensitive - Whether to consider case (default: false)
 * @returns Text with duplicate characters removed
 */
function removeDuplicates(text, caseSensitive = false) {
    if (!text)
        return '';
    const seen = new Set();
    const result = [];
    for (const char of text) {
        const key = caseSensitive ? char : char.toLowerCase();
        if (!seen.has(key)) {
            seen.add(key);
            result.push(char);
        }
    }
    return result.join('');
}
/**
 * Remove duplicate words from text
 * @param text - Text to remove duplicate words from
 * @param caseSensitive - Whether to consider case (default: false)
 * @returns Text with duplicate words removed
 */
function removeDuplicateWords(text, caseSensitive = false) {
    if (!text)
        return '';
    const words = text.split(/\s+/);
    const seen = new Set();
    const result = [];
    for (const word of words) {
        const key = caseSensitive ? word : word.toLowerCase();
        if (!seen.has(key)) {
            seen.add(key);
            result.push(word);
        }
    }
    return result.join(' ');
}
/**
 * Mask text according to a pattern
 * @param text - Text to mask
 * @param options - Masking options
 * @returns Masked text
 */
function mask(text, options) {
    const { pattern, placeholder = '*', reverse = false } = options;
    if (!text || !pattern)
        return text;
    let result = '';
    let textIndex = reverse ? text.length - 1 : 0;
    for (let i = 0; i < pattern.length; i++) {
        const patternChar = pattern[i];
        if (patternChar === '#') {
            if (reverse) {
                if (textIndex >= 0) {
                    result = text[textIndex] + result;
                    textIndex--;
                }
                else {
                    result = placeholder + result;
                }
            }
            else {
                if (textIndex < text.length) {
                    result += text[textIndex];
                    textIndex++;
                }
                else {
                    result += placeholder;
                }
            }
        }
        else {
            result += patternChar;
        }
    }
    return result;
}
/**
 * Format text according to common patterns
 * @param text - Text to format
 * @param options - Formatting options
 * @returns Formatted text
 */
function format(text, options) {
    const { type, format: formatString, locale = 'en-US' } = options;
    if (!text)
        return '';
    switch (type) {
        case 'phone':
            return formatPhone(text, formatString);
        case 'credit-card':
            return formatCreditCard(text, formatString);
        case 'ssn':
            return formatSSN(text);
        case 'zip':
            return formatZip(text);
        case 'currency':
            return formatCurrency(text, locale);
        default:
            return text;
    }
}
/**
 * Format phone number
 * @param phone - Phone number to format
 * @param format - Format pattern (default: '(###) ###-####')
 * @returns Formatted phone number
 */
function formatPhone(phone, format = '(###) ###-####') {
    const digits = phone.replace(/\D/g, '');
    return mask(digits, { pattern: format });
}
/**
 * Format credit card number
 * @param card - Credit card number to format
 * @param format - Format pattern (default: '#### #### #### ####')
 * @returns Formatted credit card number
 */
function formatCreditCard(card, format = '#### #### #### ####') {
    const digits = card.replace(/\D/g, '');
    return mask(digits, { pattern: format });
}
/**
 * Format SSN
 * @param ssn - SSN to format
 * @returns Formatted SSN
 */
function formatSSN(ssn) {
    const digits = ssn.replace(/\D/g, '');
    return mask(digits, { pattern: '###-##-####' });
}
/**
 * Format ZIP code
 * @param zip - ZIP code to format
 * @returns Formatted ZIP code
 */
function formatZip(zip) {
    const digits = zip.replace(/\D/g, '');
    if (digits.length === 9) {
        return mask(digits, { pattern: '#####-####' });
    }
    return mask(digits, { pattern: '#####' });
}
/**
 * Format currency
 * @param amount - Amount to format
 * @param locale - Locale for formatting
 * @returns Formatted currency
 */
function formatCurrency(amount, locale) {
    const num = parseFloat(amount);
    if (isNaN(num))
        return amount;
    return new Intl.NumberFormat(locale, {
        style: 'currency',
        currency: 'USD',
    }).format(num);
}
/**
 * Capitalize first letter of each word
 * @param text - Text to capitalize
 * @returns Capitalized text
 */
function capitalize(text) {
    if (!text)
        return '';
    return text
        .split(' ')
        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
        .join(' ');
}
/**
 * Capitalize first letter of first word only
 * @param text - Text to capitalize
 * @returns Text with first letter capitalized
 */
function capitalizeFirst(text) {
    if (!text)
        return '';
    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
}
/**
 * Remove extra whitespace from text
 * @param text - Text to clean
 * @returns Cleaned text
 */
function removeExtraWhitespace(text) {
    if (!text)
        return '';
    return text.replace(/\s+/g, ' ').trim();
}
/**
 * Remove all whitespace from text
 * @param text - Text to clean
 * @returns Text without whitespace
 */
function removeWhitespace(text) {
    if (!text)
        return '';
    return text.replace(/\s/g, '');
}
/**
 * Escape HTML special characters
 * @param text - Text to escape
 * @returns Escaped text
 */
function escapeHtml(text) {
    if (!text)
        return '';
    const htmlEscapes = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        "'": '&#39;',
    };
    return text.replace(/[&<>"']/g, char => htmlEscapes[char]);
}
/**
 * Unescape HTML special characters
 * @param text - Text to unescape
 * @returns Unescaped text
 */
function unescapeHtml(text) {
    if (!text)
        return '';
    const htmlUnescapes = {
        '&amp;': '&',
        '&lt;': '<',
        '&gt;': '>',
        '&quot;': '"',
        '&#39;': "'",
    };
    return text.replace(/&amp;|&lt;|&gt;|&quot;|&#39;/g, entity => htmlUnescapes[entity]);
}

// Export all types
// Default export with all utilities
const artytext = {
    // Password utilities
    generatePassword,
    generateMemorablePassword,
    checkPasswordStrength,
    // Slug utilities
    generateSlug,
    generateUniqueSlug,
    generateRandomSlug,
    slugToText,
    isValidSlug,
    // Random utilities
    randomInt,
    randomFloat,
    randomString,
    randomNumberString,
    randomHex,
    randomUUID,
    randomColor,
    randomRGB,
    randomItem,
    randomItems,
    randomBoolean,
    randomDate,
    // Case utilities
    changeCase,
    toCamelCase,
    toKebabCase,
    toSnakeCase,
    toPascalCase,
    toTitleCase,
    toSentenceCase,
    toAlternatingCase,
    toSpongeCase,
    toDotCase,
    toConstantCase,
    // Text utilities
    truncate,
    reverse,
    countWords,
    countCharacters,
    removeDuplicates,
    removeDuplicateWords,
    mask,
    format,
    capitalize,
    capitalizeFirst,
    removeExtraWhitespace,
    removeWhitespace,
    escapeHtml,
    unescapeHtml,
};

exports.capitalize = capitalize;
exports.capitalizeFirst = capitalizeFirst;
exports.changeCase = changeCase;
exports.checkPasswordStrength = checkPasswordStrength;
exports.countCharacters = countCharacters;
exports.countWords = countWords;
exports["default"] = artytext;
exports.escapeHtml = escapeHtml;
exports.format = format;
exports.generateMemorablePassword = generateMemorablePassword;
exports.generatePassword = generatePassword;
exports.generateRandomSlug = generateRandomSlug;
exports.generateSlug = generateSlug;
exports.generateUniqueSlug = generateUniqueSlug;
exports.isValidSlug = isValidSlug;
exports.mask = mask;
exports.randomBoolean = randomBoolean;
exports.randomColor = randomColor;
exports.randomDate = randomDate;
exports.randomFloat = randomFloat;
exports.randomHex = randomHex;
exports.randomInt = randomInt;
exports.randomItem = randomItem;
exports.randomItems = randomItems;
exports.randomNumberString = randomNumberString;
exports.randomRGB = randomRGB;
exports.randomString = randomString;
exports.randomUUID = randomUUID;
exports.removeDuplicateWords = removeDuplicateWords;
exports.removeDuplicates = removeDuplicates;
exports.removeExtraWhitespace = removeExtraWhitespace;
exports.removeWhitespace = removeWhitespace;
exports.reverse = reverse;
exports.slugToText = slugToText;
exports.toAlternatingCase = toAlternatingCase;
exports.toCamelCase = toCamelCase;
exports.toConstantCase = toConstantCase;
exports.toDotCase = toDotCase;
exports.toKebabCase = toKebabCase;
exports.toPascalCase = toPascalCase;
exports.toSentenceCase = toSentenceCase;
exports.toSnakeCase = toSnakeCase;
exports.toSpongeCase = toSpongeCase;
exports.toTitleCase = toTitleCase;
exports.truncate = truncate;
exports.unescapeHtml = unescapeHtml;
//# sourceMappingURL=index.js.map