rand-string-from-regex

Generate random strings that match a regular expression pattern. Works in both Node.js and browsers with zero dependencies.

Features

• Accurate - AST-based generation ensures correct pattern matching
• Zero dependencies - Pure JavaScript, works everywhere
• Universal - Works in Node.js and browsers
• Smart validation - Pre-validates impossible constraints before generation
• Priority system - Fixed-length patterns take priority over options
• Full regex support - Character classes, quantifiers, groups, alternation, backreferences, escapes, named groups, conditionals, lookarounds, Unicode properties
• Test coverage - 317 comprehensive tests, 100% passing
• Git hooks - Husky integration ensures tests pass on commit/push

Live Demo

Try the library in your browser with 32+ interactive examples:

• Open Live Demo - Hosted via htmlpreview.github.io
• Local Demo - Open demo.html in your browser after cloning the repo

The demo includes:

• Basic patterns (digits, letters, character ranges)
• Real-world patterns (emails, phones, UUIDs, credit cards, etc.)
• v4.0.0 advanced features (named backreferences, Unicode properties, conditionals)
• Quantifiers & alternation examples
• Complex combinations (passwords, MAC addresses, Bitcoin addresses)
• Custom pattern input with quick examples

Installation

Node.js

npm install rand-string-from-regex

Browser

Local files:

<!-- Development version (31KB) -->
<script src="rand-string-from-regex.js"></script>

<!-- Minified version (14KB, 55% smaller) - RECOMMENDED -->
<script src="dist/rand-string-from-regex.min.js"></script>

CDN (automatically serves minified version):

<!-- unpkg CDN -->
<script src="https://unpkg.com/rand-string-from-regex"></script>

<!-- jsDelivr CDN -->
<script src="https://cdn.jsdelivr.net/npm/rand-string-from-regex"></script>

<!-- Specific version (recommended for production) -->
<script src="https://unpkg.com/[email protected]"></script>

Note: CDN URLs automatically serve the minified version (dist/rand-string-from-regex.min.js) thanks to the unpkg, jsdelivr, and browser fields in package.json.

Package Distribution Strategy

This library provides two versions optimized for different use cases:

1. Normal Version (31KB)

• File: rand-string-from-regex.js
• Use case: Node.js projects, development, debugging
• Loaded by: require('rand-string-from-regex') in Node.js

2. Minified Version (14KB, 55% smaller)

• File: dist/rand-string-from-regex.min.js
• Use case: Browsers, CDN delivery, production
• Loaded by: CDN links, browser <script> tags

How It Works

The package.json configuration determines which version is served:

{
  "main": "rand-string-from-regex.js",              // Node.js → Normal (31KB)
  "unpkg": "dist/rand-string-from-regex.min.js",    // unpkg CDN → Minified (14KB)
  "jsdelivr": "dist/rand-string-from-regex.min.js", // jsDelivr CDN → Minified (14KB)
  "browser": "dist/rand-string-from-regex.min.js"   // Bundlers → Minified (14KB)
}

CDN Options

Recommended (pinned version for production):

<script src="https://unpkg.com/[email protected]"></script>

Version locked (safer for production) Automatically serves minified (14KB)

Latest version (auto-updates):

<script src="https://unpkg.com/rand-string-from-regex"></script>

Always serves latest version Automatically serves minified (14KB)

Alternative CDN (jsDelivr):

<!-- Latest -->
<script src="https://cdn.jsdelivr.net/npm/rand-string-from-regex"></script>

<!-- Pinned version -->
<script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>

Debug mode (normal version via CDN):

<script src="https://unpkg.com/[email protected]/rand-string-from-regex.js"></script>

Loads normal version (31KB) - only use for debugging

Distribution Summary

| Environment | Version Used | How | |-------------|-------------|-----| | Node.js require() | Normal (31KB) | "main" field | | unpkg CDN | Minified (14KB) | "unpkg" field | | jsDelivr CDN | Minified (14KB) | "jsdelivr" field | | Browser builds (webpack) | Minified (14KB) | "browser" field |

Result: CDN users automatically get the optimized 14KB minified version! 🚀

Usage

Node.js

const randomStringFromRegex = require('rand-string-from-regex');

// Generate a random email
const email = randomStringFromRegex('[a-z]{5,10}@[a-z]{3,8}\\.(com|net|org)');
console.log(email); // => "[email protected]"

