indusagi-coding-agent 0.1.59 → 0.1.60

package/dist/helpers/string-formatter.js

@@ -1,807 +0,0 @@
-/**
- * @fileoverview String Formatter Utilities
- *
- * Comprehensive string manipulation and formatting utilities for text transformation,
- * case conversion, truncation, padding, and other common string operations.
- *
- * This module provides type-safe, well-tested functions for:
- * - Case conversion (camelCase, snake_case, kebab-case, Title Case)
- * - String truncation and padding
- * - Character manipulation (reverse, capitalize, decapitalize)
- * - String searching and matching
- * - String interpolation patterns
- * - Multi-line text handling
- *
- * @example
- * // Case conversion
- * toTitleCase('hello world') // "Hello World"
- * toCamelCase('hello-world') // "helloWorld"
- * toSnakeCase('helloWorld') // "hello_world"
- * toKebabCase('HelloWorld') // "hello-world"
- *
- * @example
- * // String manipulation
- * truncate('hello world', 8) // "hello..."
- * capitalize('hello') // "Hello"
- * reverse('hello') // "olleh"
- * repeat('ab', 3) // "ababab"
- *
- * @example
- * // Padding and spacing
- * padStart('5', 3, '0') // "005"
- * padEnd('5', 3, '0') // "500"
- * repeat(' ', 4) // "    "
- */
-/**
- * Converts a string to Title Case (each word capitalized)
- *
- * Splits on spaces, hyphens, underscores, and camelCase boundaries.
- * Properly handles multiple delimiters and preserves word order.
- *
- * @param str - The input string to convert
- * @returns The title-cased string
- *
- * @example
- * toTitleCase('hello world') // "Hello World"
- * toTitleCase('hello-world') // "Hello World"
- * toTitleCase('hello_world') // "Hello World"
- * toTitleCase('helloWorld') // "Hello World"
- * toTitleCase('HELLO WORLD') // "Hello World"
- * toTitleCase('hello  world') // "Hello World" (collapses spaces)
- * toTitleCase('') // ""
- * toTitleCase('a') // "A"
- *
- * @throws Does not throw; returns empty string for null/undefined
- */
-export function toTitleCase(str) {
-    if (!str)
-        return '';
-    // Split on common delimiters and camelCase boundaries
-    const words = str
-        .replace(/([a-z])([A-Z])/g, '$1 $2') // camelCase
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2') // HTMLParser -> HTML Parser
-        .replace(/[-_\s]+/g, ' ') // hyphens, underscores, spaces
-        .trim()
-        .split(/\s+/);
-    return words
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join(' ');
-}
-/**
- * Converts a string to camelCase format
- *
- * Useful for JavaScript variable names and object properties.
- * Handles multiple input formats and preserves acronyms intelligently.
- *
- * @param str - The input string to convert
- * @returns The camelCased string
- *
- * @example
- * toCamelCase('hello world') // "helloWorld"
- * toCamelCase('hello-world') // "helloWorld"
- * toCamelCase('hello_world') // "helloWorld"
- * toCamelCase('HelloWorld') // "helloWorld"
- * toCamelCase('HELLO_WORLD') // "helloWorld"
- * toCamelCase('get-user-id') // "getUserId"
- * toCamelCase('') // ""
- * toCamelCase('x') // "x"
- *
- * @edge-cases
- * - Empty strings return empty string
- * - Single characters preserved as lowercase
- * - Multiple consecutive delimiters treated as single
- */
-export function toCamelCase(str) {
-    if (!str)
-        return '';
-    const words = str
-        .replace(/([a-z])([A-Z])/g, '$1 $2')
-        .replace(/[-_\s]+/g, ' ')
-        .trim()
-        .split(/\s+/);
-    if (words.length === 0)
-        return '';
-    // First word lowercase, rest title case
-    return (words[0].toLowerCase() +
-        words
-            .slice(1)
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-            .join(''));
-}
-/**
- * Converts a string to snake_case format
- *
- * Useful for Python variable names, database columns, and file names.
- * Handles acronyms and consecutive uppercase letters.
- *
- * @param str - The input string to convert
- * @returns The snake_cased string
- *
- * @example
- * toSnakeCase('HelloWorld') // "hello_world"
- * toSnakeCase('hello world') // "hello_world"
- * toSnakeCase('hello-world') // "hello_world"
- * toSnakeCase('helloWorld') // "hello_world"
- * toSnakeCase('HTMLParser') // "html_parser"
- * toSnakeCase('getHTTPResponseCode') // "get_http_response_code"
- * toSnakeCase('') // ""
- *
- * @edge-cases
- * - Consecutive uppercase letters treated as acronym
- * - Preserves existing underscores
- * - Collapses multiple delimiters
- */
-export function toSnakeCase(str) {
-    if (!str)
-        return '';
-    return str
-        .replace(/([a-z])([A-Z])/g, '$1_$2') // camelCase
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2') // HTMLParser
-        .replace(/[-\s]+/g, '_') // hyphens, spaces
-        .toLowerCase();
-}
-/**
- * Converts a string to kebab-case format
- *
- * Useful for URL slugs, CSS class names, and configuration keys.
- * Similar to snake_case but uses hyphens instead of underscores.
- *
- * @param str - The input string to convert
- * @returns The kebab-cased string
- *
- * @example
- * toKebabCase('HelloWorld') // "hello-world"
- * toKebabCase('hello world') // "hello-world"
- * toKebabCase('hello_world') // "hello-world"
- * toKebabCase('helloWorld') // "hello-world"
- * toKebabCase('get-user-data') // "get-user-data"
- * toKebabCase('GetUserData') // "get-user-data"
- * toKebabCase('') // ""
- *
- * @edge-cases
- * - URL-safe; suitable for web slugs
- * - Collapses multiple delimiters
- */
-export function toKebabCase(str) {
-    if (!str)
-        return '';
-    return str
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
-        .replace(/[_\s]+/g, '-')
-        .toLowerCase();
-}
-/**
- * Truncates a string to a maximum length with optional ellipsis
- *
- * Intelligently handles word boundaries when requested.
- * Preserves readability by truncating at word ends when possible.
- *
- * @param str - The input string to truncate
- * @param maxLength - Maximum length of result (including ellipsis if added)
- * @param ellipsis - String to append if truncated (default: '...')
- * @param wordBoundary - If true, truncate at word boundary (default: true)
- * @returns The truncated string
- *
- * @example
- * truncate('hello world', 8) // "hello..."
- * truncate('hello world', 11) // "hello world"
- * truncate('hello world', 8, '…') // "hello…"
- * truncate('hello world', 8, '...', false) // "hello..." (no word boundary)
- * truncate('supercalifragilisticexpialidocious', 10) // "supercali..."
- * truncate('', 5) // ""
- * truncate('hi', 10) // "hi"
- *
- * @edge-cases
- * - If maxLength < ellipsis.length, returns ellipsis truncated to maxLength
- * - Word boundary mode may result in shorter strings
- * - Empty strings return empty string
- */
-export function truncate(str, maxLength, ellipsis = '...', wordBoundary = true) {
-    if (!str || maxLength < 1)
-        return str;
-    if (str.length <= maxLength)
-        return str;
-    const truncateLength = Math.max(0, maxLength - ellipsis.length);
-    if (truncateLength === 0)
-        return ellipsis.slice(0, maxLength);
-    let truncated = str.slice(0, truncateLength);
-    if (wordBoundary) {
-        // Find the last space in the truncated portion
-        const lastSpace = truncated.lastIndexOf(' ');
-        if (lastSpace > 0) {
-            truncated = truncated.slice(0, lastSpace);
-        }
-    }
-    return truncated + ellipsis;
-}
-/**
- * Pads the start of a string with a fill string
- *
- * Complements JavaScript's native padStart with custom handling.
- * Useful for formatting numbers, codes, and aligned output.
- *
- * @param str - The input string to pad
- * @param length - Target length
- * @param fillStr - String to repeat for padding (default: ' ')
- * @returns The padded string
- *
- * @example
- * padStart('5', 3, '0') // "005"
- * padStart('42', 4, '0') // "0042"
- * padStart('hello', 10) // "     hello"
- * padStart('hello', 3) // "hello" (no padding if already longer)
- * padStart('', 3, '-') // "---"
- * padStart('a', 5, 'xy') // "xyxya"
- *
- * @edge-cases
- * - If target length is less than string length, returns original
- * - Multiple character fill strings repeat as needed
- */
-export function padStart(str, length, fillStr = ' ') {
-    if (!fillStr || str.length >= length)
-        return str;
-    const padLength = length - str.length;
-    const fill = fillStr.repeat(Math.ceil(padLength / fillStr.length));
-    return fill.slice(0, padLength) + str;
-}
-/**
- * Pads the end of a string with a fill string
- *
- * Opposite of padStart. Useful for right-aligned formatting.
- *
- * @param str - The input string to pad
- * @param length - Target length
- * @param fillStr - String to repeat for padding (default: ' ')
- * @returns The padded string
- *
- * @example
- * padEnd('5', 3, '0') // "500"
- * padEnd('hello', 10) // "hello     "
- * padEnd('hello', 3) // "hello" (no padding if already longer)
- * padEnd('', 3, '-') // "---"
- * padEnd('a', 5, 'xy') // "axyxy"
- *
- * @edge-cases
- * - If target length is less than string length, returns original
- * - Multiple character fill strings repeat as needed
- */
-export function padEnd(str, length, fillStr = ' ') {
-    if (!fillStr || str.length >= length)
-        return str;
-    const padLength = length - str.length;
-    const fill = fillStr.repeat(Math.ceil(padLength / fillStr.length));
-    return str + fill.slice(0, padLength);
-}
-/**
- * Repeats a string a specified number of times
- *
- * Native alternative with better error handling.
- *
- * @param str - The string to repeat
- * @param count - Number of times to repeat (default: 1)
- * @returns The repeated string
- *
- * @example
- * repeat('ab', 3) // "ababab"
- * repeat('x', 5) // "xxxxx"
- * repeat(' ', 4) // "    "
- * repeat('hello', 0) // ""
- * repeat('', 5) // ""
- * repeat('-', 10) // "----------"
- *
- * @edge-cases
- * - Zero or negative count returns empty string
- * - Empty string repeated returns empty string
- */
-export function repeat(str, count = 1) {
-    if (count <= 0 || !str)
-        return '';
-    return str.repeat(Math.max(0, count));
-}
-/**
- * Capitalizes the first character of a string
- *
- * Leaves remaining characters unchanged (unlike toTitleCase).
- *
- * @param str - The input string
- * @returns String with first character uppercase
- *
- * @example
- * capitalize('hello') // "Hello"
- * capitalize('HELLO') // "HELLO"
- * capitalize('helloWorld') // "HelloWorld"
- * capitalize('') // ""
- * capitalize('a') // "A"
- * capitalize('already Capitalized') // "Already Capitalized"
- *
- * @edge-cases
- * - Empty string returns empty string
- * - Doesn't change case of remaining characters
- */
-export function capitalize(str) {
-    if (!str)
-        return '';
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
- * Decapitalizes the first character of a string
- *
- * Opposite of capitalize. Useful for variable naming.
- *
- * @param str - The input string
- * @returns String with first character lowercase
- *
- * @example
- * decapitalize('Hello') // "hello"
- * decapitalize('HELLO') // "hELLO"
- * decapitalize('hello') // "hello"
- * decapitalize('') // ""
- * decapitalize('A') // "a"
- *
- * @edge-cases
- * - Empty string returns empty string
- * - Doesn't change case of remaining characters
- */
-export function decapitalize(str) {
-    if (!str)
-        return '';
-    return str.charAt(0).toLowerCase() + str.slice(1);
-}
-/**
- * Reverses a string character by character
- *
- * Properly handles Unicode and multi-byte characters.
- *
- * @param str - The input string to reverse
- * @returns The reversed string
- *
- * @example
- * reverse('hello') // "olleh"
- * reverse('abc') // "cba"
- * reverse('') // ""
- * reverse('a') // "a"
- * reverse('123') // "321"
- * reverse('hello world') // "dlrow olleh"
- *
- * @edge-cases
- * - Empty string returns empty string
- * - Single character returns same character
- */
-export function reverse(str) {
-    return str.split('').reverse().join('');
-}
-/**
- * Checks if a string starts with a given prefix
- *
- * Case-sensitive by default. Wrapper with optional case-insensitivity.
- *
- * @param str - The string to search
- * @param prefix - The prefix to check for
- * @param caseSensitive - If false, comparison is case-insensitive (default: true)
- * @returns true if string starts with prefix
- *
- * @example
- * startsWith('hello world', 'hello') // true
- * startsWith('hello world', 'world') // false
- * startsWith('Hello World', 'hello', false) // true
- * startsWith('', '') // true
- * startsWith('a', 'abc') // false
- * startsWith('test.js', '.js') // false
- *
- * @edge-cases
- * - Empty prefix always returns true
- * - Empty string only matches empty prefix
- * - Case-insensitive comparison lowercases both sides
- */
-export function startsWith(str, prefix, caseSensitive = true) {
-    if (caseSensitive) {
-        return str.startsWith(prefix);
-    }
-    return str.toLowerCase().startsWith(prefix.toLowerCase());
-}
-/**
- * Checks if a string ends with a given suffix
- *
- * Case-sensitive by default. Wrapper with optional case-insensitivity.
- *
- * @param str - The string to search
- * @param suffix - The suffix to check for
- * @param caseSensitive - If false, comparison is case-insensitive (default: true)
- * @returns true if string ends with suffix
- *
- * @example
- * endsWith('hello world', 'world') // true
- * endsWith('hello world', 'hello') // false
- * endsWith('test.js', '.js') // true
- * endsWith('Test.JS', '.js', false) // true
- * endsWith('', '') // true
- * endsWith('a', 'abc') // false
- *
- * @edge-cases
- * - Empty suffix always returns true
- * - Empty string only matches empty suffix
- * - Case-insensitive comparison lowercases both sides
- */
-export function endsWith(str, suffix, caseSensitive = true) {
-    if (caseSensitive) {
-        return str.endsWith(suffix);
-    }
-    return str.toLowerCase().endsWith(suffix.toLowerCase());
-}
-/**
- * Checks if a string includes a given substring
- *
- * Case-sensitive by default. Wrapper with optional case-insensitivity.
- *
- * @param str - The string to search
- * @param search - The substring to look for
- * @param caseSensitive - If false, comparison is case-insensitive (default: true)
- * @returns true if substring is found
- *
- * @example
- * includes('hello world', 'lo wo') // true
- * includes('hello world', 'xyz') // false
- * includes('Hello World', 'world', false) // true
- * includes('', '') // true
- * includes('test', '') // true
- * includes('JavaScript', 'Script', false) // true
- *
- * @edge-cases
- * - Empty search string always returns true
- * - Empty string only matches empty search
- * - Case-insensitive comparison lowercases both sides
- */
-export function includes(str, search, caseSensitive = true) {
-    if (caseSensitive) {
-        return str.includes(search);
-    }
-    return str.toLowerCase().includes(search.toLowerCase());
-}
-/**
- * Replaces all occurrences of a string pattern
- *
- * Works with string or regex patterns. Simpler than native replace for all occurrences.
- *
- * @param str - The string to search in
- * @param search - String or regex to search for
- * @param replacement - String or function to replace with
- * @returns The modified string
- *
- * @example
- * replaceAll('hello hello', 'hello', 'hi') // "hi hi"
- * replaceAll('a-b-c', '-', ' ') // "a b c"
- * replaceAll('test test test', 'test', 'result') // "result result result"
- * replaceAll('', 'x', 'y') // ""
- * replaceAll('abc', 'x', 'y') // "abc"
- * replaceAll('aaa', 'a', 'b') // "bbb"
- *
- * @edge-cases
- * - Empty search string doesn't replace
- * - Empty replacement removes the pattern
- * - Can use regex with global flag
- */
-export function replaceAll(str, search, replacement) {
-    if (!str || !search)
-        return str;
-    if (typeof search === 'string') {
-        if (!search)
-            return str;
-        return str.split(search).join(typeof replacement === 'string' ? replacement : '');
-    }
-    // For regex, ensure global flag is set
-    const flags = search.global ? search.flags : search.flags + 'g';
-    const regex = new RegExp(search.source, flags);
-    return str.replace(regex, replacement);
-}
-/**
- * Splits a string by a delimiter with optional trimming
- *
- * Useful for parsing comma-separated values and other delimited data.
- *
- * @param str - The string to split
- * @param delimiter - The delimiter to split on
- * @param trim - If true, trim each part (default: false)
- * @returns Array of string parts
- *
- * @example
- * splitStr('a,b,c', ',') // ["a", "b", "c"]
- * splitStr('a, b, c', ',', true) // ["a", "b", "c"]
- * splitStr('a|b|c', '|') // ["a", "b", "c"]
- * splitStr('', ',') // [""]
- * splitStr('abc', ',') // ["abc"]
- * splitStr('a  b  c', '  ') // ["a", "b", "c"]
- *
- * @edge-cases
- * - Empty delimiter returns array with original string
- * - Empty string returns array with empty string
- * - Consecutive delimiters create empty elements
- */
-export function splitStr(str, delimiter, trim = false) {
-    if (!delimiter)
-        return [str];
-    const parts = str.split(delimiter);
-    return trim ? parts.map(part => part.trim()) : parts;
-}
-/**
- * Joins an array of strings with a delimiter
- *
- * Enhanced version of Array.join with filtering options.
- *
- * @param parts - Array of strings to join
- * @param delimiter - The delimiter to use
- * @param filterEmpty - If true, remove empty strings (default: false)
- * @returns The joined string
- *
- * @example
- * joinStr(['a', 'b', 'c'], ',') // "a,b,c"
- * joinStr(['a', '', 'c'], ',') // "a,,c"
- * joinStr(['a', '', 'c'], ',', true) // "a,c"
- * joinStr([], ',') // ""
- * joinStr(['single'], ',') // "single"
- * joinStr(['path', 'to', 'file'], '/') // "path/to/file"
- *
- * @edge-cases
- * - Empty array returns empty string
- * - Single element array returns that element
- * - Filter empty removes all empty strings before joining
- */
-export function joinStr(parts, delimiter, filterEmpty = false) {
-    const filtered = filterEmpty ? parts.filter(p => p.length > 0) : parts;
-    return filtered.join(delimiter);
-}
-/**
- * Counts occurrences of a substring
- *
- * Useful for validation and analysis of string content.
- *
- * @param str - The string to search in
- * @param search - The substring to count
- * @param caseSensitive - If false, comparison is case-insensitive (default: true)
- * @returns Number of occurrences
- *
- * @example
- * countOccurrences('hello hello world', 'hello') // 2
- * countOccurrences('aaa', 'a') // 3
- * countOccurrences('test', 'x') // 0
- * countOccurrences('', 'x') // 0
- * countOccurrences('Hello HELLO hello', 'hello', false) // 3
- * countOccurrences('ababab', 'ab') // 3
- *
- * @edge-cases
- * - Empty search string returns 0
- * - Empty string returns 0
- * - Case-insensitive counts all variations
- */
-export function countOccurrences(str, search, caseSensitive = true) {
-    if (!str || !search)
-        return 0;
-    const searchStr = caseSensitive ? search : search.toLowerCase();
-    const compareStr = caseSensitive ? str : str.toLowerCase();
-    const matches = compareStr.match(new RegExp(searchStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'));
-    return matches ? matches.length : 0;
-}
-/**
- * String interpolation helper
- *
- * Replaces {key} patterns with provided values.
- * Useful for templates and dynamic strings.
- *
- * @param template - Template string with {key} placeholders
- * @param values - Object with key-value pairs
- * @returns The interpolated string
- *
- * @example
- * interpolate('Hello {name}!', { name: 'World' }) // "Hello World!"
- * interpolate('{x} + {y} = {z}', { x: '1', y: '2', z: '3' }) // "1 + 2 = 3"
- * interpolate('No placeholders', {}) // "No placeholders"
- * interpolate('Missing {value}', {}) // "Missing {value}"
- * interpolate('', {}) // ""
- *
- * @edge-cases
- * - Missing keys leave placeholder unchanged
- * - Nested objects converted via toString()
- * - Undefined values become "undefined"
- */
-export function interpolate(template, values) {
-    return template.replace(/{(\w+)}/g, (match, key) => {
-        return key in values ? String(values[key]) : match;
-    });
-}
-/**
- * Removes leading and trailing whitespace
- *
- * Enhanced trim with custom character removal.
- *
- * @param str - The string to trim
- * @param chars - Characters to remove (default: whitespace)
- * @returns The trimmed string
- *
- * @example
- * trimStr('  hello  ') // "hello"
- * trimStr('xxxhelloxxx', 'x') // "hello"
- * trimStr('  hello  ') // "hello"
- * trimStr('') // ""
- * trimStr('---test---', '-') // "test"
- *
- * @edge-cases
- * - Empty string returns empty string
- * - Only specified characters are removed from edges
- */
-export function trimStr(str, chars) {
-    if (!str)
-        return '';
-    if (!chars) {
-        return str.trim();
-    }
-    const charSet = new Set(chars);
-    let start = 0;
-    let end = str.length;
-    while (start < end && charSet.has(str[start]))
-        start++;
-    while (end > start && charSet.has(str[end - 1]))
-        end--;
-    return str.slice(start, end);
-}
-/**
- * Wraps text to fit within a specified width
- *
- * Intelligently breaks long lines while preserving word integrity.
- * Useful for terminal output and formatted text generation.
- *
- * @param str - The string to wrap
- * @param options - Wrapping options
- * @returns The wrapped string
- *
- * @example
- * wrap('hello world this is a test', { width: 10 })
- * // "hello\nworld this\nis a test"
- *
- * wrap('a very long line here', { width: 10, indent: '  ' })
- * // "a very\n  long line\n  here"
- *
- * wrap('word1 word2 word3', { width: 10, wordBoundary: true })
- * // "word1\nword2\nword3"
- *
- * @edge-cases
- * - Words longer than width are broken
- * - Existing line breaks are preserved
- */
-export function wrap(str, options = {}) {
-    const { width = 80, lineBreak = '\n', indent = '', wordBoundary = true } = options;
-    if (width <= 0)
-        return str;
-    const lines = str.split('\n');
-    return lines
-        .map(line => {
-        let result = '';
-        let currentLine = '';
-        const words = line.split(' ');
-        for (const word of words) {
-            if (currentLine.length + word.length + 1 > width) {
-                if (currentLine) {
-                    result += currentLine + lineBreak;
-                    currentLine = indent + word;
-                }
-                else {
-                    // Word is longer than width
-                    currentLine = indent + word;
-                }
-            }
-            else {
-                currentLine = currentLine ? currentLine + ' ' + word : word;
-            }
-        }
-        if (currentLine) {
-            result += currentLine;
-        }
-        return result;
-    })
-        .join(lineBreak);
-}
-/**
- * Escapes special regex characters in a string
- *
- * Useful for creating regex patterns from user input.
- *
- * @param str - The string to escape
- * @returns The escaped string safe for regex
- *
- * @example
- * escapeRegex('(test)') // "\\(test\\)"
- * escapeRegex('[a-z]') // "\\[a-z\\]"
- * escapeRegex('price: $5.00') // "price: \\$5\\.00"
- * escapeRegex('') // ""
- *
- * @edge-cases
- * - All regex special characters are escaped
- * - Empty string returns empty string
- */
-export function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Strips HTML tags from a string
- *
- * Simple tag removal; for complex HTML use a proper parser.
- *
- * @param str - The string with HTML tags
- * @returns The text content without tags
- *
- * @example
- * stripHtml('<p>Hello <b>World</b></p>') // "Hello World"
- * stripHtml('No tags here') // "No tags here"
- * stripHtml('<script>alert("xss")</script>') // "alert("xss")"
- * stripHtml('') // ""
- *
- * @edge-cases
- * - Doesn't validate HTML
- * - Removes content inside tags
- * - For security-sensitive use, use htmlspecialchars
- */
-export function stripHtml(str) {
-    if (!str)
-        return '';
-    return str.replace(/<[^>]*>/g, '');
-}
-/**
- * Escapes HTML special characters
- *
- * Makes text safe for insertion into HTML.
- *
- * @param str - The string to escape
- * @returns The escaped string
- *
- * @example
- * escapeHtml('<script>') // "&lt;script&gt;"
- * escapeHtml('Hello & Goodbye') // "Hello &amp; Goodbye"
- * escapeHtml('Price: $5.00') // "Price: $5.00"
- * escapeHtml('') // ""
- * escapeHtml('"quoted"') // "&quot;quoted&quot;"
- *
- * @edge-cases
- * - Critical for preventing XSS vulnerabilities
- * - Converts &, <, >, ", '
- */
-export function escapeHtml(str) {
-    if (!str)
-        return '';
-    const map = {
-        '&': '&amp;',
-        '<': '&lt;',
-        '>': '&gt;',
-        '"': '&quot;',
-        "'": '&#039;',
-    };
-    return str.replace(/[&<>"']/g, char => map[char]);
-}
-/**
- * Unescapes HTML special characters
- *
- * Reverses escapeHtml transformation.
- *
- * @param str - The escaped HTML string
- * @returns The unescaped string
- *
- * @example
- * unescapeHtml('&lt;script&gt;') // "<script>"
- * unescapeHtml('Hello &amp; Goodbye') // "Hello & Goodbye"
- * unescapeHtml('&quot;quoted&quot;') // ""quoted""
- */
-export function unescapeHtml(str) {
-    if (!str)
-        return '';
-    const map = {
-        '&amp;': '&',
-        '&lt;': '<',
-        '&gt;': '>',
-        '&quot;': '"',
-        '&#039;': "'",
-    };
-    let result = str;
-    for (const [entity, char] of Object.entries(map)) {
-        result = result.replace(new RegExp(entity, 'g'), char);
-    }
-    return result;
-}
-//# sourceMappingURL=string-formatter.js.map