indusagi-coding-agent 0.1.23 → 0.1.25

package/dist/utils/string-formatter.js

@@ -0,0 +1,806 @@
+/**
+ * @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: false)
+ * @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, '...', true) // "hello..." (word boundary)
+ * truncate('supercalifragilisticexpialidocious', 10) // "supercali..."
+ * truncate('', 5) // ""
+ * truncate('hi', 10) // "hi"
+ *
+ * @edge-cases
+ * - If maxLength < ellipsis.length, returns ellipsis
+ * - Word boundary mode may result in shorter strings
+ * - Empty strings return empty string
+ */
+export function truncate(str, maxLength, ellipsis = '...', wordBoundary = false) {
+    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;
+    let truncated = str.slice(0, truncateLength);
+    if (wordBoundary) {
+        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