local pattern = regex.new('abc|abcdef')
local match = pattern.match('abcdef')
-- match[1] = "abc" (not "abcdef")

local pattern = regex.new('cat|dog|bird|fish')

local pattern = regex.new('[A-Z]')     -- Matches any uppercase letter A-Z
local pattern = regex.new('[0-9]')     -- Matches any digit
local pattern = regex.new('[a-zA-Z]')  -- Matches any letter

local pattern = regex.new('[E-F]', regex.ICASE)
-- Matches 'E', 'F', 'e', 'f', and any Unicode case variants

local pattern = regex.new('[\\d!\"#$%&\'()]')  -- Matches digits or punctuation

-- Match lowercase Latin letters only
local pattern = regex.new('[\\p{sc=Latin}&&\\p{Ll}]')
-- Matches: a, b, c, ..., z, ñ, ø, etc. (lowercase Latin)
-- Does NOT match: A, B, C, ... (not lowercase)

-- Match ASCII letters only (not extended Latin)
local pattern = regex.new('[\\p{sc=Latin}&&[A-Za-z]]')

-- Match Latin letters that are NOT lowercase
local pattern = regex.new('[\\p{sc=Latin}--\\p{Ll}]')
-- Matches: A, B, C, ..., Z (uppercase, titlecase, etc.)
-- Does NOT match: a, b, c, ... (lowercase excluded)

-- Match letters except vowels
local pattern = regex.new('[A-Za-z--[AEIOUaeiou]]')
-- Matches: consonants only

local pattern = regex.new('[a-z\\q{ch|chocolate}]')
-- When matching "chocolate", matches the full word "chocolate"
-- Not "ch" followed by "ocolate"

-- Match common digraphs or single letters
local pattern = regex.new('[a-z\\q{ch|sh|th|ph}]+')

-- Match emoji sequences or letters
local pattern = regex.new('[A-Z\\q{:-)|:-(|:-D}]')

-- Valid: nested classes with operators
local pattern = regex.new('[\\p{sc=Latin}--[a-z]]')

-- Valid: nested union and subtraction
local pattern = regex.new('[A[B--C]D]')

-- INVALID: mixing && and -- at same level
[AB--CD]           -- Error: union (AB) then subtraction (--)

-- VALID: operators in different nesting levels
[[AB]--[CD]]       -- OK: separate nesting levels
[A[B--C]D]         -- OK: subtraction inside union

-- Valid: multiple subtractions at same level
[\\p{sc=Latin}--\\p{Lu}--[a-z]]

-- Correct
local pattern = regex.new('[\\(\\)\\[\\]\\{\\}]')

-- Incorrect (throws error_noescape)
local pattern = regex.new('[(]')

local pattern = regex.new('a.*b')
local match = pattern.match('axxxbxxxb')
-- match[1] = "axxxbxxxb" (matches up to the last 'b')

local pattern = regex.new('a.*?b')
local match = pattern.match('axxxbxxxb')
-- match[1] = "axxxb" (stops at the first 'b')

-- Match one or more digits
local pattern = regex.new('\\d+')

-- Match optional sign followed by digits
local pattern = regex.new('[+-]?\\d+')

-- Match exactly 3 letters
local pattern = regex.new('[A-Za-z]{3}')

-- Match 2 to 4 word characters (greedy)
local pattern = regex.new('\\w{2,4}')

-- Match 2 to 4 word characters (non-greedy)
local pattern = regex.new('\\w{2,4}?')

-- Match at least 5 digits
local pattern = regex.new('\\d{5,}')

local pattern = regex.new('(?:(a)|(b))+')
local match = pattern.match('ab')
-- match[1] = "ab" (full match)
-- match[2] = "" (empty, last iteration captured 'b', not 'a')
-- match[3] = "b" (last iteration captured 'b')

local pattern = regex.new('(\\d{3})-(\\d{3})-(\\d{4})')
local match = pattern.match('555-123-4567')
-- match[1] = "555-123-4567" (full match, always at index 1)
-- match[2] = "555" (first capturing group)
-- match[3] = "123" (second capturing group)
-- match[4] = "4567" (third capturing group)

