# todo :jvm<ignorecase+ignoremark doesn't work on jvm>
:i:m ﬆ			st	y	ignorecase ignoremark with ligature ﬆ (:i:m)
:i:m "All hell is breaking loose"			"All is fine, I am sure of it" 	n	RT128875 :i:m combined matches whole string when a single character match is found
# todo 7 :jvm<ignoremark charclass needs NFG>
:m <[a \n]>	a\x0300	y	ignoremark charclass with newline escape matches marked character
:m <[a \n]>	x	n	ignoremark charclass with newline escape rejects other character
:m [\n | <[a]>]	a\x0300	y	ignoremark charclass after alternation matches marked character
:m [<[a]> | \n]	a\x0300	y	ignoremark charclass before alternation matches marked character
:m [\n | <[b a]>]	a\x0300	y	ignoremark charclass in alternation matches on its second entry
:m [\n | <[b a]>]	c\x0300	n	ignoremark charclass in alternation rejects marked character not in list
:m <-[a \n]>	a\x0300	n	negated ignoremark charclass with newline escape rejects marked character
# todo 6 :jvm<ignoremark charclass needs NFG>
:m <[\x[E0]]>	a	y	hex escape in ignoremark charclass ignores its mark
:m <[a \x[300]]>	a\x0300	y	ignoremark charclass entry formed by a base character and combining escape matches marked character
:m <[\x[300]]>	\x0300	y	ignoremark charclass that is only a combining escape matches that mark
:m <-[a \x[300]]>	a\x0300	n	negated ignoremark charclass entry formed by a base character and combining escape rejects marked character
:m <-[a \x[300]]>	b\x0300	y	negated ignoremark charclass entry formed by a base character and combining escape accepts other marked character
:i:m [\n | <[\x[61]]>]	A\x0300	y	hex escape in ignorecase ignoremark charclass in alternation ignores case and mark
:i <[\x[4D]]>	m	y	hex escape in ignorecase charclass ignores case
:i <[\c[LATIN CAPITAL LETTER M]]>	m	y	named escape in ignorecase charclass ignores case
:i <[\x[DF]]>	\x00DF	y	escape that folds to two characters still matches itself in ignorecase charclass
:i <[\x[DF]]>	s	n	escape that folds to two characters does not match part of the fold
:i <[\x[300]]>	\x0300	y	lone combining escape in ignorecase charclass matches itself
:i <[\c[LATIN SMALL LIGATURE FF]]>	f	n	ligature escape in ignorecase charclass does not match part of the fold
:i <[ß]>	\x00DF	y	plain character that folds to two characters still matches itself in ignorecase charclass
:i <[ﬀ]>	\xFB00	y	plain ligature still matches itself in ignorecase charclass
:i <-[\x[4D]]>	m	n	negated ignorecase charclass with hex escape rejects the other case
:i <-[\x[4D]]>	n	y	negated ignorecase charclass with hex escape accepts other characters
:i <[ǆ]>	ǅ	y	ignorecase charclass matches the titlecase form of its entry
# todo 7 :jvm<combining characters need NFG>
:i:m <[\x[C0]]>	a	y	hex escape with a mark in ignorecase ignoremark charclass matches the bare base character
:m [\n | <-[a]>]	b\x0300	y	negated ignoremark charclass in alternation accepts other marked character
:m [\n | <-[a]>]	a\x0300	n	negated ignoremark charclass in alternation rejects marked character
:i <[a \x[308]]>	\x00E4	y	ignorecase charclass entry formed by a base character and combining escape matches itself
:i <[a \x[308]]>	a	n	ignorecase charclass entry formed by a base character and combining escape does not match the bare base character
:m <[\x[D]\x[A] \x[A]]>	\n	y	folded entries that would form one grapheme stay separate entries
:m <[\x[D]\x[A] \x[A]]>	\r	y	folded carriage return newline entry matches a carriage return
##  modifiers
# todo 6 :jvm<ligature problem>
:i ﬆ			st	y	ignorecase with ligature ﬆ (:i)
:i ﬆ			ST	y	ignorecase with ligature ﬆ (:i)
:i ﬆ			St	y	ignorecase with ligature ﬆ (:i)
:i ﬆ			sT	y	ignorecase with ligature ﬆ (:i)
:i st			ﬆ	y	reversed haystack and needle ignorecase with ligature ﬆ (:i)