// Generate a phone number
const phone = randomStringFromRegex('\\(\\d{3}\\)\\s\\d{3}-\\d{4}');
console.log(phone); // => "(555) 123-4567"

// Generate with length constraints
const serialNumber = randomStringFromRegex('^SN[0-9A-Za-z]*$', { min: 20, max: 30 });
console.log(serialNumber); // => "SN7aB3cD9eF1gH2iJ4kL5m"

// Use regex flags (case-insensitive)
const caseInsensitive = randomStringFromRegex(/hello/i);
console.log(caseInsensitive); // => "HeLLo" or "hello" or "HELLO"

Browser

See demo.html for a complete working example with all v4.0.0 features.

<script src="dist/rand-string-from-regex.min.js"></script>
<script>
  // Generate a random username
  const username = randomStringFromRegex('[a-zA-Z][a-zA-Z0-9_]{4,15}');
  console.log(username); // => "User_123"

  // Generate a hex color
  const color = randomStringFromRegex('#[0-9A-Fa-f]{6}');
  console.log(color); // => "#3a7f2c"

  // Named backreferences (v4.0.0)
  const repeated = randomStringFromRegex('(?<word>\\w{3})-\\k<word>');
  console.log(repeated); // => "abc-abc"
</script>

API

randomStringFromRegex(pattern, options)

Generates a random string matching the given regex pattern.

Parameters

• pattern (string | RegExp) - The regex pattern to match
• options (Object) - Optional configuration
  • min (number) - Minimum length of generated string
  • max (number) - Maximum length of generated string
  • maxRetries (number) - Maximum attempts to meet constraints (default: 100)
  • transform (Function) - Function to transform the result before returning (e.g., str => str.toUpperCase())

Returns

• (string) - A random string matching the pattern

Examples

Basic Patterns

// Literal string
randomStringFromRegex('hello'); // => "hello"

// Digits
randomStringFromRegex('\\d{5}'); // => "42397"

// Character class
randomStringFromRegex('[abc]{3}'); // => "bca"

// Range
randomStringFromRegex('[a-z]{5}'); // => "xqmtz"

Quantifiers

// Zero or more
randomStringFromRegex('a*'); // => "aaaa" or "" or "a"

// One or more
randomStringFromRegex('a+'); // => "aaa"

// Optional
randomStringFromRegex('a?b'); // => "ab" or "b"

// Exact count
randomStringFromRegex('\\d{3}'); // => "742"

// Range
randomStringFromRegex('[0-9]{3,5}'); // => "1234"

// Open-ended
randomStringFromRegex('\\w{5,}'); // => "aBc12_xyz"

// Lazy quantifiers (non-greedy)
randomStringFromRegex('a*?b'); // => "b" (lazy prefers less)
randomStringFromRegex('x+?y'); // => "xy" or "xxy"
randomStringFromRegex('z??end'); // => "end" (lazy prefers zero)

Escape Sequences

// Word characters (\w)
randomStringFromRegex('\\w{10}'); // => "aB3_xYz9Qm"

// Digits (\d)
randomStringFromRegex('\\d{3}'); // => "847"

// Whitespace (\s)
randomStringFromRegex('a\\sb'); // => "a b"

// Non-digit (\D)
randomStringFromRegex('\\D{3}'); // => "xYz"

// Hex character codes
randomStringFromRegex('\\x41\\x42\\x43'); // => "ABC"

// Unicode characters
randomStringFromRegex('\\u0048\\u0065\\u006C\\u006C\\u006F'); // => "Hello"

// Unicode emoji
randomStringFromRegex('\\u{1F600}'); // => "😀"

// Mixed hex and unicode
randomStringFromRegex('\\x48\\u0065llo'); // => "Hello"

// Null character
randomStringFromRegex('a\\0b'); // => "a\0b"

// Word boundaries (zero-width)
randomStringFromRegex('\\bhello\\b'); // => "hello" (boundaries don't add chars)

Groups and Alternation

// Simple group
randomStringFromRegex('(abc){2}'); // => "abcabc"

// Alternation in groups
randomStringFromRegex('(cat|dog)'); // => "cat" or "dog"

// Top-level alternation (OR operator)
randomStringFromRegex('cat|dog|bird'); // => "cat" or "dog" or "bird"