local pattern = regex.new('((a)(b))c')
-- Group 1: ((a)(b))
-- Group 2: (a)
-- Group 3: (b)

local pattern = regex.new('(?:tak(?:e|ing))')
-- Matches "take" or "taking" without capturing

local pattern = regex.new('(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})')
local match = pattern.match('2025-10-14')
-- match[1] = "2025-10-14"
-- match[2] = "2025" (group 1, also accessible as 'year')
-- match[3] = "10" (group 2, also accessible as 'month')
-- match[4] = "14" (group 3, also accessible as 'day')

local pattern = regex.new('(?<year>\\d{4})-\\d{1,2}|\\d{1,2}-(?<year>\\d{4})')
-- Matches "2025-10" or "10-2025"
-- 'year' captures the 4-digit year from either position

local pattern = regex.new('(TO|to)..\\1')
-- Matches "TOMATO" or "tomato" but not "Tomato"
-- \1 refers to captured text from group 1

local pattern = regex.new('(["\']).*?\\1')
-- Matches string in quotes: "hello" or 'hello'
-- But not mixed quotes: "hello'

local pattern = regex.new('(?<quote>["\']).*?\\k<quote>')
-- Same as above, but using named group

local pattern = regex.new('(?:(a)|(b))+')
local match = pattern.match('ab')
-- Only the last iteration's captures are retained
-- match[2] = "" (group 1's last iteration matched nothing)
-- match[3] = "b" (group 2's last iteration matched "b")

-- Case-insensitive only for middle section
local pattern = regex.new('hello(?i:world)THERE')
-- Matches: "helloworldTHERE", "helloWORLDTHERE", "helloWoRlDTHERE"
-- Does NOT match: "HELLOworldthere" (case-sensitive outside group)

-- Combine multiple flags
local pattern = regex.new('(?ims:.*)')
-- Case-insensitive + multiline + dotall for entire group

-- Disable flags
local pattern = regex.new('(?i)hello(?-i:world)')
-- "hello" is case-insensitive, "world" is case-sensitive

-- Match lines starting with "#"
local pattern = regex.new('^#.*', regex.MULTILINE)

-- Match lines ending with ";"
local pattern = regex.new('.*;$', regex.MULTILINE)

-- Match "cat" as a whole word
local pattern = regex.new('\\bcat\\b')
-- Matches: "cat in hat"
-- Does NOT match: "concatenate"

-- Match "cat" not as a whole word
local pattern = regex.new('\\Bcat\\B')
-- Matches: "concatenate"
-- Does NOT match: "cat in hat"

-- Match "a" only if followed by "bc" or "def"
local pattern = regex.new('a(?=bc|def)')
-- Matches: "abc" (captures "a"), "adef" (captures "a")
-- Does NOT match: "axyz"

-- Match "a" only if NOT followed by "bc" or "def"
local pattern = regex.new('a(?!bc|def)')
-- Matches: "axyz" (captures "a")
-- Does NOT match: "abc", "adef"

-- Find & symbols that are not HTML entities
local pattern = regex.new('&(?!amp;|lt;|gt;|#)')
-- Matches bare "&" but not "&", "<", etc.

-- Match "a" only if preceded by "bc" or "de"
local pattern = regex.new('(?<=bc|de)a')
-- Matches: "bca" (captures "a"), "dea" (captures "a")
-- Does NOT match: "xa"

-- Match "a" only if NOT preceded by "bc" or "de"
local pattern = regex.new('(?<!bc|de)a')
-- Matches: "xa" (captures "a")
-- Does NOT match: "bca", "dea"

-- Match words between 3-6 letters containing at least one vowel
local pattern = regex.new('\\b(?=\\w*[aeiou])\\w{3,6}\\b', regex.ICASE)

-- Match integer strings that are not part of larger numbers
local pattern = regex.new('(?<!\\d)\\d+(?!\\d)')

-- Match Latin characters
local pattern = regex.new('\\p{sc=Latin}+')

-- Match Greek characters
local pattern = regex.new('\\p{Script=Greek}+')

-- Match characters used in Latin or Common scripts
local pattern = regex.new('\\p{scx=Latin}+')

-- Match any letter in any script
local pattern = regex.new('\\p{L}+')

-- Match digits in any script
local pattern = regex.new('\\p{Nd}+')

-- Match all punctuation
local pattern = regex.new('\\p{P}+')

-- Match whitespace characters
local pattern = regex.new('\\p{White_Space}+')

-- Match emoji
local pattern = regex.new('\\p{Emoji}')

-- Match characters used in identifiers
local pattern = regex.new('\\p{ID_Start}\\p{ID_Continue}*')

-- Short form
\\p{Lu}              -- Uppercase letter
\\p{sc=Latin}        -- Latin script

-- Long form
\\p{Script=Latin}
\\p{General_Category=Uppercase_Letter}

-- Binary properties
\\p{Emoji}
\\p{White_Space}

-- Valid: string property in positive class
local pattern = regex.new('[\\p{RGI_Emoji}]')

-- INVALID: string property with negation
local pattern = regex.new('[^\\p{RGI_Emoji}]')  -- Throws error_complement

-- INVALID: string property with \P{...}
local pattern = regex.new('\\P{RGI_Emoji}')     -- Throws error_complement

local pattern = regex.new('café', regex.ICASE)
-- Matches: "café", "CAFÉ", "Café", "cAfÉ", etc.

local pattern = regex.new('ß', regex.ICASE)
-- Matches: "ß" and "SS" (German sharp S case-folds to SS)

-- Match all characters in Basic Multilingual Plane
local pattern = regex.new('[\\u0000-\\uFFFF]+')

-- Match emoji range (partial)
local pattern = regex.new('[\\u{1F600}-\\u{1F64F}]+')

local pattern = regex.new('hello', regex.ICASE)
local pattern = regex.new('.*', regex.DOTALL)
local pattern = regex.new('^line', regex.MULTILINE + regex.ICASE)

auto pattern = pf::regex("hello", pf::regex::ICASE);
auto pattern = pf::regex(".*", pf::regex::DOTALL);
auto pattern = pf::regex("^line", pf::regex::MULTILINE | pf::regex::ICASE);

local pattern = regex.new('hello', regex.ICASE)
-- Matches: "hello", "HELLO", "Hello", "HeLLo", etc.

local pattern = regex.new('[a-z]+', regex.ICASE)
-- Matches: "abc", "ABC", "aBc", etc.

local pattern = regex.new('^\\w+', regex.MULTILINE)
-- Without MULTILINE: matches word at start of string only
-- With MULTILINE: matches word at start of string AND after each line terminator

local text = "first line\nsecond line\nthird line"
local pattern = regex.new('^\\w+', regex.MULTILINE)
-- Matches: "first", "second", "third"

local pattern = regex.new('.*', regex.DOTALL)
-- Without DOTALL: .* matches up to (but not including) line terminators
-- With DOTALL: .* matches everything including line terminators

local text = "line 1\nline 2\nline 3"
local pattern = regex.new('.*', regex.DOTALL)
local match = pattern.match(text)
-- match[1] = "line 1\nline 2\nline 3" (entire string)

local pattern = regex.new('\\w+')

-- Replace only first occurrence
local result = pattern.replace('hello world', 'goodbye', regex.REPLACE_FIRST_ONLY)
-- result = "goodbye world"

-- Match only at beginning
local match = pattern.match('hello world', regex.CONTINUOUS)
-- Succeeds (starts at beginning)

local match = pattern.match('  hello', regex.CONTINUOUS)
-- Fails (does not start at beginning)

local pattern = regex.new('^hello', regex.MULTILINE)

-- Normal matching
pattern.test('hello')  -- true (at beginning)

-- With NOT_BEGIN_OF_LINE
pattern.test('hello', regex.NOT_BEGIN_OF_LINE)  -- false (not treated as line start)

local pattern = regex.new('a*')

-- Normal: matches empty string
pattern.test('')  -- true

-- With NOT_NULL: rejects empty match
pattern.test('', regex.NOT_NULL)  -- false

local pattern = regex.new('\\d+')

-- Normal: finds "123" anywhere
pattern.match('  123')  -- Matches "123"

-- With CONTINUOUS: must start at position 0
pattern.match('  123', regex.CONTINUOUS)  -- Fails
pattern.match('123', regex.CONTINUOUS)     -- Succeeds

local pattern = regex.new('\\d+')

-- Normal replace: keeps non-matching text
pattern.replace('a123b456c', 'X')  -- "aXbXc"

-- With REPLACE_NO_COPY: only includes replacements
pattern.replace('a123b456c', 'X', regex.REPLACE_NO_COPY)  -- "XX"

local pattern = regex.new('\\d+')

-- Normal replace: replaces all
pattern.replace('123 456 789', 'X')  -- "X X X"

-- With REPLACE_FIRST_ONLY: replaces only first
pattern.replace('123 456 789', 'X', regex.REPLACE_FIRST_ONLY)  -- "X 456 789"

local pattern = regex.new('\\1(abc)')  -- Valid

local pattern = regex.new('(a)?b\\1')
-- Matches "ab" (group 1 captured nothing, so \1 matches empty string)

-- Valid
local pattern = regex.new('\\0')     -- Matches NULL (U+0000)

-- Invalid (not defined by ECMAScript)
local pattern = regex.new('\\101')   -- Error: invalid escape

local pattern = regex.new('\\x41')    -- 'A' in hexadecimal
local pattern = regex.new('\\u0041')  -- 'A' in Unicode

-- Direct: [\p{sc=Latin}&&\p{Ll}]
-- Alternative: using lookahead
(?=\\p{sc=Latin})\\p{Ll}

-- Direct: [\p{sc=Latin}--\p{Ll}]
-- Alternative: using negative lookahead
(?!\\p{Ll})\\p{sc=Latin}

-- Perl/PCRE: (?>pattern)
-- ECMAScript equivalent: (?=(pattern))\1

for i = 1, 10000 do
   local pattern = regex.new('\\d+')  -- Compiles pattern 10,000 times
   pattern.test(data[i])
end

local pattern = regex.new('\\d+')  -- Compiles pattern once
for i = 1, 10000 do
   pattern.test(data[i])  -- Reuses compiled pattern
end

-- Compiled patterns
local emailPattern = regex.new('[\\w._%+-]+@[\\w.-]+\\.[A-Za-z]{2,}')
local phonePattern = regex.new('\\d{3}-\\d{3}-\\d{4}')
local datePattern = regex.new('\\d{4}-\\d{2}-\\d{2}')

-- Use patterns multiple times efficiently
for _, contact in ipairs(contacts) do
   if emailPattern.test(contact.email) then
      processEmail(contact)
   end
   if phonePattern.test(contact.phone) then
      processPhone(contact)
   end
end

-- Greedy: tries to match as much as possible, then backtracks
local pattern = regex.new('<.*>')
-- Matches: "<tag>content</tag>" as one match (backtracks from end)

-- Non-greedy: stops at first opportunity
local pattern = regex.new('<.*?>')
-- Matches: "<tag>" and "</tag>" separately (no backtracking)

-- Extract tag content efficiently
local pattern = regex.new('<([^>]+)>(.*?)</\\1>')

-- Exponential backtracking on non-match
local pattern = regex.new('(a+)+b')
local text = 'aaaaaaaaaaaaaaaaaac'  -- No 'b' at end
-- This takes exponential time as pattern length increases

-- Faster
local pattern = regex.new('\\d+')

-- Slower (equivalent but not optimised)
local pattern = regex.new('[0-9]+')

-- Complex
local pattern = regex.new('[A-Za-z0-9_]+')

-- Simpler and equivalent
local pattern = regex.new('\\w+')

-- Unanchored: searches entire string
local pattern = regex.new('\\d+')

-- Anchored: only checks from beginning
local pattern = regex.new('^\\d+')

-- Anchored both ends: exact match only
local pattern = regex.new('^\\d+$')

-- Faster: general category
local pattern = regex.new('\\p{L}+')  -- All letters

-- Slower: specific script
local pattern = regex.new('\\p{sc=Latin}+')  -- Latin letters only

local pattern = regex.new('[\\w._%+-]+@[\\w.-]+\\.[A-Za-z]{2,}')
-- Matches: user@example.com, first.last@sub.domain.co.uk

local pattern = regex.new('^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$')
-- Anchored to match entire string

local pattern = regex.new('(https?)://([^/\\s]+)([^\\s]*)')
-- Captures: protocol, domain, path

local match = pattern.match('https://example.com/path?query=value')
-- match[1] = "https://example.com/path?query=value" (full match)
-- match[2] = "https" (protocol)
-- match[3] = "example.com" (domain)
-- match[4] = "/path?query=value" (path)

local pattern = regex.new('(?<protocol>https?)://(?<domain>[^/\\s]+)(?<path>[^\\s]*)')

local match = pattern.match('https://example.com/path')
-- Access by name: match.domain (language binding dependent)
-- Access by number: match[3]

-- Format: 555-123-4567
local pattern = regex.new('\\d{3}-\\d{3}-\\d{4}')

-- With optional country code: +1-555-123-4567
local pattern = regex.new('(\\+1-)?\\d{3}-\\d{3}-\\d{4}')

-- With optional separators (-, ., space, or none)
local pattern = regex.new('\\d{3}[-. ]?\\d{3}[-. ]?\\d{4}')

-- +1234567890 to +123456789012345
local pattern = regex.new('\\+\\d{1,15}')

local pattern = regex.new('\\d{4}-\\d{2}-\\d{2}')
-- Matches: 2025-10-14

-- With validation (basic):
local pattern = regex.new('\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])')
-- Validates month (01-12) and day (01-31)

local pattern = regex.new('(0[1-9]|1[0-2])/(0[1-9]|[12]\\d|3[01])/\\d{4}')
-- Matches: 10/14/2025

local pattern = regex.new('\\d{1,2}[-/]\\d{1,2}[-/]\\d{2,4}')
-- Matches: 10/14/2025, 10-14-25, 1/5/2025

local pattern = regex.new('([01]?\\d|2[0-3]):[0-5]\\d')
-- Matches: 09:30, 23:59, 8:05

-- With optional seconds:
local pattern = regex.new('([01]?\\d|2[0-3]):[0-5]\\d(:[0-5]\\d)?')
-- Matches: 09:30, 09:30:45

local pattern = regex.new('(0?[1-9]|1[0-2]):[0-5]\\d\\s*([AaPp][Mm])')
-- Matches: 9:30 AM, 12:45 PM, 9:30AM

local pattern = regex.new('^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}$')

local pattern = regex.new('^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&]).{8,}$')

local pattern = regex.new('\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b')
-- Matches: 192.168.1.1, 10.0.0.1

-- With validation (0-255 per octet):
local pattern = regex.new('\\b(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\b')

local pattern = regex.new('(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}')
-- Matches full IPv6: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

local pattern = regex.new('<([a-zA-Z][a-zA-Z0-9]*)\\b[^>]*>(.*?)</\\1>')
-- Matches: <div>content</div>, <span class="x">text</span>
-- Captures: tag name (group 1), content (group 2)

local pattern = regex.new('<[^>]+>(.*?)</[^>]+>')
-- Captures content between any tags

local pattern = regex.new('<[a-zA-Z][a-zA-Z0-9]*\\b[^>]*/>')
-- Matches: <br/>, <img src="x" />

local pattern = regex.new('([^,]+),?')
-- Matches fields separated by commas

local pattern = regex.new('(?:^|,)(?:\"([^\"]*(?:\"\"[^\"]*)*)\"|([^,]*))')
-- Handles: "quoted field", unquoted, "field with ""quotes"""

local pattern = regex.new('\\b\\w+\\b')
-- Matches: any word (alphanumeric + underscore)

local pattern = regex.new('\\b[A-Za-z]+\\b')
-- Matches: only alphabetic words

local pattern = regex.new('\\b[A-Za-z]+(?:\'[A-Za-z]+)?\\b')
-- Matches: don't, it's, can't, etc.

local pattern = regex.new('-?\\d+')
-- Matches: 123, -456

local pattern = regex.new('-?\\d+\\.\\d+')
-- Matches: 123.45, -67.89

-- With optional decimal part:
local pattern = regex.new('-?\\d+(?:\\.\\d+)?')
-- Matches: 123, 123.45, -67.89

local pattern = regex.new('-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?')
-- Matches: 1.23e10, -4.5E-6, 123

local pattern = regex.new('^\\s+|\\s+$')
-- Use with replace to remove leading/trailing spaces

local pattern = regex.new('\\s+')
-- Replace with single space to normalize whitespace

local pattern = regex.new('\\s+')
-- Use with split to separate words

local pattern = regex.new('^(/[^/]+)+/?$')
-- Matches: /home/user/file.txt, /usr/local/bin/

local pattern = regex.new('^[A-Za-z]:\\\\(?:[^\\\\/:*?\"<>|]+\\\\)*[^\\\\/:*?\"<>|]*$')
-- Matches: C:\Users\Name\file.txt

local pattern = regex.new('\\.([A-Za-z0-9]+)$')
-- Captures file extension: .txt, .pdf, .jpg

local pattern = regex.new('^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$')
-- Matches: 1.0.0, 2.1.3, 1.0.0-alpha.1, 1.0.0+build.123

local pattern = regex.new('\\d+\\.\\d+(?:\\.\\d+)?')
-- Matches: 1.0, 1.0.5, 2.10.1

-- Invalid: \q is not defined
local pattern = regex.new('\\q')  -- Error: invalid escape sequence

-- Invalid: \c not followed by letter
local pattern = regex.new('\\c5')  -- Error: expected A-Z or a-z after \c

-- Invalid: \x not followed by two hex digits
local pattern = regex.new('\\xGG')  -- Error: expected two hex digits

-- Invalid: code point exceeds maximum
local pattern = regex.new('\\u{110000}')  -- Error: code point > U+10FFFF

-- Valid alternatives:
local pattern = regex.new('q')           -- Literal q
local pattern = regex.new('\\x71')       -- Hex escape for q
local pattern = regex.new('\\u0071')     -- Unicode escape for q

-- Invalid: unclosed bracket
local pattern = regex.new('[abc')  -- Error: missing ]

-- Invalid: extra closing bracket
local pattern = regex.new('abc]')  -- Error: unmatched ]

