package regexp

Import Path
	regexp (on go.dev)

Dependency Relation
	imports 9 packages, and imported by one package

Involved Source Files

	      backtrack.go
	      exec.go
	      onepass.go
	   #d regexp.go
		Package regexp implements regular expression search.

		The syntax of the regular expressions accepted is the same
		general syntax used by Perl, Python, and other languages.
		More precisely, it is the syntax accepted by RE2 and described at
		https://golang.org/s/re2syntax, except for \C.
		For an overview of the syntax, run
		  go doc regexp/syntax

		The regexp implementation provided by this package is
		guaranteed to run in time linear in the size of the input.
		(This is a property not guaranteed by most open source
		implementations of regular expressions.) For more information
		about this property, see
		https://swtch.com/~rsc/regexp/regexp1.html
		or any book about automata theory.

		All characters are UTF-8-encoded code points.

		There are 16 methods of Regexp that match a regular expression and identify
		the matched text. Their names are matched by this regular expression:

		Find(All)?(String)?(Submatch)?(Index)?

		If 'All' is present, the routine matches successive non-overlapping
		matches of the entire expression. Empty matches abutting a preceding
		match are ignored. The return value is a slice containing the successive
		return values of the corresponding non-'All' routine. These routines take
		an extra integer argument, n. If n >= 0, the function returns at most n
		matches/submatches; otherwise, it returns all of them.

		If 'String' is present, the argument is a string; otherwise it is a slice
		of bytes; return values are adjusted as appropriate.

		If 'Submatch' is present, the return value is a slice identifying the
		successive submatches of the expression. Submatches are matches of
		parenthesized subexpressions (also known as capturing groups) within the
		regular expression, numbered from left to right in order of opening
		parenthesis. Submatch 0 is the match of the entire expression, submatch 1
		the match of the first parenthesized subexpression, and so on.

		If 'Index' is present, matches and submatches are identified by byte index
		pairs within the input string: result[2*n:2*n+1] identifies the indexes of
		the nth submatch. The pair for n==0 identifies the match of the entire
		expression. If 'Index' is not present, the match is identified by the text
		of the match/submatch. If an index is negative or text is nil, it means that
		subexpression did not match any string in the input. For 'String' versions
		an empty string means either no match or an empty match.

		There is also a subset of the methods that can be applied to text read
		from a RuneReader:

		MatchReader, FindReaderIndex, FindReaderSubmatchIndex

		This set may grow. Note that regular expression matches may need to
		examine text beyond the text returned by a match, so the methods that
		match text from a RuneReader may read arbitrarily far into the input
		before returning.

		(There are a few other methods that do not match this pattern.)