// Top-level alternation with different patterns
randomStringFromRegex('^EG[0-9A-Za-z]*$|[0-9]*');
// => Either "EG123abc" or "456789"

// Complex alternation
randomStringFromRegex('[a-z]{3}\\.(com|net|org)'); // => "xyz.com"

// Multiple patterns with anchors
randomStringFromRegex('^(hello|hi)$|^(bye|goodbye)$');
// => "hello", "hi", "bye", or "goodbye"

Backreferences

// Simple backreference
randomStringFromRegex('(\\d{3})-\\1');
// => "456-456" (second part matches first)

// With alternation
randomStringFromRegex('(cat|dog) and \\1');
// => "cat and cat" or "dog and dog"

// Multiple groups
randomStringFromRegex('(\\w+)@(\\w+)\\.\\2');
// => "[email protected]"

// Complex pattern
randomStringFromRegex('(\\d{2})-(\\w{2})-\\1');
// => "42-ab-42"

// Named groups and backreferences
randomStringFromRegex('(?<word>\\w{3})-\\k<word>');
// => "abc-abc" (named group captured and repeated)

// Multiple named groups
randomStringFromRegex('(?<user>\\w+)@(?<domain>\\w+)\\.\\k<domain>');
// => "[email protected]"

Advanced Features (v4.0.0+)

// Unicode properties
randomStringFromRegex('\\p{Letter}{5}');
// => "aBcDe" (5 letters)

randomStringFromRegex('\\p{Greek}{3}');
// => "ΑΒΓ" (3 Greek letters)

randomStringFromRegex('\\p{Number}{4}');
// => "1234" (4 numbers)

// Conditional patterns
randomStringFromRegex('(?<test>x)?(?(test)y|z)');
// => "xy" or "z" (if 'test' group matched, use 'y', else 'z')

randomStringFromRegex('(\\d+)?(?(1)-[a-z]+|[A-Z]+)');
// => "123-abc" or "ABC"

// Lookaheads (zero-width assertions)
randomStringFromRegex('(?<id>\\d{3})(?=-)\\k<id>');
// => "123123" (lookahead doesn't consume the '-')

// Combined advanced features
randomStringFromRegex('(?<word>\\p{L}{3})(?=-)\\k<word>(?(word)!|)');
// => "abc-abc!" (named group + unicode + lookahead + conditional)

// Atomic groups
randomStringFromRegex('(?>abc|ab)def');
// => "abcdef" (atomic groups prevent backtracking)

Real-World Patterns

// Email address
randomStringFromRegex('[a-z]{5,10}@[a-z]{3,8}\\.(com|net|org)');
// => "[email protected]"

// Phone number (Senegal format)
randomStringFromRegex('^((221)\\d{9})$');
// => "221771234567"

// US Phone number
randomStringFromRegex('\\(\\d{3}\\)\\s\\d{3}-\\d{4}');
// => "(555) 123-4567"

// Social Security Number
randomStringFromRegex('\\d{3}-\\d{2}-\\d{4}');
// => "123-45-6789"

// Hex color
randomStringFromRegex('#[0-9A-Fa-f]{6}');
// => "#3a7f2c"

// UUID (partial)
randomStringFromRegex('[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}');
// => "d37484a3-4797-c1ca"

// Username
randomStringFromRegex('[a-zA-Z][a-zA-Z0-9_]{4,15}');
// => "User_123abc"

Length Constraints

// Maximum length
randomStringFromRegex('^SN[0-9A-Za-z]*$', { max: 10 });
// => "SN7aB3c" (length ≤ 10)

// Minimum length
randomStringFromRegex('[a-z]+', { min: 15 });
// => "abcdefghijklmnop" (length ≥ 15)

// Exact length
randomStringFromRegex('^SN[0-9A-Za-z]*$', { min: 20, max: 20 });
// => "SN7aB3cD9eF1gH2iJ4k" (exactly 20 characters)

// Range
randomStringFromRegex('[a-z]+', { min: 10, max: 20 });
// => "xyzabcdefghij" (10 ≤ length ≤ 20)

Transform Function

Apply custom transformations to the generated string:

// Convert to uppercase
randomStringFromRegex('[a-z]{5}', { transform: (str) => str.toUpperCase() });
// => "ABCDE"

