package syntax

Import Path
	github.com/dlclark/regexp2/v2/syntax (on go.dev)

Dependency Relation
	imports 13 packages, and imported by 2 packages



Package-Level Type Names (total 27)


	/* sort by:  |  */
	

		
			
				anchorDescription returns a human-readable description of the anchors

		
			 AnchorLoc : expvar.Var
			 AnchorLoc : fmt.Stringer
		
			const AnchorBeginning
			const AnchorBol
			const AnchorBoundary
			const AnchorECMABoundary
			const AnchorEnd
			const AnchorEndZ
			const AnchorEol
			const AnchorStart


	
		BmPrefix precomputes the Boyer-Moore
		tables for fast string scanning. These tables allow
		you to scan for the first occurrence of a string within
		a large body of text without examining every character.
		The performance of the heuristic depends on the actual
		string and the text being searched, but usually, the longer
		the string that is being searched for, the fewer characters
		need to be examined.

		
			
				Dump returns the contents of the filter as a human readable string

			
				When a regex is anchored, we can do a quick IsMatch test instead of a Scan

			
				Scan uses the Boyer-Moore algorithm to find the first occurrence
				of the specified string within text, beginning at index, and
				constrained within beglimit and endlimit.
				
				The direction and case-sensitivity of the match is determined
				by the arguments to the RegexBoyerMoore constructor.

			(*BmPrefix) String() string
		
			*BmPrefix : expvar.Var
			*BmPrefix : fmt.Stringer


	

		
			Cat string
			Negate bool
		
			( Category) String() string
		
			 Category : expvar.Var
			 Category : fmt.Stringer
		
			func (*CharSet).GetIfOnlyUnicodeCategories() (cats []Category, negate bool)


	

		
			
				true if we know for sure that all ASCII values are in the set; otherwise, false.
				This can only be true if OnlyRanges is true.

			
				true if we know for sure that all non-ASCII values are in the set; otherwise, false.
				This can only be true if OnlyRanges is true.

			
				true if we know for sure that the set doesn't contain any ASCII values; otherwise, false.
				This can only be true if OnlyRanges is true.

			
				true if we know for sure that the set contains only ASCII values; otherwise, false.
				This can only be true if OnlyRanges is true.

			
				The inclusive lower bound.
				This is only valid if OnlyRanges is true.

			
				true if the set contains only ranges; false if it contains Unicode categories and/or subtraction.

			
				The exclusive upper bound.
				This is only valid if OnlyRanges is true.

		
			func (*CharSet).Analyze() CharClassAnalysisResults


	
		CharSet combines start-end rune ranges and unicode categories representing a set of characters

		
			
				<summary>Analyzes the set to determine some basic properties that can be used to optimize usage.

			
				CharIn returns true if the rune is in our character set (either ranges or categories).
				It handles negations and subtracted sub-charsets.

			
				Copy makes a deep copy to prevent accidental mutation of a set

			(*CharSet) Equals(c2 *CharSet) bool
			( CharSet) GetIfNRanges(n int) []SingleRange
			(*CharSet) GetIfOnlyUnicodeCategories() (cats []Category, negate bool)
			
				Gets all of the characters in the specified set, storing them into the provided span.
				
				Only considers character classes that only contain sets (no categories),
				just simple sets containing starting/ending pairs (subtraction from those pairs
				is factored in, however).The returned characters may be negated: if IsNegated(set)
				is false, then the returned characters are the only ones that match; if it returns
				true, then the returned characters are the only ones that don't match.

			( CharSet) HasSubtraction() bool
			(*CharSet) Hash() []byte
			( CharSet) IsAnything() bool
			( CharSet) IsEmpty() bool
			( CharSet) IsMergeable() bool
			( CharSet) IsNegated() bool
			( CharSet) IsSingleton() bool
			( CharSet) IsSingletonInverse() bool
			
				Gets whether the specified set is a named set with a reasonably small count
				of Unicode characters. Designed to help the regexp code generator choose a better
				search algo for finding chars
				Description is a short name that can be used as part of a var name in code gen

			
				Determines whether two sets could overlap.

			
				SingletonChar will return the char from the first range without validation.
				It assumes you have checked for IsSingleton or IsSingletonInverse and will panic given bad input

			
				gets a human-readable description for a set string

		
			 CharSet : expvar.Var
			 CharSet : fmt.Stringer
		
			func NewCharSetRuntime(buf string) CharSet
			func CharSet.Copy() CharSet
		
			func (*CharSet).Equals(c2 *CharSet) bool
			func (*CharSet).MayOverlap(set2 *CharSet) bool
			func github.com/dlclark/regexp2/v2/helpers.IndexOfAnyExceptInSet(in []rune, set CharSet) int


	

		
			
				// the set of zero-length start anchors (RegexFCD.Bol, etc)

			
				// the fixed prefix string as a Boyer-Moore machine (may be null)

			
				// mapping of user group numbers -> impl group slots

			
				// number of impl group slots

			
				// capture slots observable by the pattern itself during quick matches

			
				// the code

			
				// shared match tables for deterministic alternations

			
				// the set of candidate first characters (may be null)

			
				// analyzed candidate search strategy

			
				// bool-only code with unobservable captures removed

			
				// lightweight tables targeting QuickCodes

			
				// true if right to left

			
				// character set table

			
				// string table

			
				// how many instructions use backtracking

		
			(*Code) Dump() string
			
				OpcodeDescription is a humman readable string of the specific offset

			
				PrepareCharSetASCIIBitmaps builds bounded ASCII lookup tables for compiled
				character classes before the regexp is shared across goroutines.

		
			func Write(tree *RegexTree) (*Code, error)


	
		DispatchTable maps disjoint character sets to branch indices. Larger tables
		use a direct ASCII lookup, small tables use compact masks, and non-ASCII
		runes inspect the full sets.

		
			
				// entry index + 1; zero means no branch

			
				// two membership words per branch when ASCII is nil

			Branches []int
			Sets []int


	
		An Error describes a failure to parse a regular expression
		and gives the offending expression.

		
			Args []interface{}
			Code ErrorCode
			Expr string
		
			(*Error) Error() string
		
			*Error : error


	
		An ErrorCode describes a failure to parse a regular expression.

		
			( ErrorCode) String() string
		
			 ErrorCode : expvar.Var
			 ErrorCode : fmt.Stringer
		
			const ErrInternalError


	

		
			C rune
			Distance int
			S string


	

		
			const Back
			const Back2
			const Backjump
			const Beginning
			const Bol
			const Boundary
			const Branchcount
			const Branchmark
			const Capturemark
			const Ci
			const Dispatch
			const ECMABoundary
			const End
			const EndZ
			const Eol
			const Forejump
			const Getmark
			const Goto
			const Grapheme
			const Lazybranch
			const Lazybranchcount
			const Lazybranchmark
			const Mask
			const Multi
			const Nonboundary
			const NonECMABoundary
			const Nothing
			const Notone
			const Notonelazy
			const Notoneloop
			const Notoneloopatomic
			const Notonerep
			const Nullcount
			const Nullmark
			const One
			const Onelazy
			const Oneloop
			const Oneloopatomic
			const Onerep
			const Prune
			const Ref
			const Rtl
			const Set
			const Setcount
			const Setjump
			const Setlazy
			const Setloop
			const Setloopatomic
			const Setmark
			const Setrep
			const Start
			const Stop
			const Testref
			const UpdateBumpalong


	

		
			const AfterChild
			const BeforeChild
			const NtAlternate
			const NtAtomic
			const NtBackRefCond
			const NtBeginning
			const NtBol
			const NtBoundary
			const NtCapture
			const NtConcatenate
			const NtECMABoundary
			const NtEmpty
			const NtEnd
			const NtEndZ
			const NtEol
			const NtExprCond
			const NtGrapheme
			const NtGroup
			const NtLazyloop
			const NtLoop
			const NtMulti
			const NtNegLook
			const NtNonboundary
			const NtNonECMABoundary
			const NtNothing
			const NtNotone
			const NtNotonelazy
			const NtNotoneloop
			const NtNotoneloopatomic
			const NtOne
			const NtOnelazy
			const NtOneloop
			const NtOneloopatomic
			const NtPosLook
			const NtRef
			const NtSet
			const NtSetlazy
			const NtSetloop
			const NtSetloopatomic
			const NtStart
			const NtUnknown
			const NtUpdateBumpalong


	

		
			CodeGen bool
			MaintainCaptureOrder bool
			RegexOptions RegexOptions
		
			func Parse(re string, op ParseOptions) (*RegexTree, error)


	

		
			CaseInsensitive bool
			PrefixSet CharSet
			PrefixStr []rune


	
		Implementation notes:
		
		Since the node tree is a temporary data structure only used
		during compilation of the regexp to integer codes, it's
		designed for clarity and convenience rather than
		space efficiency.
		
		RegexNodes are built into a tree, linked by the n.children list.
		Each node also has a n.parent and n.ichild member indicating
		its parent and which child # it is in its parent's list.
		
		RegexNodes come in as many types as there are constructs in
		a regular expression, for example, "concatenate", "alternate",
		"one", "rept", "group". There are also node types for basic
		peephole optimizations, e.g., "onerep", "notsetrep", etc.
		
		Because perl 5 allows "lookback" groups that scan backwards,
		each node also gets a "direction". Normally the value of
		boolean n.backward = false.
		
		On the parse stack, each tree has a "role" - basically, the
		nonterminal in the grammar that the parser has currently
		assigned to the tree. That code is stored in n.role.
		
		Finally, some of the different kinds of nodes have data.
		Two integers (for the looping constructs) are stored in
		n.operands, an an object (either a string or a set)
		is stored in n.data

		
			Ch rune
			Children []*RegexNode
			M int
			N int
			Options RegexOptions
			Parent *RegexNode
			Set *CharSet
			Str []rune
			T NodeType
		
			
				Computes a min bound on the required length of any string that could possibly match.
				If the result is 0, there is no minimum we can enforce.

			(*RegexNode) Description() string
			
				Recurs into the last expression of a loop node, looking to see if it can find a node
				that could be made atomic _assuming_ the conditions exist for it with the loop's ancestors.
				Returns The found node that should be explored further for auto-atomicity; null if it doesn't exist.

			(*RegexNode) FindStartingLiteral() *StartingLiteral
			
				Finds the guaranteed beginning literal(s) of the node, or null if none exists.
				allowZeroWidth = true

			
				Gets the character that begins a One or Multi.

			(*RegexNode) IsAtomicloopFamily() bool
			(*RegexNode) IsNotoneFamily() bool
			(*RegexNode) IsNotoneloopFamily() bool
			(*RegexNode) IsOneFamily() bool
			(*RegexNode) IsOneloopFamily() bool
			(*RegexNode) IsSetFamily() bool
			(*RegexNode) IsSetloopFamily() bool
			(*RegexNode) ReplaceChild(index int, newChild *RegexNode)
			
				Determine whether the specified child node is the beginning of a sequence that can
				trivially have length checks combined in order to avoid bounds checks.
				requiredLength is The sum of all the fixed lengths for the nodes in the sequence.</param>
				exclusiveEnd is The index of the node just after the last one in the sequence.</param>
				returns true if more than one node can have their length checks combined; otherwise, false.</returns>
				
				There are additional node types for which we can prove a fixed length, e.g. examining all branches
				of an alternation and returning true if all their lengths are equal.  However, the primary purpose
				of this method is to avoid bounds checks by consolidating length checks that guard accesses to
				strings/spans for which the JIT can see a fixed index within bounds, and alternations employ
				patterns that defeat that (e.g. reassigning the span in question).  As such, the implementation
				remains focused on only a core subset of nodes that are a) likely to be used in concatenations and
				b) employ simple patterns of checks.

			
				Determines whether the specified child index of a concatenation begins a sequence whose values
				should be used to perform an ordinal case-insensitive comparison.
				
				When consumeZeroWidthNodes is false, the consumer needs the semantics of matching the produced string to fully represent
				the semantics of all the consumed nodes, which means nodes can be consumed iff they produce text that's represented
				by the resulting string. When true, the resulting string needs to fully represent all valid matches at that position,
				but it can have false positives, which means the resulting string doesn't need to fully represent all zero-width nodes
				consumed. true is only valid when used as part of a search to determine where to try a full match, not as part of
				actual matching logic.
				consumeZeroWidthNodes = false

		
			*RegexNode : github.com/alexflint/go-arg.Described
		
			func (*RegexNode).FindLastExpressionInLoopForAutoAtomic() *RegexNode
			func (*RegexNode).FindStartingLiteralNode(allowZeroWidth bool) *RegexNode
		
			func (*RegexNode).ReplaceChild(index int, newChild *RegexNode)


	

		
			func NewReplacerData(rep string, caps map[int]int, capsize int, capnames map[string]int, op RegexOptions) (*ReplacerData, error)
		
			const ECMAScript
			const ExplicitCapture
			const IgnoreCase
			const IgnorePatternWhitespace
			const Multiline
			const RE2
			const RightToLeft
			const Singleline
			const Unicode


	

		
			Caplist []string
			Capnames map[string]int
			Capnumlist []int
			Caps map[int]int
			Captop int
			FindOptimizations *FindOptimizations
			Options RegexOptions
			Root *RegexNode
		
			(*RegexTree) Dump() string
		
			func Parse(re string, op ParseOptions) (*RegexTree, error)
		
			func Write(tree *RegexTree) (*Code, error)


	

		
			Rep string
			Rules []int
			Strings []string
		
			func NewReplacerData(rep string, caps map[int]int, capsize int, capnames map[string]int, op RegexOptions) (*ReplacerData, error)


	

		
			
				Alternatives describes the mutually exclusive shapes that can satisfy
				this single required landmark. A landmark matches when any one alternative
				matches at a position in the input.



	

		
			
				LeadingWhitespaceSet is the optional or required whitespace immediately
				before the core token. If RequireWhitespaceBefore is true, at least one
				rune from this set must precede the core. When this alternative is the
				first matched landmark, the runner may rewind over additional contiguous
				leading whitespace from this set before rewinding over LeadingLoopSet.

			
				Literal is the core token for literal alternatives. When non-empty, it
				must match exactly at the candidate core position, and Set must be nil.

			MaxRepeat int
			
				MinRepeat and MaxRepeat describe the core token width. Literal alternatives
				use 1..1 regardless of literal length because the literal is matched as one
				fixed core token; Set alternatives use the source set repetition.

			RequireWhitespaceAfter bool
			RequireWhitespaceBefore bool
			
				Set is the core token for character-class alternatives. When non-nil, it
				must match between MinRepeat and MaxRepeat runes at the candidate core
				position, and Literal must be empty. The analyzer only builds set
				alternatives for non-negated sets that can be cheaply enumerated, but the
				runner uses Set for membership checks.

			
				TrailingWhitespaceSet is the optional or required whitespace immediately
				after the core token. If RequireWhitespaceAfter is true, at least one rune
				from this set must follow the core. The runner validates the requirement,
				but does not consume optional trailing whitespace into the landmark end.



	

		
			
				Landmarks must all be found, in slice order, for the chain prefilter to
				produce a candidate. Each landmark is satisfied by exactly one matching
				alternative; alternatives are tried independently by the runner.

			
				LeadingLoopSet is the unbounded leading set loop that precedes every
				landmark in the original concatenation. At run time, after the first
				landmark alternative is found, the scanner walks backward over this set
				to recover the earliest plausible regex start position.



	

		
			First rune
			Last rune
		
			func CharSet.GetIfNRanges(n int) []SingleRange


	

		
			Negated bool
			Range SingleRange
			SetChars []rune
			String []rune
		
			func (*RegexNode).FindStartingLiteral() *StartingLiteral