-- Valid:
local pattern = regex.new('[abc]')       -- Correct bracket pair
local pattern = regex.new('\\]')         -- Escaped bracket (literal)

-- Invalid: unclosed parenthesis
local pattern = regex.new('(abc')  -- Error: missing )

-- Invalid: extra closing parenthesis
local pattern = regex.new('abc)')  -- Error: unmatched )

-- Valid:
local pattern = regex.new('(abc)')       -- Correct parenthesis pair
local pattern = regex.new('\\(abc\\)')   -- Escaped parentheses (literals)

-- Invalid: unclosed brace
local pattern = regex.new('a{3')  -- Error: missing }

-- Valid:
local pattern = regex.new('a{3}')        -- Correct quantifier
local pattern = regex.new('\\{3\\}')     -- Escaped braces (literals)

-- Invalid: n > m in range
local pattern = regex.new('a{5,3}')  -- Error: 5 > 3

-- Invalid: missing n
local pattern = regex.new('a{,5}')  -- Error: must specify n

-- Valid:
local pattern = regex.new('a{3,5}')      -- n ≤ m
local pattern = regex.new('a{3,}')       -- n or more (no maximum)
local pattern = regex.new('a{3}')        -- exactly n

-- Invalid: reversed range
local pattern = regex.new('[z-a]')  -- Error: z (U+007A) > a (U+0061)

