newUnicodeNewlineNode constructs \R from existing general-purpose nodes. Its branches have disjoint starting sets, and the optional LF is atomic, so r

Remember the pushed state (in response to a ')')

This is the pop.

Remove a number from the longjump unrolling stack

Remove the starting text from the one or multi node. This may end up changing the type of the node to be Empty if the starting text matches the node'

We also use a stack of RegexFC objects. This is the push.

Push the parser state (in response to an open paren)

To avoid recursion, we use a simple integer stack. This is the push.

Basic optimization. Single-letter alternations can be replaced by faster set specifications, and nested alternations with no intervening operators can

Remove unnecessary atomic nodes, and make appropriate descendents of the atomic node themselves atomic. e.g. (?>(?>(?>a*))) => (?>a*) e.g. (?>(abc*)*)

Optimizations for backreference conditionals.

Combine adjacent loops. e.g. a*a*a* => a* e.g. a+ab => a{2,}b

Basic optimization. Adjacent strings can be concatenated. (?:abc)(?:def) -> abcdef

<summary>Optimizations for expression conditionals.</summary>

<summary>Optimizations for positive and negative lookaheads/behinds.</summary>

Nested repeaters just get multiplied with each other if they're not too lumpy

Simple optimization. If a set is a singleton, an inverse singleton, or empty, it's transformed accordingly.

* * The main FC computation. It does a shortcutted depth-first walk * through the tree and calls CalculateFC to emits code before * and after each

Nonpublic builder: removes a group match by capnum

Removes unnecessary Empty and Nothing nodes from the alternation. A Nothing will never match, so it can be removed entirely, and an Empty can be remov

repeat the rune r, c times... up to the max of MaxPrefixSize

Given a Match, emits into the StringBuilder the evaluated substitution pattern.

restoreLastUnit makes an immediately preceding literal quantifiable again when an empty \Q\E appears between it and its quantifier.

Scans \-style backreferences and character escapes

Grabs and converts an ascii control character

* * Scans $ patterns recognized within replacement patterns */

scanGroupOpen scans chars following a '(' (not counting the '('), and returns a RegexNode for the type of group scanned, or nil if the group simply ch

Scans up to three octal digits (stops before exceeding 0377).

Scans up to three octal digits (stops before exceeding 0377).