Code Examples

	
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			// Compile the expression once, usually at init time.
			// Use raw strings to avoid having to quote the backslashes.
			var validID = regexp.MustCompile(`^[a-z]+\[[0-9]+\]$`)
		
			fmt.Println(validID.MatchString("adam[23]"))
			fmt.Println(validID.MatchString("eve[7]"))
			fmt.Println(validID.MatchString("Job[48]"))
			fmt.Println(validID.MatchString("snakey"))
		}

	Match
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			matched, err := regexp.Match(`foo.*`, []byte(`seafood`))
			fmt.Println(matched, err)
			matched, err = regexp.Match(`bar.*`, []byte(`seafood`))
			fmt.Println(matched, err)
			matched, err = regexp.Match(`a(b`, []byte(`seafood`))
			fmt.Println(matched, err)
		
		}

	MatchString
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			matched, err := regexp.MatchString(`foo.*`, "seafood")
			fmt.Println(matched, err)
			matched, err = regexp.MatchString(`bar.*`, "seafood")
			fmt.Println(matched, err)
			matched, err = regexp.MatchString(`a(b`, "seafood")
			fmt.Println(matched, err)
		}

	QuoteMeta
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			fmt.Println(regexp.QuoteMeta(`Escaping symbols like: .+*?()|[]{}^$`))
		}

	Regexp_Expand
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			content := []byte(`
			# comment line
			option1: value1
			option2: value2
		
			# another comment line
			option3: value3
		`)
		
			// Regex pattern captures "key: value" pair from the content.
			pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
		
			// Template to convert "key: value" to "key=value" by
			// referencing the values captured by the regex pattern.
			template := []byte("$key=$value\n")
		
			result := []byte{}
		
			// For each match of the regex in the content.
			for _, submatches := range pattern.FindAllSubmatchIndex(content, -1) {
				// Apply the captured submatches to the template and append the output
				// to the result.
				result = pattern.Expand(result, template, content, submatches)
			}
			fmt.Println(string(result))
		}

	Regexp_ExpandString
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			content := `
			# comment line
			option1: value1
			option2: value2
		
			# another comment line
			option3: value3
		`
		
			// Regex pattern captures "key: value" pair from the content.
			pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
		
			// Template to convert "key: value" to "key=value" by
			// referencing the values captured by the regex pattern.
			template := "$key=$value\n"
		
			result := []byte{}
		
			// For each match of the regex in the content.
			for _, submatches := range pattern.FindAllStringSubmatchIndex(content, -1) {
				// Apply the captured submatches to the template and append the output
				// to the result.
				result = pattern.ExpandString(result, template, content, submatches)
			}
			fmt.Println(string(result))
		}

	Regexp_Find
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`foo.?`)
			fmt.Printf("%q\n", re.Find([]byte(`seafood fool`)))
		
		}

	Regexp_FindAll
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`foo.?`)
			fmt.Printf("%q\n", re.FindAll([]byte(`seafood fool`), -1))
		
		}

	Regexp_FindAllIndex
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			content := []byte("London")
			re := regexp.MustCompile(`o.`)
			fmt.Println(re.FindAllIndex(content, 1))
			fmt.Println(re.FindAllIndex(content, -1))
		}

	Regexp_FindAllString
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a.`)
			fmt.Println(re.FindAllString("paranormal", -1))
			fmt.Println(re.FindAllString("paranormal", 2))
			fmt.Println(re.FindAllString("graal", -1))
			fmt.Println(re.FindAllString("none", -1))
		}

	Regexp_FindAllStringSubmatch
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(x*)b`)
			fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-", -1))
			fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-", -1))
			fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-axb-", -1))
			fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-ab-", -1))
		}

	Regexp_FindAllStringSubmatchIndex
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(x*)b`)
			// Indices:
			//    01234567   012345678
			//    -ab-axb-   -axxb-ab-
			fmt.Println(re.FindAllStringSubmatchIndex("-ab-", -1))
			fmt.Println(re.FindAllStringSubmatchIndex("-axxb-", -1))
			fmt.Println(re.FindAllStringSubmatchIndex("-ab-axb-", -1))
			fmt.Println(re.FindAllStringSubmatchIndex("-axxb-ab-", -1))
			fmt.Println(re.FindAllStringSubmatchIndex("-foo-", -1))
		}

	Regexp_FindAllSubmatch
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`foo(.?)`)
			fmt.Printf("%q\n", re.FindAllSubmatch([]byte(`seafood fool`), -1))
		
		}

	Regexp_FindAllSubmatchIndex
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			content := []byte(`
			# comment line
			option1: value1
			option2: value2
		`)
			// Regex pattern captures "key: value" pair from the content.
			pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
			allIndexes := pattern.FindAllSubmatchIndex(content, -1)
			for _, loc := range allIndexes {
				fmt.Println(loc)
				fmt.Println(string(content[loc[0]:loc[1]]))
				fmt.Println(string(content[loc[2]:loc[3]]))
				fmt.Println(string(content[loc[4]:loc[5]]))
			}
		}

	Regexp_FindIndex
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			content := []byte(`
			# comment line
			option1: value1
			option2: value2
		`)
			// Regex pattern captures "key: value" pair from the content.
			pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
		
			loc := pattern.FindIndex(content)
			fmt.Println(loc)
			fmt.Println(string(content[loc[0]:loc[1]]))
		}

	Regexp_FindString
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`foo.?`)
			fmt.Printf("%q\n", re.FindString("seafood fool"))
			fmt.Printf("%q\n", re.FindString("meat"))
		}

	Regexp_FindStringIndex
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`ab?`)
			fmt.Println(re.FindStringIndex("tablett"))
			fmt.Println(re.FindStringIndex("foo") == nil)
		}

	Regexp_FindStringSubmatch
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(x*)b(y|z)c`)
			fmt.Printf("%q\n", re.FindStringSubmatch("-axxxbyc-"))
			fmt.Printf("%q\n", re.FindStringSubmatch("-abzc-"))
		}

	Regexp_FindSubmatch
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`foo(.?)`)
			fmt.Printf("%q\n", re.FindSubmatch([]byte(`seafood fool`)))
		
		}

	Regexp_FindSubmatchIndex
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(x*)b`)
			// Indices:
			//    01234567   012345678
			//    -ab-axb-   -axxb-ab-
			fmt.Println(re.FindSubmatchIndex([]byte("-ab-")))
			fmt.Println(re.FindSubmatchIndex([]byte("-axxb-")))
			fmt.Println(re.FindSubmatchIndex([]byte("-ab-axb-")))
			fmt.Println(re.FindSubmatchIndex([]byte("-axxb-ab-")))
			fmt.Println(re.FindSubmatchIndex([]byte("-foo-")))
		}

	Regexp_Longest
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(|b)`)
			fmt.Println(re.FindString("ab"))
			re.Longest()
			fmt.Println(re.FindString("ab"))
		}

	Regexp_Match
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`foo.?`)
			fmt.Println(re.Match([]byte(`seafood fool`)))
			fmt.Println(re.Match([]byte(`something else`)))
		
		}

	Regexp_MatchString
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`(gopher){2}`)
			fmt.Println(re.MatchString("gopher"))
			fmt.Println(re.MatchString("gophergopher"))
			fmt.Println(re.MatchString("gophergophergopher"))
		}

	Regexp_NumSubexp
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re0 := regexp.MustCompile(`a.`)
			fmt.Printf("%d\n", re0.NumSubexp())
		
			re := regexp.MustCompile(`(.*)((a)b)(.*)a`)
			fmt.Println(re.NumSubexp())
		}

	Regexp_ReplaceAll
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(x*)b`)
			fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("T")))
			fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("$1")))
			fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("$1W")))
			fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("${1}W")))
		}

	Regexp_ReplaceAllLiteralString
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(x*)b`)
			fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "T"))
			fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "$1"))
			fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "${1}"))
		}

	Regexp_ReplaceAllString
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`a(x*)b`)
			fmt.Println(re.ReplaceAllString("-ab-axxb-", "T"))
			fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1"))
			fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1W"))
			fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))
		}

	Regexp_ReplaceAllStringFunc
		package main
		
		import (
			"fmt"
			"regexp"
			"strings"
		)
		
		func main() {
			re := regexp.MustCompile(`[^aeiou]`)
			fmt.Println(re.ReplaceAllStringFunc("seafood fool", strings.ToUpper))
		}

	Regexp_Split
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			a := regexp.MustCompile(`a`)
			fmt.Println(a.Split("banana", -1))
			fmt.Println(a.Split("banana", 0))
			fmt.Println(a.Split("banana", 1))
			fmt.Println(a.Split("banana", 2))
			zp := regexp.MustCompile(`z+`)
			fmt.Println(zp.Split("pizza", -1))
			fmt.Println(zp.Split("pizza", 0))
			fmt.Println(zp.Split("pizza", 1))
			fmt.Println(zp.Split("pizza", 2))
		}

	Regexp_SubexpIndex
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)`)
			fmt.Println(re.MatchString("Alan Turing"))
			matches := re.FindStringSubmatch("Alan Turing")
			lastIndex := re.SubexpIndex("last")
			fmt.Printf("last => %d\n", lastIndex)
			fmt.Println(matches[lastIndex])
		}

	Regexp_SubexpNames
		package main
		
		import (
			"fmt"
			"regexp"
		)
		
		func main() {
			re := regexp.MustCompile(`(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)`)
			fmt.Println(re.MatchString("Alan Turing"))
			fmt.Printf("%q\n", re.SubexpNames())
			reversed := fmt.Sprintf("${%s} ${%s}", re.SubexpNames()[2], re.SubexpNames()[1])
			fmt.Println(reversed)
			fmt.Println(re.ReplaceAllString("Alan Turing", reversed))
		}


Package-Level Type Names (total 18, in which 1 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Regexp (struct)
		Regexp is the representation of a compiled regular expression.
		A Regexp is safe for concurrent use by multiple goroutines,
		except for configuration methods, such as Longest.

		Fields (total 16, none are exported)
			/* 16 unexporteds ... *//* 16 unexporteds: */
			cond syntax.EmptyOp
				// empty-width conditions required at start of match

			expr string
				// as passed to Compile

			longest bool
				This field can be modified by the Longest method,
				but it is otherwise read-only.
				// whether regexp prefers leftmost-longest match

			matchcap int
				// size of recorded match lengths

			maxBitStateLen int
			minInputLen int
				// minimum length of the input in bytes

			mpool int
				// pool for machines

			numSubexp int
			onepass *onePassProg
				// onepass program or nil

			prefix string
				// required prefix in unanchored matches

			prefixBytes []byte
				// prefix, as a []byte

			prefixComplete bool
				// prefix is the entire regexp

			prefixEnd uint32
				// pc for last rune in prefix

			prefixRune rune
				// first rune in prefix

			prog *syntax.Prog
				// compiled program

			subexpNames []string
		Methods (total 48, in which 37 are exported)
			(*T) Copy() *Regexp
				Copy returns a new Regexp object copied from re.
				Calling Longest on one copy does not affect another.

				Deprecated: In earlier releases, when using a Regexp in multiple goroutines,
				giving each goroutine its own copy helped to avoid lock contention.
				As of Go 1.12, using Copy is no longer necessary to avoid lock contention.
				Copy may still be appropriate if the reason for its use is to make
				two copies with different Longest settings.

			(*T) Expand(dst []byte, template []byte, src []byte, match []int) []byte
				Expand appends template to dst and returns the result; during the
				append, Expand replaces variables in the template with corresponding
				matches drawn from src. The match slice should have been returned by
				FindSubmatchIndex.

				In the template, a variable is denoted by a substring of the form
				$name or ${name}, where name is a non-empty sequence of letters,
				digits, and underscores. A purely numeric name like $1 refers to
				the submatch with the corresponding index; other names refer to
				capturing parentheses named with the (?P<name>...) syntax. A
				reference to an out of range or unmatched index or a name that is not
				present in the regular expression is replaced with an empty slice.

				In the $name form, name is taken to be as long as possible: $1x is
				equivalent to ${1x}, not ${1}x, and, $10 is equivalent to ${10}, not ${1}0.

				To insert a literal $ in the output, use $$ in the template.

			(*T) ExpandString(dst []byte, template string, src string, match []int) []byte
				ExpandString is like Expand but the template and source are strings.
				It appends to and returns a byte slice in order to give the calling
				code control over allocation.

			(*T) Find(b []byte) []byte
				Find returns a slice holding the text of the leftmost match in b of the regular expression.
				A return value of nil indicates no match.

			(*T) FindAll(b []byte, n int) [][]byte
				FindAll is the 'All' version of Find; it returns a slice of all successive
				matches of the expression, as defined by the 'All' description in the
				package comment.
				A return value of nil indicates no match.

			(*T) FindAllIndex(b []byte, n int) [][]int
				FindAllIndex is the 'All' version of FindIndex; it returns a slice of all
				successive matches of the expression, as defined by the 'All' description
				in the package comment.
				A return value of nil indicates no match.

			(*T) FindAllString(s string, n int) []string
				FindAllString is the 'All' version of FindString; it returns a slice of all
				successive matches of the expression, as defined by the 'All' description
				in the package comment.
				A return value of nil indicates no match.

			(*T) FindAllStringIndex(s string, n int) [][]int
				FindAllStringIndex is the 'All' version of FindStringIndex; it returns a
				slice of all successive matches of the expression, as defined by the 'All'
				description in the package comment.
				A return value of nil indicates no match.

			(*T) FindAllStringSubmatch(s string, n int) [][]string
				FindAllStringSubmatch is the 'All' version of FindStringSubmatch; it
				returns a slice of all successive matches of the expression, as defined by
				the 'All' description in the package comment.
				A return value of nil indicates no match.

			(*T) FindAllStringSubmatchIndex(s string, n int) [][]int
				FindAllStringSubmatchIndex is the 'All' version of
				FindStringSubmatchIndex; it returns a slice of all successive matches of
				the expression, as defined by the 'All' description in the package
				comment.
				A return value of nil indicates no match.

			(*T) FindAllSubmatch(b []byte, n int) [][][]byte
				FindAllSubmatch is the 'All' version of FindSubmatch; it returns a slice
				of all successive matches of the expression, as defined by the 'All'
				description in the package comment.
				A return value of nil indicates no match.

			(*T) FindAllSubmatchIndex(b []byte, n int) [][]int
				FindAllSubmatchIndex is the 'All' version of FindSubmatchIndex; it returns
				a slice of all successive matches of the expression, as defined by the
				'All' description in the package comment.
				A return value of nil indicates no match.

			(*T) FindIndex(b []byte) (loc []int)
				FindIndex returns a two-element slice of integers defining the location of
				the leftmost match in b of the regular expression. The match itself is at
				b[loc[0]:loc[1]].
				A return value of nil indicates no match.

			(*T) FindReaderIndex(r io.RuneReader) (loc []int)
				FindReaderIndex returns a two-element slice of integers defining the
				location of the leftmost match of the regular expression in text read from
				the RuneReader. The match text was found in the input stream at
				byte offset loc[0] through loc[1]-1.
				A return value of nil indicates no match.

			(*T) FindReaderSubmatchIndex(r io.RuneReader) []int
				FindReaderSubmatchIndex returns a slice holding the index pairs
				identifying the leftmost match of the regular expression of text read by
				the RuneReader, and the matches, if any, of its subexpressions, as defined
				by the 'Submatch' and 'Index' descriptions in the package comment. A
				return value of nil indicates no match.

			(*T) FindString(s string) string
				FindString returns a string holding the text of the leftmost match in s of the regular
				expression. If there is no match, the return value is an empty string,
				but it will also be empty if the regular expression successfully matches
				an empty string. Use FindStringIndex or FindStringSubmatch if it is
				necessary to distinguish these cases.

			(*T) FindStringIndex(s string) (loc []int)
				FindStringIndex returns a two-element slice of integers defining the
				location of the leftmost match in s of the regular expression. The match
				itself is at s[loc[0]:loc[1]].
				A return value of nil indicates no match.

			(*T) FindStringSubmatch(s string) []string
				FindStringSubmatch returns a slice of strings holding the text of the
				leftmost match of the regular expression in s and the matches, if any, of
				its subexpressions, as defined by the 'Submatch' description in the
				package comment.
				A return value of nil indicates no match.

			(*T) FindStringSubmatchIndex(s string) []int
				FindStringSubmatchIndex returns a slice holding the index pairs
				identifying the leftmost match of the regular expression in s and the
				matches, if any, of its subexpressions, as defined by the 'Submatch' and
				'Index' descriptions in the package comment.
				A return value of nil indicates no match.

			(*T) FindSubmatch(b []byte) [][]byte
				FindSubmatch returns a slice of slices holding the text of the leftmost
				match of the regular expression in b and the matches, if any, of its
				subexpressions, as defined by the 'Submatch' descriptions in the package
				comment.
				A return value of nil indicates no match.

			(*T) FindSubmatchIndex(b []byte) []int
				FindSubmatchIndex returns a slice holding the index pairs identifying the
				leftmost match of the regular expression in b and the matches, if any, of
				its subexpressions, as defined by the 'Submatch' and 'Index' descriptions
				in the package comment.
				A return value of nil indicates no match.

			(*T) LiteralPrefix() (prefix string, complete bool)
				LiteralPrefix returns a literal string that must begin any match
				of the regular expression re. It returns the boolean true if the
				literal string comprises the entire regular expression.

			(*T) Longest()
				Longest makes future searches prefer the leftmost-longest match.
				That is, when matching against text, the regexp returns a match that
				begins as early as possible in the input (leftmost), and among those
				it chooses a match that is as long as possible.
				This method modifies the Regexp and may not be called concurrently
				with any other methods.

			(*T) Match(b []byte) bool
				Match reports whether the byte slice b
				contains any match of the regular expression re.

			(*T) MatchReader(r io.RuneReader) bool
				MatchReader reports whether the text returned by the RuneReader
				contains any match of the regular expression re.

			(*T) MatchString(s string) bool
				MatchString reports whether the string s
				contains any match of the regular expression re.

			(*T) NumSubexp() int
				NumSubexp returns the number of parenthesized subexpressions in this Regexp.

			(*T) ReplaceAll(src, repl []byte) []byte
				ReplaceAll returns a copy of src, replacing matches of the Regexp
				with the replacement text repl. Inside repl, $ signs are interpreted as
				in Expand, so for instance $1 represents the text of the first submatch.

			(*T) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
				ReplaceAllFunc returns a copy of src in which all matches of the
				Regexp have been replaced by the return value of function repl applied
				to the matched byte slice. The replacement returned by repl is substituted
				directly, without using Expand.

			(*T) ReplaceAllLiteral(src, repl []byte) []byte
				ReplaceAllLiteral returns a copy of src, replacing matches of the Regexp
				with the replacement bytes repl. The replacement repl is substituted directly,
				without using Expand.

			(*T) ReplaceAllLiteralString(src, repl string) string
				ReplaceAllLiteralString returns a copy of src, replacing matches of the Regexp
				with the replacement string repl. The replacement repl is substituted directly,
				without using Expand.

			(*T) ReplaceAllString(src, repl string) string
				ReplaceAllString returns a copy of src, replacing matches of the Regexp
				with the replacement string repl. Inside repl, $ signs are interpreted as
				in Expand, so for instance $1 represents the text of the first submatch.

			(*T) ReplaceAllStringFunc(src string, repl func(string) string) string
				ReplaceAllStringFunc returns a copy of src in which all matches of the
				Regexp have been replaced by the return value of function repl applied
				to the matched substring. The replacement returned by repl is substituted
				directly, without using Expand.

			(*T) Split(s string, n int) []string
				Split slices s into substrings separated by the expression and returns a slice of
				the substrings between those expression matches.

				The slice returned by this method consists of all the substrings of s
				not contained in the slice returned by FindAllString. When called on an expression
				that contains no metacharacters, it is equivalent to strings.SplitN.

				Example:
				  s := regexp.MustCompile("a*").Split("abaabaccadaaae", 5)
				  // s: ["", "b", "b", "c", "cadaaae"]

				The count determines the number of substrings to return:
				  n > 0: at most n substrings; the last substring will be the unsplit remainder.
				  n == 0: the result is nil (zero substrings)
				  n < 0: all substrings

			(*T) String() string
				String returns the source text used to compile the regular expression.

			(*T) SubexpIndex(name string) int
				SubexpIndex returns the index of the first subexpression with the given name,
				or -1 if there is no subexpression with that name.

				Note that multiple subexpressions can be written using the same name, as in
				(?P<bob>a+)(?P<bob>b+), which declares two subexpressions named "bob".
				In this case, SubexpIndex returns the index of the leftmost such subexpression
				in the regular expression.

			(*T) SubexpNames() []string
				SubexpNames returns the names of the parenthesized subexpressions
				in this Regexp. The name for the first sub-expression is names[1],
				so that if m is a match slice, the name for m[i] is SubexpNames()[i].
				Since the Regexp as a whole cannot be named, names[0] is always
				the empty string. The slice should not be modified.

			/* 11 unexporteds ... *//* 11 unexporteds: */
			(*T) allMatches(s string, b []byte, n int, deliver func([]int))
				allMatches calls deliver at most n times
				with the location of successive matches in the input text.
				The input text is b if non-nil, otherwise s.

			(*T) backtrack(ib []byte, is string, pos int, ncap int, dstCap []int) []int
				backtrack runs a backtracking search of prog on the input starting at pos.

			(*T) doExecute(r io.RuneReader, b []byte, s string, pos int, ncap int, dstCap []int) []int
				doExecute finds the leftmost match in the input, appends the position
				of its subexpressions to dstCap and returns dstCap.

				nil is returned if no matches are found and non-nil if matches are found.

			(*T) doMatch(r io.RuneReader, b []byte, s string) bool
				doMatch reports whether either r, b or s match the regexp.

			(*T) doOnePass(ir io.RuneReader, ib []byte, is string, pos, ncap int, dstCap []int) []int
				doOnePass implements r.doExecute using the one-pass execution engine.

			(*T) expand(dst []byte, template string, bsrc []byte, src string, match []int) []byte
			(*T) get() *machine
				get returns a machine to use for matching re.
				It uses the re's machine cache if possible, to avoid
				unnecessary allocation.

			(*T) pad(a []int) []int
				The number of capture values in the program may correspond
				to fewer capturing expressions than are in the regexp.
				For example, "(a){0}" turns into an empty program, so the
				maximum capture in the program is 0 but we need to return
				an expression for \1.  Pad appends -1s to the slice a as needed.

			(*T) put(m *machine)
				put returns a machine to the correct machine pool.

			(*T) replaceAll(bsrc []byte, src string, nmatch int, repl func(dst []byte, m []int) []byte) []byte
			(*T) tryBacktrack(b *bitState, i input, pc uint32, pos int) bool
				tryBacktrack runs a backtracking search starting at pos.

		Implements (at least 3, in which 1 are exported)
			*T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least 6, in which 5 are exported)
			func Compile(expr string) (*Regexp, error)
			func CompilePOSIX(expr string) (*Regexp, error)
			func MustCompile(str string) *Regexp
			func MustCompilePOSIX(str string) *Regexp
			func (*Regexp).Copy() *Regexp
			/* at least one unexported ... *//* at least one unexported: */
			func compile(expr string, mode syntax.Flags, longest bool) (*Regexp, error)
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var gitlab.com/pcanilho/goneo.supportedIdentifierFormat *Regexp

	/* 17 unexporteds ... *//* 17 unexporteds: */
	 type bitState (struct)
		bitState holds state for the backtracker.

		Fields (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			cap []int
			end int
			inputs inputs
			jobs []job
			matchcap []int
			visited []uint32
		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) push(re *Regexp, pc uint32, pos int, arg bool)
				push pushes (pc, pos, arg) onto the job stack if it should be
				visited.

			(*T) reset(prog *syntax.Prog, end int, ncap int)
				reset resets the state of the backtracker.
				end is the end position in the input.
				ncap is the number of captures.

			(*T) shouldVisit(pc uint32, pos int) bool
				shouldVisit reports whether the combination of (pc, pos) has not
				been visited yet.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newBitState() *bitState
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func freeBitState(b *bitState)
			func (*Regexp).tryBacktrack(b *bitState, i input, pc uint32, pos int) bool

	 type entry (struct)
		An entry is an entry on a queue.
		It holds both the instruction pc and the actual thread.
		Some queue entries are just place holders so that the machine
		knows it has considered that pc. Such entries have t == nil.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			pc uint32
			t *thread

	 type input (interface)
		input abstracts different representations of the input text. It provides
		one-character lookahead.

		Methods (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			( T) canCheckPrefix() bool
				// can we look ahead without losing info?

			( T) context(pos int) lazyFlag
			( T) hasPrefix(re *Regexp) bool
			( T) index(re *Regexp, pos int) int
			( T) step(pos int) (r rune, width int)
				// advance one rune

		Implemented By (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*inputBytes
			*inputReader
			*inputString
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Regexp).tryBacktrack(b *bitState, i input, pc uint32, pos int) bool

	 type inputBytes (struct)
		inputBytes scans a byte slice.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			str []byte
		Methods (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) canCheckPrefix() bool
			(*T) context(pos int) lazyFlag
			(*T) hasPrefix(re *Regexp) bool
			(*T) index(re *Regexp, pos int) int
			(*T) step(pos int) (rune, int)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : input

	 type inputReader (struct)
		inputReader scans a RuneReader.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			atEOT bool
			pos int
			r io.RuneReader
		Methods (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) canCheckPrefix() bool
			(*T) context(pos int) lazyFlag
			(*T) hasPrefix(re *Regexp) bool
			(*T) index(re *Regexp, pos int) int
			(*T) step(pos int) (rune, int)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : input

	 type inputs (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			bytes inputBytes
				cached inputs, to avoid allocation

			reader inputReader
			string inputString
		Methods (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) clear()
			(*T) init(r io.RuneReader, b []byte, s string) (input, int)
			(*T) newBytes(b []byte) input
			(*T) newReader(r io.RuneReader) input
			(*T) newString(s string) input

	 type inputString (struct)
		inputString scans a string.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			str string
		Methods (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) canCheckPrefix() bool
			(*T) context(pos int) lazyFlag
			(*T) hasPrefix(re *Regexp) bool
			(*T) index(re *Regexp, pos int) int
			(*T) step(pos int) (rune, int)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : input

	 type job (struct)
		A job is an entry on the backtracker's job stack. It holds
		the instruction pc and the position in the input.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			arg bool
			pc uint32
			pos int

	 type lazyFlag uint64 (basic type)
		A lazyFlag is a lazily-evaluated syntax.EmptyOp,
		for checking zero-width flags like ^ $ \A \z \B \b.
		It records the pair of relevant runes and does not
		determine the implied flags until absolutely necessary
		(most of the time, that means never).

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( T) match(op syntax.EmptyOp) bool
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newLazyFlag(r1, r2 rune) lazyFlag

	 type machine (struct)
		A machine holds all the state during an NFA simulation for p.

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			inputs inputs
			matchcap []int
				// capture information for the match

			matched bool
				// whether a match was found

			p *syntax.Prog
				// compiled program

			pool []*thread
				// pool of available threads

			q0 queue
				// two queues for runq, nextq

			q1 queue
				// two queues for runq, nextq

			re *Regexp
				// corresponding Regexp

		Methods (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) add(q *queue, pc uint32, pos int, cap []int, cond *lazyFlag, t *thread) *thread
				add adds an entry to q for pc, unless the q already has such an entry.
				It also recursively adds an entry for all instructions reachable from pc by following
				empty-width conditions satisfied by cond.  pos gives the current position
				in the input.

			(*T) alloc(i *syntax.Inst) *thread
				alloc allocates a new thread with the given instruction.
				It uses the free pool if possible.

			(*T) clear(q *queue)
				clear frees all threads on the thread queue.

			(*T) init(ncap int)
			(*T) match(i input, pos int) bool
				match runs the machine over the input starting at pos.
				It reports whether a match was found.
				If so, m.matchcap holds the submatch information.

			(*T) step(runq, nextq *queue, pos, nextPos int, c rune, nextCond *lazyFlag)
				step executes one step of the machine, running each of the threads
				on runq and appending new threads to nextq.
				The step processes the rune c (which may be endOfText),
				which starts at position pos and ends at nextPos.
				nextCond gives the setting for the empty-width flags after c.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Regexp).get() *machine
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Regexp).put(m *machine)

	 type onePassInst (struct)
		A onePassInst is a single instruction in a one-pass regular expression program.
		It is the same as syntax.Inst except for the new 'Next' field.

		Fields (total 6, all are exported)
			Inst syntax.Inst
			Inst.Arg uint32
				// InstAlt, InstAltMatch, InstCapture, InstEmptyWidth

			Inst.Op syntax.InstOp
			Inst.Out uint32
				// all but InstMatch, InstFail

			Inst.Rune []rune
			Next []uint32
		Methods (total 5, in which 4 are exported)
			(*T) MatchEmptyWidth(before rune, after rune) bool
				MatchEmptyWidth reports whether the instruction matches
				an empty string between the runes before and after.
				It should only be called when i.Op == InstEmptyWidth.

			(*T) MatchRune(r rune) bool
				MatchRune reports whether the instruction matches (and consumes) r.
				It should only be called when i.Op == InstRune.

			(*T) MatchRunePos(r rune) int
				MatchRunePos checks whether the instruction matches (and consumes) r.
				If so, MatchRunePos returns the index of the matching rune pair
				(or, when len(i.Rune) == 1, rune singleton).
				If not, MatchRunePos returns -1.
				MatchRunePos should only be called when i.Op == InstRune.

			(*T) String() string
			/* one unexported ... *//* one unexported: */
			(*T) op() syntax.InstOp
				op returns i.Op but merges all the Rune special cases into InstRune

		Implements (at least 3, in which 1 are exported)
			*T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*T : context.stringer
			*T : runtime.stringer
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func onePassNext(i *onePassInst, r rune) uint32

	 type onePassMachine (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			inputs inputs
			matchcap []int
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newOnePassMachine() *onePassMachine
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func freeOnePassMachine(m *onePassMachine)

	 type onePassProg (struct)
		A onePassProg is a compiled one-pass regular expression program.
		It is the same as syntax.Prog except for the use of onePassInst.

		Fields (total 3, all are exported)
			Inst []onePassInst
			NumCap int
				// number of InstCapture insts in re

			Start int
				// index of start instruction

		As Outputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func compileOnePass(prog *syntax.Prog) (p *onePassProg)
			func makeOnePass(p *onePassProg) *onePassProg
			func onePassCopy(prog *syntax.Prog) *onePassProg
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func cleanupOnePass(prog *onePassProg, original *syntax.Prog)
			func makeOnePass(p *onePassProg) *onePassProg

	 type queue (struct)
		A queue is a 'sparse array' holding pending threads of execution.
		See https://research.swtch.com/2008/03/using-uninitialized-memory-for-fun-and.html

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			dense []entry
			sparse []uint32

	 type queueOnePass (struct)
		Sparse Array implementation is used as a queueOnePass.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			dense []uint32
			nextIndex uint32
			size uint32
			sparse []uint32
		Methods (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) clear()
			(*T) contains(u uint32) bool
			(*T) empty() bool
			(*T) insert(u uint32)
			(*T) insertNew(u uint32)
			(*T) next() (n uint32)
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newQueue(size int) (q *queueOnePass)

	 type runeSlice ([]T)
		runeSlice exists to permit sorting the case-folded rune sets.

		Methods (total 3, all are exported)
			( T) Len() int
			( T) Less(i, j int) bool
			( T) Swap(i, j int)
		Implements (at least one exported)
			 T : sort.Interface

	 type thread (struct)
		A thread is the state of a single path through the machine:
		an instruction and a corresponding capture array.
		See https://swtch.com/~rsc/regexp/regexp2.html

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			cap []int
			inst *syntax.Inst


Package-Level Functions (total 30, in which 8 are exported)

	 func Compile(expr string) (*Regexp, error)
		Compile parses a regular expression and returns, if successful,
		a Regexp object that can be used to match against text.

		When matching against text, the regexp returns a match that
		begins as early as possible in the input (leftmost), and among those
		it chooses the one that a backtracking search would have found first.
		This so-called leftmost-first matching is the same semantics
		that Perl, Python, and other implementations use, although this
		package implements it without the expense of backtracking.
		For POSIX leftmost-longest matching, see CompilePOSIX.

	 func CompilePOSIX(expr string) (*Regexp, error)
		CompilePOSIX is like Compile but restricts the regular expression
		to POSIX ERE (egrep) syntax and changes the match semantics to
		leftmost-longest.

		That is, when matching against text, the regexp returns a match that
		begins as early as possible in the input (leftmost), and among those
		it chooses a match that is as long as possible.
		This so-called leftmost-longest matching is the same semantics
		that early regular expression implementations used and that POSIX
		specifies.

		However, there can be multiple leftmost-longest matches, with different
		submatch choices, and here this package diverges from POSIX.
		Among the possible leftmost-longest matches, this package chooses
		the one that a backtracking search would have found first, while POSIX
		specifies that the match be chosen to maximize the length of the first
		subexpression, then the second, and so on from left to right.
		The POSIX rule is computationally prohibitive and not even well-defined.
		See https://swtch.com/~rsc/regexp/regexp2.html#posix for details.

	 func Match(pattern string, b []byte) (matched bool, err error)
		Match reports whether the byte slice b
		contains any match of the regular expression pattern.
		More complicated queries need to use Compile and the full Regexp interface.

	 func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
		MatchReader reports whether the text returned by the RuneReader
		contains any match of the regular expression pattern.
		More complicated queries need to use Compile and the full Regexp interface.

	 func MatchString(pattern string, s string) (matched bool, err error)
		MatchString reports whether the string s
		contains any match of the regular expression pattern.
		More complicated queries need to use Compile and the full Regexp interface.

	 func MustCompile(str string) *Regexp
		MustCompile is like Compile but panics if the expression cannot be parsed.
		It simplifies safe initialization of global variables holding compiled regular
		expressions.

	 func MustCompilePOSIX(str string) *Regexp
		MustCompilePOSIX is like CompilePOSIX but panics if the expression cannot be parsed.
		It simplifies safe initialization of global variables holding compiled regular
		expressions.

	 func QuoteMeta(s string) string
		QuoteMeta returns a string that escapes all regular expression metacharacters
		inside the argument text; the returned string is a regular expression matching
		the literal text.

	/* 22 unexporteds ... *//* 22 unexporteds: */
	 func cleanupOnePass(prog *onePassProg, original *syntax.Prog)
		cleanupOnePass drops working memory, and restores certain shortcut instructions.

	 func compile(expr string, mode syntax.Flags, longest bool) (*Regexp, error)
	 func compileOnePass(prog *syntax.Prog) (p *onePassProg)
		compileOnePass returns a new *syntax.Prog suitable for onePass execution if the original Prog
		can be recharacterized as a one-pass regexp program, or syntax.nil if the
		Prog cannot be converted. For a one pass prog, the fundamental condition that must
		be true is: at any InstAlt, there must be no ambiguity about what branch to  take.

	 func extract(str string) (name string, num int, rest string, ok bool)
		extract returns the name from a leading "$name" or "${name}" in str.
		If it is a number, extract returns num set to that number; otherwise num = -1.

	 func freeBitState(b *bitState)
	 func freeOnePassMachine(m *onePassMachine)
	 func init()
	 func iop(i *syntax.Inst) syntax.InstOp
	 func makeOnePass(p *onePassProg) *onePassProg
		makeOnePass creates a onepass Prog, if possible. It is possible if at any alt,
		the match engine can always tell which branch to take. The routine may modify
		p if it is turned into a onepass Prog. If it isn't possible for this to be a
		onepass Prog, the Prog nil is returned. makeOnePass is recursive
		to the size of the Prog.

	 func maxBitStateLen(prog *syntax.Prog) int
		maxBitStateLen returns the maximum length of a string to search with
		the backtracker using prog.

	 func mergeRuneSets(leftRunes, rightRunes *[]rune, leftPC, rightPC uint32) ([]rune, []uint32)
	 func minInputLen(re *syntax.Regexp) int
		minInputLen walks the regexp to find the minimum length of any matchable input

	 func newBitState() *bitState
	 func newLazyFlag(r1, r2 rune) lazyFlag
	 func newOnePassMachine() *onePassMachine
	 func newQueue(size int) (q *queueOnePass)
	 func onePassCopy(prog *syntax.Prog) *onePassProg
		onePassCopy creates a copy of the original Prog, as we'll be modifying it

	 func onePassNext(i *onePassInst, r rune) uint32
		OnePassNext selects the next actionable state of the prog, based on the input character.
		It should only be called when i.Op == InstAlt or InstAltMatch, and from the one-pass machine.
		One of the alternates may ultimately lead without input to end of line. If the instruction
		is InstAltMatch the path to the InstMatch is in i.Out, the normal node in i.Next.

	 func onePassPrefix(p *syntax.Prog) (prefix string, complete bool, pc uint32)
		OnePassPrefix returns a literal string that all matches for the
		regexp must start with. Complete is true if the prefix
		is the entire match. Pc is the index of the last rune instruction
		in the string. The OnePassPrefix skips over the mandatory
		EmptyBeginText

	 func quote(s string) string
	 func shouldBacktrack(prog *syntax.Prog) bool
		shouldBacktrack reports whether the program is too
		long for the backtracker to run.

	 func special(b byte) bool
		special reports whether byte b needs to be escaped by QuoteMeta.


Package-Level Variables (total 10, none are exported)

	/* 10 unexporteds ... *//* 10 unexporteds: */
	  var anyRune []rune
	  var anyRuneNotNL []rune
	  var arrayNoInts [0]int
		arrayNoInts is returned by doExecute match if nil dstCap is passed
		to it with ncap=0.

	  var bitStatePool sync.Pool
	  var matchPool [5]sync.Pool
		Pools of *machine for use during (*Regexp).doExecute,
		split up by the size of the execution queues.
		matchPool[i] machines have queue size matchSize[i].
		On a 64-bit system each queue entry is 16 bytes,
		so matchPool[0] has 16*2*128 = 4kB queues, etc.
		The final matchPool is a catch-all for very large queues.

	  var matchSize [5]int
		Pools of *machine for use during (*Regexp).doExecute,
		split up by the size of the execution queues.
		matchPool[i] machines have queue size matchSize[i].
		On a 64-bit system each queue entry is 16 bytes,
		so matchPool[0] has 16*2*128 = 4kB queues, etc.
		The final matchPool is a catch-all for very large queues.

	  var noNext []uint32
	  var noRune []rune
	  var onePassPool sync.Pool
	  var specialBytes [16]byte
		Bitmap used by func special to check whether a character needs to be escaped.


Package-Level Constants (total 6, none are exported)

	/* 6 unexporteds ... *//* 6 unexporteds: */
	const endOfText rune = -1
	const maxBacktrackProg = 500 // len(prog.Inst) <= max
	const maxBacktrackVector = 262144 // bit vector size <= max (bits)
	const mergeFailed uint32 = 4294967295
		mergeRuneSets merges two non-intersecting runesets, and returns the merged result,
		and a NextIp array. The idea is that if a rune matches the OnePassRunes at index
		i, NextIp[i/2] is the target. If the input sets intersect, an empty runeset and a
		NextIp array with the single element mergeFailed is returned.
		The code assumes that both inputs contain ordered and non-intersecting rune pairs.

	const startSize = 10 // The size at which to start a slice in the 'All' routines.
	const visitedBits = 32

The pages are generated with Golds v0.4.2. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.