Package-Level Functions (total 13)


	
		CharDescription Produces a human-readable description for a single character.


	 func Escape(input string) string
	
		According to UTS#18 Unicode Regular Expressions (http://www.unicode.org/reports/tr18/)
		RL 1.4 Simple Word Boundaries  The class of <word_character> includes all Alphabetic
		values from the Unicode character database, from UnicodeData.txt [UData], plus the U+200C
		ZERO WIDTH NON-JOINER and U+200D ZERO WIDTH JOINER.


	
		NewReplacerData will populate a reusable replacer data struct based on the given replacement string
		and the capture group data from a regexp


	
		NextGraphemeClusterBoundary returns the first extended-grapheme boundary
		after start, or -1 when start is not a valid input position. It implements
		the Unicode 17 rules from UAX #29 with a small state machine, avoiding the
		backtracking and repeated character-class probes of an equivalent regexp.


	
		Parse converts a regex string into a parse tree


	
		PreviousGraphemeClusterBoundary returns the first extended-grapheme boundary
		before end, or -1 when end is not a valid input position.


	 func Unescape(input string) (string, error)
	 func Write(tree *RegexTree) (*Code, error)


Package-Level Variables (total 19)


	  var AnyClass func() *CharSet
	  var DigitClass func() *CharSet
	  var ECMAAnyClass func() *CharSet
	  var ECMADigitClass func() *CharSet
	  var ECMASpaceClass func() *CharSet
	  var ECMAWordClass func() *CharSet
	
		ErrReplacementError is a general error during parsing the replacement text


	  var NoneClass func() *CharSet
	  var NotDigitClass func() *CharSet
	  var NotSpaceClass func() *CharSet
	  var NotWordClass func() *CharSet
	  var RE2SpaceClass func() *CharSet
	  var SpaceClass func() *CharSet
	  var WordClass func() *CharSet