-- Invalid: empty range
local pattern = regex.new('[\\u0100-\\u0010]')  -- Error: start > end

-- Valid:
local pattern = regex.new('[a-z]')       -- Correct range
local pattern = regex.new('[z]')         -- Single character (no range)

-- Invalid: group doesn't exist
local pattern = regex.new('\\5')  -- Error: no group 5

-- Invalid: named group doesn't exist
local pattern = regex.new('\\k<missing>')  -- Error: no group named 'missing'

-- Valid:
local pattern = regex.new('(a)\\1')            -- Backreference to group 1
local pattern = regex.new('(?<x>a)\\k<x>')    -- Named backreference

-- Invalid: duplicate flag
local pattern = regex.new('(?ii:abc)')  -- Error: 'i' appears twice

-- Invalid: contradictory flags
local pattern = regex.new('(?i-i:abc)')  -- Error: both +i and -i

-- Valid:
local pattern = regex.new('(?i:abc)')          -- Single flag
local pattern = regex.new('(?im:abc)')         -- Multiple different flags
local pattern = regex.new('(?i-m:abc)')        -- Enable and disable flags

-- Invalid: mixed operators at same level
local pattern = regex.new('[AB--CD]')  -- Error: union (AB) then subtraction

-- Invalid: reserved double punctuator
local pattern = regex.new('[a-z!!]')  -- Error: !! is reserved