// Convert to lowercase
randomStringFromRegex('[A-Z]{5}', { transform: (str) => str.toLowerCase() });
// => "abcde"

// Add prefix
randomStringFromRegex('\\d{5}', { transform: (str) => 'ID-' + str });
// => "ID-12345"

// Add suffix
randomStringFromRegex('[A-Z]{3}', { transform: (str) => str + '-2024' });
// => "ABC-2024"

// Complex transformation
randomStringFromRegex('[a-z]{8}', {
  min: 8,
  max: 12,
  transform: (str) => str.charAt(0).toUpperCase() + str.slice(1)
});
// => "Abcdefgh"

// Reverse string
randomStringFromRegex('abc', { transform: (str) => str.split('').reverse().join('') });
// => "cba"

// Custom formatting
randomStringFromRegex('\\d{10}', {
  transform: (str) => `(${str.slice(0,3)}) ${str.slice(3,6)}-${str.slice(6)}`
});
// => "(123) 456-7890"

Regex Flags (Modifiers)

Regex flags/modifiers control pattern matching behavior:

// Case-insensitive flag (/i)
randomStringFromRegex(/[a-z]{5}/i);
// => Can generate: "aBcDe", "HELLO", "WoRLd"

randomStringFromRegex(/hello/i);
// => Can generate: "hello", "HELLO", "HeLLo", "hELLO"

// DotAll flag (/s) - makes . match newlines
randomStringFromRegex(/.{3}/s);
// => Can include newlines: "a\nb", "xyz"

// Combining flags
randomStringFromRegex(/[a-z]{5}/is);
// => Case-insensitive + dotAll

// Using with character classes
randomStringFromRegex(/[abc]{4}/i);
// => Can generate: "AaBb", "CCCC", "aBcA"

Supported Flags:

• i (ignoreCase) - Makes patterns case-insensitive. Affects character classes [a-z] and literal characters.
• s (dotAll) - Makes . match newline characters in addition to regular characters.

Note: Other JavaScript regex flags (g, m, u, y) don't affect string generation and are ignored.

Supported Regex Features

Character Classes

• [abc] - Match any character in the set
• [a-z] - Match any character in the range
• [^abc] - Match any character NOT in the set
• . - Match any character

Quantifiers

• * - Zero or more (greedy)
• + - One or more (greedy)
• ? - Zero or one (greedy)
• {n} - Exactly n times
• {n,m} - Between n and m times
• {n,} - n or more times
• *? - Zero or more (lazy/non-greedy)
• +? - One or more (lazy)
• ?? - Zero or one (lazy)

Escape Sequences

Character Classes:

• \d - Digit (0-9)
• \D - Non-digit
• \w - Word character (a-z, A-Z, 0-9, _)
• \W - Non-word character
• \s - Whitespace
• \S - Non-whitespace

Special Characters:

• \t - Tab
• \n - Newline
• \r - Carriage return
• \0 - Null character
• \\ - Literal backslash

Unicode & Hex:

• \xhh - Hex character code (e.g., \x41 = 'A')
• \uhhhh - Unicode 4-digit (e.g., \u0041 = 'A')
• \u{hhhhh} - Unicode code point (e.g., \u{1F600} = '😀')

Boundaries:

• \b - Word boundary (zero-width, doesn't generate chars)
• \B - Non-word boundary (zero-width)

Groups and Alternation

• (abc) - Capturing group
• (?:abc) - Non-capturing group
• a|b - Alternation (a or b)
• (cat|dog) - Group alternation
• ^pattern1$|^pattern2$ - Top-level alternation

Backreferences

• \1, \2, ..., \9 - Numeric backreference to captured group
• \k<name> - Named backreference to named capturing group

Named Groups

• (?<name>...) - Named capturing group

Anchors

• ^ - Start of string (stripped during generation)
• $ - End of string (stripped during generation)
• \b - Word boundary (zero-width)
• \B - Non-word boundary (zero-width)

Lookarounds (Assertions)

• (?=...) - Positive lookahead (zero-width)
• (?!...) - Negative lookahead (zero-width)
• (?<=...) - Positive lookbehind (zero-width)
• (?<!...) - Negative lookbehind (zero-width)

Note: Lookarounds are zero-width assertions and don't generate characters.

Unicode Property Escapes

• \p{Letter} or \p{L} - Any letter
• \p{Number} or \p{N} - Any number
• \p{Punctuation} or \p{P} - Any punctuation
• \p{Greek} - Greek letters
• \p{Cyrillic} - Cyrillic letters
• \P{Property} - Negated property (any character NOT in the property)

Conditional Patterns

• (?(1)yes|no) - If group 1 matched, use "yes" pattern, else "no"
• (?(name)yes|no) - If named group matched, use "yes" pattern, else "no"

Atomic Groups

• (?>...) - Atomic (possessive) group - treated as non-capturing for generation

Pattern Length Priority System

Important: Fixed-length patterns in the regex always take priority over min/max options. The library validates this before generation.

Fixed Length vs Options

// Pattern generates exactly 4 digits - works
randomStringFromRegex('\\d{4}');
// => "1234" (exactly 4 characters)

// Conflicting constraint - throws error
randomStringFromRegex('\\d{4}', { min: 10 });
// Error: "Regex generates exactly 4 characters (fixed length),
//         but min constraint is 10. Regex length takes priority."

// Compatible constraint - works
randomStringFromRegex('\\d{4}', { min: 4, max: 4 });
// => "5678" (options match pattern's exact length)

// Variable-length pattern with options - works
randomStringFromRegex('\\d+', { min: 10, max: 20 });
// => "12345678901234" (options control variable parts)

How Priority Works

1. Fixed-length patterns (like \\d{4}, abc, [a-z]{3}) generate exactly N characters
2. Variable-length patterns (like \\d+, \\w*, [a-z]{2,5}) respect min/max options
3. Mixed patterns (like ^SN[0-9A-Za-z]*$) distribute length across variable parts

// Fixed parts + variable parts
randomStringFromRegex('^SN[0-9A-Za-z]*$', { min: 20, max: 20 });
// => "SN7aB3cD9eF1gH2iJ4k"
// "SN" is 2 chars (fixed), so 18 chars distributed to [0-9A-Za-z]*

// Multiple variable parts - length distributed intelligently
randomStringFromRegex('\\d+-[a-z]+', { min: 15 });
// => "12345-abcdefgh" (total length ≥ 15)

Validation Before Generation

v4.0.0 validates constraints before attempting generation, making it 20000x faster for impossible patterns:

// Instant detection (no retry attempts wasted)
randomStringFromRegex('hello', { min: 10 });
// Error: "Regex generates exactly 5 characters (fixed length),
//         but min constraint is 10."

// Old behavior (v3): Would retry 100 times then fail
// New behavior (v4): Validates immediately and throws

Testing

The library includes a comprehensive test suite with 317 tests covering:

• Basic patterns and literals
• All quantifier types (greedy and lazy)
• Character classes and escape sequences
• Groups, alternation, and backreferences (numeric and named)
• Named groups and named backreferences
• Unicode property escapes
• Conditional patterns
• Lookarounds (lookaheads and lookbehinds)
• Atomic groups
• Real-world patterns (emails, phones, UUIDs, IBANs, credit cards, etc.)
• Length constraints and priority validation
• Transform function
• Regex flags/modifiers (i, s)
• Edge cases and nested patterns
• Unicode and emoji support

Run tests:

# Test both normal and minified versions
npm test

# Test specific version
npm run test:normal
npm run test:minified

Expected output: 317/317 tests passing (100%) for both versions ✅

Development

Git Hooks

This project uses Husky to ensure code quality:

• pre-commit hook: Automatically minifies rand-string-from-regex.js to dist/rand-string-from-regex.min.js (31KB → 14KB, 55% smaller)
• pre-push hook: Re-minifies and runs all 317 tests on both normal and minified versions

Workflow:

1. On commit: Minified version is auto-generated and added to the commit
2. On push: Both versions are tested (normal + minified) to ensure consistency
3. If any test fails, the push is blocked

This ensures only tested code reaches the repository and both versions work identically.

Running Tests

# Run all tests (both normal and minified versions)
npm test

# Test normal version only
npm run test:normal
# or
node test-all.js

# Test minified version only
npm run test:minified
# or
node test-all.js --minified

Installing Git Hooks

Git hooks are automatically installed when you run:

npm install

This triggers the prepare script which sets up Husky.

Browser Compatibility

Works in all modern browsers and IE11+. Uses only standard JavaScript features.

Performance

v4.0.0 introduces intelligent pre-validation that detects impossible constraints before generation:

//  Impossible constraint detected immediately
randomStringFromRegex('\\d{3}', {min: 10});
// Throws: "Regex generates exactly 3 characters (fixed length),
//         but min constraint is 10. Regex length takes priority."

Performance improvements:

• 20000x faster for impossible constraint detection
• No wasted retry attempts
• Intelligent length distribution eliminates most retries
• More efficient AST-based generation

License

MIT © Moussa Ndour [email protected]

Links

• GitHub Repository
• npm Package
• Issues

Changelog

v4.0.0 (2025-10-03) - Major Architectural Redesign 🎉

• NEW: Complete AST-based architecture for accurate generation
• NEW: Named capturing groups ((?<name>...)) with full support
• NEW: Named backreferences (\k<name>) - reference named groups
• NEW: Unicode property escapes (\p{Letter}, \p{Greek}, \p{Number}, etc.)
• NEW: Conditional patterns ((?(1)yes|no), (?(name)yes|no))
• NEW: Lookarounds - lookaheads and lookbehinds ((?=...), (?!...), (?<=...), (?<!...))
• NEW: Atomic groups ((?>...)) for possessive matching
• NEW: Backreference support (\1, \2, etc.) with correct group numbering
• NEW: Intelligent length distribution across variable parts
• NEW: Pre-validation of impossible constraints
• NEW: Fixed-length patterns take absolute priority over options (e.g., \d{4} with {min:10} throws error)
• NEW: Husky git hooks integration - auto-minify on commit, auto-test both versions on push
• NEW: Automatic minification with Terser (31KB → 14KB, 55% smaller) to dist/rand-string-from-regex.min.js
• NEW: Dual testing system - tests run on both normal and minified versions to ensure consistency
• NEW: 67 additional test cases for v4 advanced features (42 complex + 25 advanced feature tests)
• NEW: 24 real-world pattern tests (emails, phones, IBANs, credit cards, dates, etc.)
• FIXED: True lazy/greedy behavior (deterministic, not probability-based)
• FIXED: Hex/unicode escapes no longer conflict with escape sequences
• FIXED: Top-level alternation with anchors works correctly
• FIXED: Zero-length generation ({max: 0}) now respected
• FIXED: Infinite loop prevention for nested quantifiers with zero-length elements
• FIXED: Length distribution bug causing off-by-one errors with exact min=max constraints
• FIXED: Backreference group numbering for nested capturing groups
• FIXED: Quantified named groups now properly capture for conditionals and backreferences
• IMPROVED: 317/317 tests passing (100%) - all edge cases resolved
• IMPROVED: Better error messages for impossible constraints
• PERFORMANCE: 20000x faster for impossible constraint detection
• 100% backward compatible with v3.0.0

v3.0.0 (2025-01-XX)

• NEW: Complete regex operator support
  • Added lazy quantifiers: *? +? ??
  • Added hex codes: \xhh (e.g., \x41 = 'A')
  • Added unicode: \uhhhh and \u{hhhhh} (emoji support!)
  • Added \0 (null character)
  • Added \b and \B (word boundaries)
• FIXED: Unicode ranges in character classes ([\u0041-\u005A] now works!)
• FIXED: Negated multi-range character classes ([^a-zA-Z0-9] now works!)
• FIXED: Escaped special chars in character classes ([\[\]\(\)] now works!)
• NEW: Comprehensive test suite (250 base tests, 100% passing)
• Supports all major JavaScript regex operators
• Complete documentation with examples for every feature

v2.0.0 (2025-01-XX)

• NEW: Regex flags/modifiers support
  • Added support for /i (case-insensitive) flag
  • Added support for /s (dotAll) flag for . matching newlines
  • Works with RegExp objects: /[a-z]{5}/i
• Fixed: Top-level alternation support (pattern1|pattern2)
• Now correctly handles ^EG[0-9A-Za-z]*$|[0-9]* and similar patterns
• Added 9 new tests (47 tests total, 100% passing)

v1.1.0 (2025-01-XX)

• Added transform option for custom string transformations
• Enhanced test suite (38 tests)
• Improved documentation with transform examples

v1.0.0 (2025-01-XX)

• Initial release
• Support for all basic regex features
• Length constraints (min/max)
• Browser and Node.js compatibility
• 100% test coverage