Package-Level Constants (total 189)


	const AfterChild NodeType = 128
	
		where the regex can be pegged


	
		where the regex can be pegged


	
		where the regex can be pegged


	
		where the regex can be pegged


	
		where the regex can be pegged


	
		where the regex can be pegged


	
		where the regex can be pegged


	
		where the regex can be pegged


	const Back InstOp = 128 // bit to indicate that we're backtracking.
	const Back2 InstOp = 256 // bit to indicate that we're backtracking on a second branch.
	const Backjump InstOp = 35 // zap back to saved state
	const BeforeChild NodeType = 64
	const Beginning InstOp = 18 // \A
	const Bol InstOp = 14 // ^
	const Boundary InstOp = 16 // \b
	const Branchcount InstOp = 28 // back     jump,limit      branch++ if zero<=c<limit
	const Branchmark InstOp = 24 // back     jump            branch first for loop
	const Capturemark InstOp = 32 // back     group           define group
	const Ci InstOp = 512 // bit to indicate that we're case-insensitive.
	
		Selects and consumes the next character using a disjoint branch table.
		Operand 0 is an index into Code.Dispatches.


	const E byte = 1 // should be escaped
	const ECMABoundary InstOp = 41 // \b
	const ECMAScript RegexOptions = 256 // "e"
	const End InstOp = 21 // \Z
	const EndZ InstOp = 20 // \Z
	const Eol InstOp = 15 // $
	const ErrAlternationCantCapture = "alternation conditions do not capture and cannot be named"
	const ErrAlternationCantHaveComment = "alternation conditions cannot be comments"
	const ErrBadClassInCharRange = "cannot include class \\%v in character range"
	const ErrCapNumNotZero = "capture number cannot be zero"
	const ErrCaptureGroupOutOfRange = "capture group number out of range"
	const ErrConditionalExpression = "illegal conditional (?(...)) expression"
	const ErrDuplicateGroupName = "duplicate capture group name"
	const ErrIllegalEndEscape = "illegal \\ at end of pattern"
	const ErrIncompleteSlashP = "incomplete \\p{X} character escape"
	
		internal issue


	const ErrInvalidCharRange = "invalid character class range"
	const ErrInvalidECMAGroupName = "invalid capture group name"
	const ErrInvalidGroupName = "invalid group name: group names must begin with a word character and...
	const ErrInvalidHex = "hex values may not be larger than 0x10FFFF"
	const ErrInvalidRepeatOp = "invalid nested repetition operator"
	const ErrInvalidRepeatSize = "invalid repeat count"
	const ErrInvalidUTF8 = "invalid UTF-8"
	const ErrMalformedNameRef = "malformed \\k<...> named back reference"
	const ErrMalformedReference = "(?(%v) ) malformed"
	const ErrMalformedSlashP = "malformed \\p{X} character escape"
	const ErrMissingBrace = "missing closing }"
	const ErrMissingControl = "missing control character"
	const ErrMissingParen = "missing closing )"
	const ErrMissingRepeatArgument = "missing argument to repetition operator"
	const ErrReversedCharRange = "[%c-%c] range in reverse order"
	const ErrShorthandClassInCharRange = "cannot create range with shorthand escape sequence \\%v"
	const ErrSubtractionMustBeLast = "a subtraction must be the last element in a character class"
	const ErrTooFewHex = "insufficient hexadecimal digits"
	const ErrTooManyAlternates = "too many | in (?()|)"
	const ErrUndefinedBackRef = "reference to undefined group number %v"
	const ErrUndefinedNameRef = "reference to undefined group name %v"
	const ErrUndefinedReference = "(?(%v) ) reference to undefined group"
	const ErrUnexpectedParen = "unexpected )"
	const ErrUnknownSlashP = "unknown unicode category, script, or property '%v'"
	const ErrUnrecognizedControl = "unrecognized control character"
	const ErrUnrecognizedEscape = "unrecognized escape sequence \\%v"
	const ErrUnrecognizedGrouping = "unrecognized grouping construct: (%v"
	const ErrUnterminatedBracket = "unterminated [] set"
	
		Parser errors


	const ExplicitCapture RegexOptions = 4 // "n"
	
		A single character at a fixed distance from the start of the pattern.


	
		One or more sets at a fixed distance from the start of the pattern.


	
		A multi-character case-sensitive string at a fixed distance from the start of the pattern.


	const Forejump InstOp = 36 // zap backtracking state
	const Getmark InstOp = 33 // back                     recall position
	const Goto InstOp = 38 // jump            just go
	
		Matches one Unicode extended grapheme cluster (\X).


	const IgnoreCase RegexOptions = 1 // "i"
	const Lazybranch InstOp = 23 // back     jump            straight first
	const Lazybranchcount InstOp = 29 // back     jump,limit      same, but straight first
	const Lazybranchmark InstOp = 25 // back     jump            straight first for loop
	
		A "beginning" anchor at the beginning of the pattern.


	
		An "end" anchor at the beginning of the pattern.  This is rare.


	
		An "endz" anchor at the beginning of the pattern.  This is rare.


	
		A "start" anchor at the beginning of the pattern.


	
		A "beginning" anchor at the beginning of the right-to-left pattern.


	
		An "end" anchor at the beginning of the right-to-left pattern.  This is rare.


	
		An "endz" anchor at the beginning of the right-to-left pattern.  This is rare.


	
		A "start" anchor at the beginning of the right-to-left pattern.


	
		A single character at the start of the right-to-left pattern.


	
		A set starting the pattern.


	
		A set starting the right-to-left pattern.


	
		A multi-character substring at the beginning of the pattern.


	
		A multi-character ordinal case-insensitive substring at the beginning of the pattern.


	
		A multi-character substring at the beginning of the right-to-left pattern.


	
		Multiple leading prefix strings


	
		Multiple leading ordinal case-insensitive prefix strings


	
		A literal (single character, multi-char string, or set with small number of characters) after a non-overlapping set loop at the start of the pattern.


	const LowercaseAdd = 1 // Add arg.
	const LowercaseBad = 3 // Bitwise and with 1 and add original.
	const LowercaseBor = 2 // Bitwise or with 1.
	const LowercaseSet = 0 // Set to arg.
	const Mask InstOp = 63 // Mask to get unmodified ordinary operator
	
		MaxPrefixSize is the largest number of runes we'll use for a BoyerMoyer prefix


	const Multi InstOp = 12 // lef      string          abcd
	const Multiline RegexOptions = 2 // "m"
	
		Arbitrary number of repetitions of the same character when we'd prefer to represent that as a repeater of that character rather than a string.


	const Nonboundary InstOp = 17 // \B
	const NonECMABoundary InstOp = 42 // \B
	const Nothing InstOp = 22 // Reject!
	const Notone InstOp = 10 // lef      char            [^a]
	const Notonelazy InstOp = 7 // lef,back char,min,max    .{,n}?
	const Notoneloop InstOp = 4 // lef,back char,min,max    .{,n}
	
		Atomic loop of a single character other than the one specified.
		Operand 0 is the character. Operand 1 is the max iteration count.


	const Notonerep InstOp = 1 // lef,back char,min,max    .{n}
	const NtAlternate NodeType = 24 // a|b
	const NtAtomic NodeType = 32 // (?>) (?<)
	const NtBackRefCond NodeType = 33 // (?(n) | )
	const NtBeginning NodeType = 18 // \A
	const NtBol NodeType = 14 // ^
	const NtBoundary NodeType = 16 // \b
	const NtCapture NodeType = 28 // n        ()
	const NtConcatenate NodeType = 25 // ab
	const NtECMABoundary NodeType = 41 // \b
	const NtEmpty NodeType = 23 // ()
	const NtEnd NodeType = 21 // \Z
	const NtEndZ NodeType = 20 // \Z
	const NtEol NodeType = 15 // $
	const NtExprCond NodeType = 34 // (?(...) | )
	
		Matches one Unicode extended grapheme cluster (\X).


	const NtGroup NodeType = 29 // (?:)
	const NtLazyloop NodeType = 27 // m,x      *? +? ?? {,}?
	const NtLoop NodeType = 26 // m,x      * + ? {,}
	const NtMulti NodeType = 12 // lef      string          abcd
	const NtNegLook NodeType = 31 // (?!) (?<!)
	const NtNonboundary NodeType = 17 // \B
	const NtNonECMABoundary NodeType = 42 // \B
	const NtNothing NodeType = 22 // []
	const NtNotone NodeType = 10 // lef      char            [^a]
	const NtNotonelazy NodeType = 7 // lef,back char,min,max    .{,n}?
	const NtNotoneloop NodeType = 4 // lef,back char,min,max    .{,n}
	
		Atomic loop of a single character other than the one specified.
		Operand 0 is the character. Operand 1 is the max iteration count.


	const NtOne NodeType = 9 // lef      char            a
	const NtOnelazy NodeType = 6 // lef,back char,min,max    a {,n}?
	
		NtOnerep      NodeType = 0  // lef,back char,min,max    a {n}
		NtNotonerep   NodeType = 1  // lef,back char,min,max    .{n}
		NtSetrep      NodeType = 2  // lef,back set,min,max     [\d]{n}


	
		Atomic loop of the specified character.
		Operand 0 is the character. Operand 1 is the max iteration count.


	const NtPosLook NodeType = 30 // (?=) (?<=)
	const NtRef NodeType = 13 // lef      group           \#
	const NtSet NodeType = 11 // lef      set             [a-z\s]  \w \s \d
	const NtSetlazy NodeType = 8 // lef,back set,min,max     [\d]{,n}?
	const NtSetloop NodeType = 5 // lef,back set,min,max     [\d]{,n}
	
		Atomic loop of a single character matching the specified set
		Operand 0 is index into the strings table of the character class description. Operand 1 is the repetition count.


	const NtStart NodeType = 19 // \G
	
		The following are leaves, and correspond to primitive operations


	
		Updates the bumpalong position to the current position.


	const Nullcount InstOp = 26 // back     val             set counter, null mark
	const Nullmark InstOp = 30 // back                     save position
	const One InstOp = 9 // lef      char            a
	const Onelazy InstOp = 6 // lef,back char,min,max    a {,n}?
	const Oneloop InstOp = 3 // lef,back char,min,max    a {,n}
	
		Atomic loop of the specified character.
		Operand 0 is the character. Operand 1 is the max iteration count.


	const Onerep InstOp = 0 // lef,back char,min,max    a {n}
	const Prune InstOp = 39 // prune it baby
	const Q byte = 5 // quantifier
	const RE2 RegexOptions = 512 // RE2 compat mode
	const Ref InstOp = 13 // lef      group           \#
	
		A sequence of required landmarks after a leading loop.


	const RightToLeft RegexOptions = 64 // "r"
	const Rtl InstOp = 64 // bit to indicate that we're reverse scanning.
	const S byte = 4 // ordinary stopper
	const Set InstOp = 11 // lef      set             [a-z\s]  \w \s \d
	const Setcount InstOp = 27 // back     val             set counter, make mark
	const Setjump InstOp = 34 // back                     save backtrack state
	const Setlazy InstOp = 8 // lef,back set,min,max     [\d]{,n}?
	const Setloop InstOp = 5 // lef,back set,min,max     [\d]{,n}
	
		Atomic loop of a single character matching the specified set
		Operand 0 is index into the strings table of the character class description. Operand 1 is the repetition count.


	const Setmark InstOp = 31 // back                     save position
	const Setrep InstOp = 2 // lef,back set,min,max     [\d]{n}
	const Singleline RegexOptions = 16 // "s"
	const SpaceCategoryText = " "
	const Start InstOp = 19 // \G
	const Stop InstOp = 40 // done!
	const Testref InstOp = 37 // backtrack if ref undefined
	
		An "end" anchor at the end of the pattern, with the pattern always matching a fixed-length expression.


	
		An "endz" anchor at the end of the pattern, with the pattern always matching a fixed-length expression.


	const Unicode RegexOptions = 1024 // "u"
	
		Updates the bumpalong position to the current position.


	const WordCategoryText = "W"
	const X byte = 2 // whitespace
	const Z byte = 3 // ScanBlank stopper