-- Valid:
local pattern = regex.new('[[AB]--[CD]]')      -- Nested classes
local pattern = regex.new('[A[B--C]D]')        -- Operator in nested level
local pattern = regex.new('[a-z\\!\\!]')       -- Escaped (two separate !)

-- Invalid: ( must be escaped in character class
local pattern = regex.new('[(]')  -- Error: must escape (

-- Invalid: { must be escaped
local pattern = regex.new('[{]')  -- Error: must escape {

-- Valid:
local pattern = regex.new('[\\(]')             -- Escaped (
local pattern = regex.new('[\\{\\}]')          -- Escaped braces

-- Invalid: string property in negated class
local pattern = regex.new('[^\\p{RGI_Emoji}]')  -- Error: cannot negate string property

-- Invalid: string property with \P
local pattern = regex.new('\\P{RGI_Emoji}')     -- Error: \P doesn't support string properties

-- Valid:
local pattern = regex.new('[\\p{RGI_Emoji}]')      -- String property in positive class
local pattern = regex.new('\\P{Emoji}')             -- Character property (not string)
local pattern = regex.new('[^\\p{Emoji}]')          -- Character property negated

-- Invalid: quantifier at start
local pattern = regex.new('*abc')  -- Error: nothing to repeat

-- Invalid: double quantifier
local pattern = regex.new('a**')   -- Error: quantifier on quantifier

-- Valid:
local pattern = regex.new('a*bc')              -- Quantifier after character
local pattern = regex.new('\\*abc')            -- Escaped * (literal)

-- Invalid UTF-8 in pattern
-- (This typically occurs when pattern strings contain invalid byte sequences)

-- Invalid: overlong encoding
local pattern = regex.new('\\xC0\\xB0')  -- Error: overlong form of U+0030

-- Valid:
local pattern = regex.new('\\x30')             -- Shortest form
local pattern = regex.new('\\u0030')           -- Unicode escape

-- Using catch for error handling
local err, pattern = catch(function()
   return regex.new('[invalid')
end)

if err then
   print('Pattern compilation failed: ' .. err.message)
   print('Error line: ' .. (err.line or 'unknown'))
else
   -- Use pattern
end

try {
   auto pattern = pf::regex("[invalid");
} catch (const std::exception& e) {
   std::cerr << "Pattern compilation failed: " << e.what() << std::endl;
}

-- Wrong: . matches any character
local pattern = regex.new('file.txt')
-- Matches: "file.txt", "file?txt", "fileXtxt"

-- Correct: \. matches literal dot
local pattern = regex.new('file\\.txt')
-- Matches: "file.txt" only

-- Wrong: brackets don't nest this way
local pattern = regex.new('[[a-z]')  -- Error

-- Correct: nest with operators
local pattern = regex.new('[[a-m][n-z]]')  -- Union of two ranges

-- Wrong: double quantifier
local pattern = regex.new('a*+')  -- Error

-- Correct: quantify group
local pattern = regex.new('(a*)+')