# todo :moar<ligature problem>
:i abcdefgﬆ			sT	y	ignorecase with ligature ﬆ (:i)
:i bcd			abcdef	y	ignorecase (:i)
:i bcd			aBcdef	y	ignorecase (:i)
:i bcd			abCdef	y	ignorecase (:i)
:i bcd			abcDef	y	ignorecase (:i)
:i bcd			abc-ef	n	ignorecase (:i)
:ignorecase bcd		abcdef	y	ignorecase (:ignorecase)
:ignorecase bcd		aBCDef	y	ignorecase (:ignorecase)
:ignorecase bcd		abc-ef	n	ignorecase (:ignorecase)
:i(0) bcd		abcdef	y	ignorecase, repetition (:i(0))
:i(0) bcd		abCdef	n	ignorecase, repetition (:i(0))
:i(1) bcd		abcdef	y	ignorecase, repetition (:i(1))
:i(1) bcd		abCdef	y	ignorecase, repetition (:i(1))
:i(1) bcd		aBxDef	n	ignorecase, repetition (:i(1))
:0i bcd			abcdef	y	ignorecase, repetition (:0i)
:0i bcd			abCdef	n	ignorecase, repetition (:0i)
:1i bcd			abcdef	y	ignorecase, repetition (:1i)
:1i bcd			abCdef	y	ignorecase, repetition (:1i)
:1i bcd			aBCDef	y	ignorecase, repetition (:1i)
:1i bcd			aBxDef	n	ignorecase, repetition (:1i)
A :i B			Ab		y	ignorecase in the middle, literals on both sides
ab [:i cd ] ef		abcdef	y	ignorecase, lexical (:i)
ab [:i cd ] ef		abCdef	y	ignorecase, lexical (:i)
ab [:i cd ] ef		abcDef	y	ignorecase, lexical (:i)
ab [:i cd ] ef		abCDef	y	ignorecase, lexical (:i)
ab [:i cd ] ef		aBCDef	n	ignorecase, lexical (:i)
ab [:i cd ] ef		abCDEf	n	ignorecase, lexical (:i)
:i ab [:i cd ] ef	abCDef	y	ignorecase, lexical (:i)
:i ab [:i cd ] ef	AbCDeF	y	ignorecase, lexical (:i)
:i ab [:i cd ] ef	AbcdeF	y	ignorecase, lexical (:i)
:i a [:i(0) b [:i(1) c [:0i d [:1i e [:i(0) f ] ] ] ] ]		AbCdEf		y	ignorecase, lexical (:i)
:i aa [:i(0) bb [:i(1) cc [:0i dd [:1i ee [:i(0) ff ] ] ] ] ]	AabbCcddEeff	y	ignorecase, lexical (:i)
:i a [:i(0) b [:i(1) c [:0i d [:1i e [:i(0) f ] ] ] ] ]		AbCdEF		n	ignorecase, lexical (:i)
:i aa [:i(0) bb [:i(1) cc [:0i dd [:1i ee [:i(0) ff ] ] ] ] ]	AabbCcddEeFf	n	ignorecase, lexical (:i)
:i ab [:i(0) cd ] ef	AbcdeF	y	ignorecase, lexical repetition (:i)
:i ab [:!i cd ] ef	AbcdeF	y	ignorecase, lexical repetition (:i)
:i ab [:0i cd ] ef	AbcdeF	y	ignorecase, lexical repetition (:i)
:0i ab [:1i cd ] ef	abCDef	y	ignorecase, lexical repetition (:i)
:0i ab [:1i cd ] ef	AbCDeF	n	ignorecase, lexical repetition (:i)
:0i ab [:1i cd ] ef	AbcdeF	n	ignorecase, lexical repetition (:i)
:0i ab [:i(0) cd ] ef	abcdef	y	ignorecase, lexical repetition (:i)
:0i ab [:1i cd ] ef	AbcdeF	n	ignorecase, lexical repetition (:i)
:i(1) ab [:1i cd ] ef	AbCdeF	y	ignorecase, lexical repetition (:i)
:i(1) ab [:i(0) cd ] ef	AbcdeF	y	ignorecase, lexical repetition (:i)
:i(1) ab [:i(0) cd ] ef	AbcDeF	n	ignorecase, lexical repetition (:i)
:i(2) ab [:i(999) cd ] ef	ABCDEF	y	ignorecase, lexical repetition (:i)
:1i ab [:i(1) cd ] ef		ABCDEF	y	ignorecase, lexical repetition (:i)
:0i ab [:1i cd ] ef		abcDeF	n	ignorecase, lexical repetition (:i)
:2i ab [:999i cd ] ef		ABCDEF	y	ignorecase, lexical repetition (:i)
ab [:ignorecase cd ] ef		abCDef	y	ignorecase, lexical (:ignorecase)
ab [:ignorecase cd ] ef		aBCDef	n	ignorecase, lexical (:ignorecase)
:1ignorecase ab [:ignorecase(1) cd ] ef	ABCDEF	y	ignorecase, lexical repetition (:ignorecase)
:s bcd			a bcdef		y	sigspace (:s)
:s bcd			a bcd ef	y	sigspace (:s)
:s bcd			abcdef		y	sigspace (:s)
:s bcd			abcd ef		y	sigspace (:s)
:s bcd			ab cdef		n	sigspace (:s)
:s b c d		a b c d ef	y	sigspace (:s)
:s b c d		a b c def	y	sigspace (:s)
:s b c d		ab c d ef	y	sigspace (:s)
:s b c d		a bcdef		n	sigspace (:s)
:s b c d		abcdef		n	sigspace (:s)
:sigspace bcd		a bcdef		y	sigspace (:sigspace)
:sigspace bcd		a bcd ef	y	sigspace (:sigspace)
:sigspace bcd		abcdef		y	sigspace (:sigspace)
:sigspace b c d		a b c d ef	y	sigspace (:sigspace)
:sigspace b c d		a b c def	y	sigspace (:sigspace)
:sigspace b c d		ab c d ef	y	sigspace (:sigspace)
:s(1) b c [:s(0) d \w f ]	a b c def	y	sigspace, lexical repetition (:s)
:s b c [:!s d \w f ]	a b c def	y	sigspace, lexical repetition (:s)
:s(0) b \w [:s(1) d \w f ]	a b c def	n	sigspace, lexical repetition (:s)
:!s b \w [:s d \w f ]	a b c def	n	sigspace, lexical repetition (:s)
:s(0) b \w [:s(0) d \w f ]	a b c def	n	sigspace, lexical repetition (:s)
:!s b \w [:!s d \w f ]	a b c def	n	sigspace, lexical repetition (:s)
:s ab 				ab		y	sigspace, trailing ws
foo\s*'-'?\s*bar		foo\t \n-\n\t bar	y	basic match
foo\s*'-'?\s*bar		foo - bar	y	basic match
foo\s+'-'?\s*bar		foo   bar	y	basic match \s+ \s*
foo\s+'-'?\s*bar		foo  -bar	y	basic match \s+ \s*
foo\s*'-'?\s+bar		foo-  bar	y	basic match \s* \s+
foo '-'? bar			foo-bar		y	basic match \s* \s*
foo '-'? bar			foobar		y	basic match
foo '-'? bar			foo - bar	n	basic non-match
:s foo '-'? bar			foo\n \t- \t\t\nbar	y	basic ws match
:s foo '-'? bar			foo - bar	y	basic ws match
:s foo '-'? bar			foo   bar	y	basic ws match \s+ \s*
:s foo '-'? bar			foo  -bar	y	basic ws match \s+ \s*
:s foo '-'? bar			foo-  bar	y	basic ws match \s* \s+
:s foo '-'? bar			foo-bar		y	basic ws match \s* \s*
:s foo '-'? bar			foobar		n	basic ws non-match
# todo :any<feature>
:s()foo '-'? bar		foo - bar	n	basic ws match
# todo :any<feature>
:s[]foo '-'? bar		foo - bar	y	basic ws match
:s<?wb>foo '-'? bar		foo - bar	y	basic ws match with boundary modifier separation
# todo :any<::>
:s::foo '-'? bar			foo - bar	y	basic ws match with backtrack no-op modifier separation
# todo :any<::>
:s::(\w+) ':=' (\S+)		dog := spot	/mob 0: <dog @ 0>/	sigspace and capture together
# todo :any<::>
:s::(\w+) ':=' (\S+)		dog := spot	/mob 1: <spot @ 7>/	sigspace and capture together
# todo :any<feature>
:perl5 \A.*? bcd\Q$\E..\z	a bcd$ef	y	perl5 syntax (:perl5)
:s^[\d+ ]* abc			11 12 13 abc	y	<?ws> before closing bracket

## vim: noexpandtab tabstop=4 shiftwidth=4
