package chroma

Import Path
	github.com/alecthomas/chroma/v2 (on go.dev)

Dependency Relation
	imports 19 packages, and imported by 7 packages

Involved Source Files

	    coalesce.go
	    colour.go
	    delegate.go
	  d doc.go
		Package chroma takes source code and other structured text and converts it into syntax highlighted HTML, ANSI-
		coloured text, etc.
		
		Chroma is based heavily on Pygments, and includes translators for Pygments lexers and styles.
		
		For more information, go here: https://github.com/alecthomas/chroma

	    emitters.go
	    formatter.go
	    iterator.go
	    lexer.go
	    mutators.go
	    regexp.go
	    registry.go
	    remap.go
	    serialise.go
	    style.go
	    tokentype_enumer.go
	    types.go
Package-Level Type Names (total 36)

	/* sort by: alphabet | popularity */
	 type AnalyseConfig (struct)
		AnalyseConfig defines the list of regexes analysers.

		Fields (total 2)
			First bool
				If true, the first matching score is returned.

			Regexes []RegexConfig

	 type Analyser (interface)
		Analyser determines how appropriate this lexer is for the given text.

		Methods (only one)
			( Analyser) AnalyseText(text string) float32
		Implemented By (at least 2)
			 Lexer (interface)
			*RegexLexer

	 type Colour int32 (basic type)
		Colour represents an RGB colour.

		Methods (total 11)
			( Colour) Blue() uint8
				Blue component of colour.

			( Colour) Brighten(factor float64) Colour
				Brighten returns a copy of this colour with its brightness adjusted.
				
				If factor is negative, the colour is darkened.
				
				Uses approach described here (http://www.pvladov.com/2012/09/make-color-lighter-or-darker.html).

			( Colour) BrightenOrDarken(factor float64) Colour
				BrightenOrDarken brightens a colour if it is < 0.5 brightness or darkens if > 0.5 brightness.

			( Colour) Brightness() float64
				Brightness of the colour (roughly) in the range 0.0 to 1.0.

			( Colour) ClampBrightness(min, max float64) Colour
				ClampBrightness returns a copy of this colour with its brightness adjusted such that
				it falls within the range [min, max] (or very close to it due to rounding errors).
				The supplied values use the same [0.0, 1.0] range as Brightness.

			( Colour) Distance(e2 Colour) float64
				Distance between this colour and another.
				
				This uses the approach described here (https://www.compuphase.com/cmetric.htm).
				This is not as accurate as LAB, et. al. but is *vastly* simpler and sufficient for our needs.

			( Colour) GoString() string
			( Colour) Green() uint8
				Green component of colour.

			( Colour) IsSet() bool
				IsSet returns true if the colour is set.

			( Colour) Red() uint8
				Red component of colour.

			( Colour) String() string
		Implements (at least 3)
			 Colour : expvar.Var
			 Colour : fmt.GoStringer
			 Colour : fmt.Stringer
		As Outputs Of (at least 6)
			func MustParseColour(colour string) Colour
			func NewColour(r, g, b uint8) Colour
			func ParseColour(colour string) Colour
			func Colour.Brighten(factor float64) Colour
			func Colour.BrightenOrDarken(factor float64) Colour
			func Colour.ClampBrightness(min, max float64) Colour
		As Inputs Of (at least one exported)
			func Colour.Distance(e2 Colour) float64

	 type Colours ([])
		Colours is an orderable set of colours.

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

	 type CompiledRule (struct)
		A CompiledRule is a Rule with a pre-compiled regex.
		
		Note that regular expressions are lazily compiled on first use of the lexer.

		Fields (total 5)
			Regexp *regexp2.Regexp
			Rule Rule
			Rule.Mutator Mutator
			Rule.Pattern string
			Rule.Type Emitter
		Methods (total 2)
			( CompiledRule) MarshalXML(e *xml.Encoder, _ xml.StartElement) error
			(*CompiledRule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
		Implements (at least 2)
			 CompiledRule : encoding/xml.Marshaler
			*CompiledRule : encoding/xml.Unmarshaler

	 type CompiledRules (map)
		CompiledRules is a map of rule name to sequence of compiled rules in that rule.

		As Inputs Of (at least one exported)
			func LexerMutator.MutateLexer(rules CompiledRules, state string, rule int) error

	 type Config (struct)
		Config for a lexer.

		Fields (total 11)
			AliasFilenames []string
				Secondary file name globs

			Aliases []string
				Shortcuts for the lexer

			Analyse *AnalyseConfig
				Analyse is a list of regexes to match against the input.
				
				If a match is found, the score is returned if single attribute is set to true,
				otherwise the sum of all the score of matching patterns will be
				used as the final score.

			CaseInsensitive bool
				Regex matching is case-insensitive.

			DotAll bool
				Regex matches all characters.

			EnsureNL bool
				Make sure that the input ends with a newline. This
				is required for some lexers that consume input linewise.

			Filenames []string
				File name globs

			MimeTypes []string
				MIME types

			Name string
				Name of the lexer.

			NotMultiline bool
				Regex does not match across lines ($ matches EOL).
				
				Defaults to multiline.

			Priority float32
				Priority of lexer.
				
				If this is 0 it will be treated as a default of 1.

		As Outputs Of (at least 2)
			func Lexer.Config() *Config
			func (*RegexLexer).Config() *Config
		As Inputs Of (at least 3)
			func MustNewLexer(config *Config, rules func() Rules) *RegexLexer
			func NewLexer(config *Config, rulesFunc func() Rules) (*RegexLexer, error)
			func (*RegexLexer).SetConfig(config *Config) *RegexLexer

	 type Emitter (interface)
		An Emitter takes group matches and returns tokens.

		Methods (only one)
			( Emitter) Emit(groups []string, state *LexerState) Iterator
				Emit tokens for the given regex groups.

		Implemented By (at least 3)
			 EmitterFunc
			 SerialisableEmitter (interface)
			 TokenType
		As Outputs Of (at least 6)
			func ByGroupNames(emitters map[string]Emitter) Emitter
			func ByGroups(emitters ...Emitter) Emitter
			func Using(lexer string) Emitter
			func UsingByGroup(sublexerNameGroup, codeGroup int, emitters ...Emitter) Emitter
			func UsingLexer(lexer Lexer) Emitter
			func UsingSelf(stateName string) Emitter
		As Inputs Of (at least 3)
			func ByGroupNames(emitters map[string]Emitter) Emitter
			func ByGroups(emitters ...Emitter) Emitter
			func UsingByGroup(sublexerNameGroup, codeGroup int, emitters ...Emitter) Emitter

	 type EmitterFunc (func)
		EmitterFunc is a function that is an Emitter.

		Methods (only one)
			( EmitterFunc) Emit(groups []string, state *LexerState) Iterator
				Emit tokens for groups.

		Implements (at least one exported)
			 EmitterFunc : Emitter

	 type Emitters ([])

		Methods (total 2)
			( Emitters) MarshalXML(e *xml.Encoder, start xml.StartElement) error
			(*Emitters) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
		Implements (at least 2)
			 Emitters : encoding/xml.Marshaler
			*Emitters : encoding/xml.Unmarshaler

	 type Formatter (interface)
		A Formatter for Chroma lexers.

		Methods (only one)
			( Formatter) Format(w io.Writer, style *Style, iterator Iterator) error
				Format returns a formatting function for tokens.
				
				If the iterator panics, the Formatter should recover.

		Implemented By (at least 3)
			 FormatterFunc
			*github.com/alecthomas/chroma/v2/formatters/html.Formatter
			*github.com/alecthomas/chroma/v2/formatters/svg.Formatter
		As Outputs Of (at least 3)
			func RecoveringFormatter(formatter Formatter) Formatter
			func github.com/alecthomas/chroma/v2/formatters.Get(name string) Formatter
			func github.com/alecthomas/chroma/v2/formatters.Register(name string, formatter Formatter) Formatter
		As Inputs Of (at least 2)
			func RecoveringFormatter(formatter Formatter) Formatter
			func github.com/alecthomas/chroma/v2/formatters.Register(name string, formatter Formatter) Formatter
		As Types Of (total 10)
			  var github.com/alecthomas/chroma/v2/formatters.Fallback
			  var github.com/alecthomas/chroma/v2/formatters.JSON
			  var github.com/alecthomas/chroma/v2/formatters.NoOp
			  var github.com/alecthomas/chroma/v2/formatters.SVG
			  var github.com/alecthomas/chroma/v2/formatters.Tokens
			  var github.com/alecthomas/chroma/v2/formatters.TTY
			  var github.com/alecthomas/chroma/v2/formatters.TTY16
			  var github.com/alecthomas/chroma/v2/formatters.TTY16m
			  var github.com/alecthomas/chroma/v2/formatters.TTY256
			  var github.com/alecthomas/chroma/v2/formatters.TTY8

	 type FormatterFunc (func)
		A FormatterFunc is a Formatter implemented as a function.
		
		Guards against iterator panics.

		Methods (only one)
			( FormatterFunc) Format(w io.Writer, s *Style, it Iterator) (err error)
		Implements (at least one exported)
			 FormatterFunc : Formatter

	 type Iterator (func)
		An Iterator across tokens.
		
		EOF will be returned at the end of the Token stream.
		
		If an error occurs within an Iterator, it may propagate this in a panic. Formatters should recover.

		Methods (only one)
			( Iterator) Tokens() []Token
				Tokens consumes all tokens from the iterator and returns them as a slice.

		As Outputs Of (at least 8)
			func Concaterator(iterators ...Iterator) Iterator
			func Literator(tokens ...Token) Iterator
			func Emitter.Emit(groups []string, state *LexerState) Iterator
			func EmitterFunc.Emit(groups []string, state *LexerState) Iterator
			func Lexer.Tokenise(options *TokeniseOptions, text string) (Iterator, error)
			func (*RegexLexer).Tokenise(options *TokeniseOptions, text string) (Iterator, error)
			func SerialisableEmitter.Emit(groups []string, state *LexerState) Iterator
			func TokenType.Emit(groups []string, _ *LexerState) Iterator
		As Inputs Of (at least 5)
			func Concaterator(iterators ...Iterator) Iterator
			func Formatter.Format(w io.Writer, style *Style, iterator Iterator) error
			func FormatterFunc.Format(w io.Writer, s *Style, it Iterator) (err error)
			func github.com/alecthomas/chroma/v2/formatters/html.(*Formatter).Format(w io.Writer, style *Style, iterator Iterator) (err error)
			func github.com/alecthomas/chroma/v2/formatters/svg.(*Formatter).Format(w io.Writer, style *Style, iterator Iterator) (err error)

	 type Lexer (interface)
		A Lexer for tokenising source code.

		Methods (total 5)
			( Lexer) AnalyseText(text string) float32
				AnalyseText scores how likely a fragment of text is to match
				this lexer, between 0.0 and 1.0. A value of 1 indicates high confidence.

			( Lexer) Config() *Config
				Config describing the features of the Lexer.

			( Lexer) SetAnalyser(analyser func(text string) float32) Lexer
				SetAnalyser sets a function the Lexer should use for scoring how
				likely a fragment of text is to match this lexer, between 0.0 and 1.0.
				A value of 1 indicates high confidence.
				
				Lexers may ignore this if they implement their own analysers.

			( Lexer) SetRegistry(registry *LexerRegistry) Lexer
				SetRegistry sets the registry this Lexer is associated with.
				
				The registry should be used by the Lexer if it needs to look up other
				lexers.

			( Lexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error)
				Tokenise returns an Iterator over tokens in text.

		Implemented By (at least one exported)
			*RegexLexer
		Implements (at least one exported)
			 Lexer : Analyser
		As Outputs Of (at least 18)
			func Coalesce(lexer Lexer) Lexer
			func DelegatingLexer(root Lexer, language Lexer) Lexer
			func RemappingLexer(lexer Lexer, mapper func(Token) []Token) Lexer
			func TypeRemappingLexer(lexer Lexer, mapping TypeMapping) Lexer
			func Lexer.SetAnalyser(analyser func(text string) float32) Lexer
			func Lexer.SetRegistry(registry *LexerRegistry) Lexer
			func (*LexerRegistry).Analyse(text string) Lexer
			func (*LexerRegistry).Get(name string) Lexer
			func (*LexerRegistry).Match(filename string) Lexer
			func (*LexerRegistry).MatchMimeType(mimeType string) Lexer
			func (*LexerRegistry).Register(lexer Lexer) Lexer
			func (*RegexLexer).SetAnalyser(analyser func(text string) float32) Lexer
			func (*RegexLexer).SetRegistry(registry *LexerRegistry) Lexer
			func github.com/alecthomas/chroma/v2/lexers.Analyse(text string) Lexer
			func github.com/alecthomas/chroma/v2/lexers.Get(name string) Lexer
			func github.com/alecthomas/chroma/v2/lexers.Match(filename string) Lexer
			func github.com/alecthomas/chroma/v2/lexers.MatchMimeType(mimeType string) Lexer
			func github.com/alecthomas/chroma/v2/lexers.Register(lexer Lexer) Lexer
		As Inputs Of (at least 9)
			func Coalesce(lexer Lexer) Lexer
			func DelegatingLexer(root Lexer, language Lexer) Lexer
			func DelegatingLexer(root Lexer, language Lexer) Lexer
			func RemappingLexer(lexer Lexer, mapper func(Token) []Token) Lexer
			func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, error)
			func TypeRemappingLexer(lexer Lexer, mapping TypeMapping) Lexer
			func UsingLexer(lexer Lexer) Emitter
			func (*LexerRegistry).Register(lexer Lexer) Lexer
			func github.com/alecthomas/chroma/v2/lexers.Register(lexer Lexer) Lexer
		As Types Of (total 18)
			  var github.com/alecthomas/chroma/v2/lexers.Caddyfile
			  var github.com/alecthomas/chroma/v2/lexers.CaddyfileDirectives
			  var github.com/alecthomas/chroma/v2/lexers.CommonLisp
			  var github.com/alecthomas/chroma/v2/lexers.EmacsLisp
			  var github.com/alecthomas/chroma/v2/lexers.Fallback
			  var github.com/alecthomas/chroma/v2/lexers.Genshi
			  var github.com/alecthomas/chroma/v2/lexers.GenshiHTMLTemplate
			  var github.com/alecthomas/chroma/v2/lexers.GenshiText
			  var github.com/alecthomas/chroma/v2/lexers.Go
			  var github.com/alecthomas/chroma/v2/lexers.GoHTMLTemplate
			  var github.com/alecthomas/chroma/v2/lexers.GoTextTemplate
			  var github.com/alecthomas/chroma/v2/lexers.Haxe
			  var github.com/alecthomas/chroma/v2/lexers.HTTP
			  var github.com/alecthomas/chroma/v2/lexers.Markdown
			  var github.com/alecthomas/chroma/v2/lexers.Raku
			  var github.com/alecthomas/chroma/v2/lexers.Restructuredtext
			  var github.com/alecthomas/chroma/v2/lexers.Svelte
			  var github.com/alecthomas/chroma/v2/lexers.Typoscript

	 type LexerMutator (interface)
		A LexerMutator is an additional interface that a Mutator can implement
		to modify the lexer when it is compiled.

		Methods (only one)
			( LexerMutator) MutateLexer(rules CompiledRules, state string, rule int) error
				MutateLexer can be implemented to mutate the lexer itself.
				
				Rules are the lexer rules, state is the state key for the rule the mutator is associated with.


	 type LexerRegistry (struct)
		LexerRegistry is a registry of Lexers.

		Fields (only one)
			Lexers Lexers
		Methods (total 6)
			(*LexerRegistry) Analyse(text string) Lexer
				Analyse text content and return the "best" lexer..

			(*LexerRegistry) Get(name string) Lexer
				Get a Lexer by name, alias or file extension.

			(*LexerRegistry) Match(filename string) Lexer
				Match returns the first lexer matching filename.
				
				Note that this iterates over all file patterns in all lexers, so is not fast.

			(*LexerRegistry) MatchMimeType(mimeType string) Lexer
				MatchMimeType attempts to find a lexer for the given MIME type.

			(*LexerRegistry) Names(withAliases bool) []string
				Names of all lexers, optionally including aliases.

			(*LexerRegistry) Register(lexer Lexer) Lexer
				Register a Lexer with the LexerRegistry. If the lexer is already registered
				it will be replaced.

		As Outputs Of (at least one exported)
			func NewLexerRegistry() *LexerRegistry
		As Inputs Of (at least 2)
			func Lexer.SetRegistry(registry *LexerRegistry) Lexer
			func (*RegexLexer).SetRegistry(registry *LexerRegistry) Lexer
		As Types Of (only one)
			  var github.com/alecthomas/chroma/v2/lexers.GlobalLexerRegistry *LexerRegistry

	 type Lexers ([])
		Lexers is a slice of lexers sortable by name.

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

	 type LexerState (struct)
		LexerState contains the state for a single lex.

		Fields (total 11)
			Groups []string
				Group matches.

			Lexer *RegexLexer
			MutatorContext map[interface{}]interface{}
				Custum context for mutators.

			NamedGroups map[string]string
				Named Group matches.

			Pos int
			Registry *LexerRegistry
			Rule int
			Rules CompiledRules
			Stack []string
			State string
			Text []rune
		Methods (total 3)
			(*LexerState) Get(key interface{}) interface{}
				Get mutator context.

			(*LexerState) Iterator() Token
				Iterator returns the next Token from the lexer.

			(*LexerState) Set(key interface{}, value interface{})
				Set mutator context.

		As Inputs Of (at least 7)
			func Emitter.Emit(groups []string, state *LexerState) Iterator
			func EmitterFunc.Emit(groups []string, state *LexerState) Iterator
			func Mutator.Mutate(state *LexerState) error
			func MutatorFunc.Mutate(state *LexerState) error
			func SerialisableEmitter.Emit(groups []string, state *LexerState) Iterator
			func SerialisableMutator.Mutate(state *LexerState) error
			func TokenType.Emit(groups []string, _ *LexerState) Iterator

	 type Mutator (interface)
		A Mutator modifies the behaviour of the lexer.

		Methods (only one)
			( Mutator) Mutate(state *LexerState) error
				Mutate the lexer state machine as it is processing.

		Implemented By (at least 2)
			 MutatorFunc
			 SerialisableMutator (interface)
		As Outputs Of (at least 4)
			func Combined(states ...string) Mutator
			func Mutators(modifiers ...Mutator) Mutator
			func Pop(n int) Mutator
			func Push(states ...string) Mutator
		As Inputs Of (at least 2)
			func Default(mutators ...Mutator) Rule
			func Mutators(modifiers ...Mutator) Mutator

	 type MutatorFunc (func)
		A MutatorFunc is a Mutator that mutates the lexer state machine as it is processing.

		Methods (only one)
			( MutatorFunc) Mutate(state *LexerState) error
		Implements (at least one exported)
			 MutatorFunc : Mutator

	 type PrioritisedLexers ([])
		PrioritisedLexers is a slice of lexers sortable by priority.

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

	 type RegexConfig (struct)
		RegexConfig defines a single regex pattern and its score in case of match.

		Fields (total 2)
			Pattern string
			Score float32

	 type RegexLexer (struct)
		RegexLexer is the default lexer implementation used in Chroma.

		Methods (total 10)
			(*RegexLexer) AnalyseText(text string) float32
				AnalyseText scores how likely a fragment of text is to match this lexer, between 0.0 and 1.0.

			(*RegexLexer) Config() *Config
				Config returns the Config for this Lexer.

			(*RegexLexer) MustRules() Rules
				MustRules is like Rules() but will panic on error.

			(*RegexLexer) Rules() (Rules, error)
				Rules in the Lexer.

			(*RegexLexer) SetAnalyser(analyser func(text string) float32) Lexer
				SetAnalyser sets the analyser function used to perform content inspection.

			(*RegexLexer) SetConfig(config *Config) *RegexLexer
				SetConfig replaces the Config for this Lexer.

			(*RegexLexer) SetRegistry(registry *LexerRegistry) Lexer
				SetRegistry the lexer will use to lookup other lexers if necessary.

			(*RegexLexer) String() string
			(*RegexLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error)
				Tokenise text using lexer, returning an iterator.

			(*RegexLexer) Trace(trace bool) *RegexLexer
				Trace enables debug tracing.

		Implements (at least 4)
			*RegexLexer : Analyser
			*RegexLexer : Lexer
			*RegexLexer : expvar.Var
			*RegexLexer : fmt.Stringer
		As Outputs Of (at least 7)
			func MustNewLexer(config *Config, rules func() Rules) *RegexLexer
			func MustNewXMLLexer(from fs.FS, path string) *RegexLexer
			func NewLexer(config *Config, rulesFunc func() Rules) (*RegexLexer, error)
			func NewXMLLexer(from fs.FS, path string) (*RegexLexer, error)
			func Unmarshal(data []byte) (*RegexLexer, error)
			func (*RegexLexer).SetConfig(config *Config) *RegexLexer
			func (*RegexLexer).Trace(trace bool) *RegexLexer
		As Inputs Of (at least one exported)
			func Marshal(l *RegexLexer) ([]byte, error)
		As Types Of (only one)
			  var github.com/alecthomas/chroma/v2/lexers.HTML *RegexLexer

	 type Rule (struct)
		A Rule is the fundamental matching unit of the Regex lexer state machine.

		Fields (total 3)
			Mutator Mutator
			Pattern string
			Type Emitter
		Methods (total 2)
			( Rule) MarshalXML(e *xml.Encoder, _ xml.StartElement) error
			(*Rule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
		Implements (at least 2)
			 Rule : encoding/xml.Marshaler
			*Rule : encoding/xml.Unmarshaler
		As Outputs Of (at least 2)
			func Default(mutators ...Mutator) Rule
			func Include(state string) Rule

	 type Rules (map)
		Rules maps from state to a sequence of Rules.

		Methods (total 5)
			( Rules) Clone() Rules
				Clone returns a clone of the Rules.

			( Rules) MarshalXML(e *xml.Encoder, _ xml.StartElement) error
			( Rules) Merge(rules Rules) Rules
				Merge creates a clone of "r" then merges "rules" into the clone.

			( Rules) Rename(oldRule, newRule string) Rules
				Rename clones rules then a rule.

			(*Rules) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
		Implements (at least 2)
			 Rules : encoding/xml.Marshaler
			*Rules : encoding/xml.Unmarshaler
		As Outputs Of (at least 6)
			func (*RegexLexer).MustRules() Rules
			func (*RegexLexer).Rules() (Rules, error)
			func Rules.Clone() Rules
			func Rules.Merge(rules Rules) Rules
			func Rules.Rename(oldRule, newRule string) Rules
			func github.com/alecthomas/chroma/v2/lexers.PlaintextRules() Rules
		As Inputs Of (at least one exported)
			func Rules.Merge(rules Rules) Rules

	 type SerialisableEmitter (interface)
		SerialisableEmitter is an Emitter that can be serialised and deserialised to/from JSON.

		Methods (total 2)
			( SerialisableEmitter) Emit(groups []string, state *LexerState) Iterator
				Emit tokens for the given regex groups.

			( SerialisableEmitter) EmitterKind() string
		Implemented By (at least one exported)
			 TokenType
		Implements (at least one exported)
			 SerialisableEmitter : Emitter

	 type SerialisableMutator (interface)
		SerialisableMutator is a Mutator that can be serialised and deserialised.

		Methods (total 2)
			( SerialisableMutator) Mutate(state *LexerState) error
				Mutate the lexer state machine as it is processing.

			( SerialisableMutator) MutatorKind() string
		Implements (at least one exported)
			 SerialisableMutator : Mutator

	 type Style (struct)
		A Style definition.
		
		See http://pygments.org/docs/styles/ for details. Semantics are intended to be identical.

		Fields (only one)
			Name string
		Methods (total 6)
			(*Style) Builder() *StyleBuilder
				Builder creates a mutable builder from this Style.
				
				The builder can then be safely modified. This is a cheap operation.

			(*Style) Get(ttype TokenType) StyleEntry
				Get a style entry. Will try sub-category or category if an exact match is not found, and
				finally return the Background.

			(*Style) Has(ttype TokenType) bool
				Has checks if an exact style entry match exists for a token type.
				
				This is distinct from Get() which will merge parent tokens.

			(*Style) MarshalXML(e *xml.Encoder, start xml.StartElement) error
			(*Style) Types() []TokenType
				Types that are styled.

			(*Style) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
		Implements (at least 2)
			*Style : encoding/xml.Marshaler
			*Style : encoding/xml.Unmarshaler
		As Outputs Of (at least 7)
			func MustNewStyle(name string, entries StyleEntries) *Style
			func MustNewXMLStyle(r io.Reader) *Style
			func NewStyle(name string, entries StyleEntries) (*Style, error)
			func NewXMLStyle(r io.Reader) (*Style, error)
			func (*StyleBuilder).Build() (*Style, error)
			func github.com/alecthomas/chroma/v2/styles.Get(name string) *Style
			func github.com/alecthomas/chroma/v2/styles.Register(style *Style) *Style
		As Inputs Of (at least 6)
			func Formatter.Format(w io.Writer, style *Style, iterator Iterator) error
			func FormatterFunc.Format(w io.Writer, s *Style, it Iterator) (err error)
			func github.com/alecthomas/chroma/v2/formatters/html.(*Formatter).Format(w io.Writer, style *Style, iterator Iterator) (err error)
			func github.com/alecthomas/chroma/v2/formatters/html.(*Formatter).WriteCSS(w io.Writer, style *Style) error
			func github.com/alecthomas/chroma/v2/formatters/svg.(*Formatter).Format(w io.Writer, style *Style, iterator Iterator) (err error)
			func github.com/alecthomas/chroma/v2/styles.Register(style *Style) *Style
		As Types Of (total 60)
			  var github.com/alecthomas/chroma/v2/styles.Abap *Style
			  var github.com/alecthomas/chroma/v2/styles.Algol *Style
			  var github.com/alecthomas/chroma/v2/styles.AlgolNu *Style
			  var github.com/alecthomas/chroma/v2/styles.Arduino *Style
			  var github.com/alecthomas/chroma/v2/styles.Autumn *Style
			  var github.com/alecthomas/chroma/v2/styles.Average *Style
			  var github.com/alecthomas/chroma/v2/styles.Base16Snazzy *Style
			  var github.com/alecthomas/chroma/v2/styles.BlackWhite *Style
			  var github.com/alecthomas/chroma/v2/styles.Borland *Style
			  var github.com/alecthomas/chroma/v2/styles.CatppuccinFrappe *Style
			  var github.com/alecthomas/chroma/v2/styles.CatppuccinLatte *Style
			  var github.com/alecthomas/chroma/v2/styles.CatppuccinMacchiato *Style
			  var github.com/alecthomas/chroma/v2/styles.CatppuccinMocha *Style
			  var github.com/alecthomas/chroma/v2/styles.Colorful *Style
			  var github.com/alecthomas/chroma/v2/styles.DoomOne *Style
			  var github.com/alecthomas/chroma/v2/styles.DoomOne2 *Style
			  var github.com/alecthomas/chroma/v2/styles.Dracula *Style
			  var github.com/alecthomas/chroma/v2/styles.Emacs *Style
			  var github.com/alecthomas/chroma/v2/styles.Fallback *Style
			  var github.com/alecthomas/chroma/v2/styles.Friendly *Style
			  var github.com/alecthomas/chroma/v2/styles.Fruity *Style
			  var github.com/alecthomas/chroma/v2/styles.GitHub *Style
			  var github.com/alecthomas/chroma/v2/styles.GitHubDark *Style
			  var github.com/alecthomas/chroma/v2/styles.Gruvbox *Style
			  var github.com/alecthomas/chroma/v2/styles.GruvboxLight *Style
			  var github.com/alecthomas/chroma/v2/styles.HrDark *Style
			  var github.com/alecthomas/chroma/v2/styles.HrHighContrast *Style
			  var github.com/alecthomas/chroma/v2/styles.Igor *Style
			  var github.com/alecthomas/chroma/v2/styles.Lovelace *Style
			  var github.com/alecthomas/chroma/v2/styles.Manni *Style
			  var github.com/alecthomas/chroma/v2/styles.ModusOperandi *Style
			  var github.com/alecthomas/chroma/v2/styles.ModusVivendi *Style
			  var github.com/alecthomas/chroma/v2/styles.Monokai *Style
			  var github.com/alecthomas/chroma/v2/styles.MonokaiLight *Style
			  var github.com/alecthomas/chroma/v2/styles.Murphy *Style
			  var github.com/alecthomas/chroma/v2/styles.Native *Style
			  var github.com/alecthomas/chroma/v2/styles.Nord *Style
			  var github.com/alecthomas/chroma/v2/styles.OnesEnterprise *Style
			  var github.com/alecthomas/chroma/v2/styles.ParaisoDark *Style
			  var github.com/alecthomas/chroma/v2/styles.ParaisoLight *Style
			  var github.com/alecthomas/chroma/v2/styles.Pastie *Style
			  var github.com/alecthomas/chroma/v2/styles.Perldoc *Style
			  var github.com/alecthomas/chroma/v2/styles.Pygments *Style
			  var github.com/alecthomas/chroma/v2/styles.RainbowDash *Style
			  var github.com/alecthomas/chroma/v2/styles.RosePine *Style
			  var github.com/alecthomas/chroma/v2/styles.RosePineDawn *Style
			  var github.com/alecthomas/chroma/v2/styles.RosePineMoon *Style
			  var github.com/alecthomas/chroma/v2/styles.Rrt *Style
			  var github.com/alecthomas/chroma/v2/styles.SolarizedDark *Style
			  var github.com/alecthomas/chroma/v2/styles.SolarizedDark256 *Style
			  var github.com/alecthomas/chroma/v2/styles.SolarizedLight *Style
			  var github.com/alecthomas/chroma/v2/styles.SwapOff *Style
			  var github.com/alecthomas/chroma/v2/styles.Tango *Style
			  var github.com/alecthomas/chroma/v2/styles.Trac *Style
			  var github.com/alecthomas/chroma/v2/styles.Vim *Style
			  var github.com/alecthomas/chroma/v2/styles.VisualStudio *Style
			  var github.com/alecthomas/chroma/v2/styles.Vulcan *Style
			  var github.com/alecthomas/chroma/v2/styles.WitchHazel *Style
			  var github.com/alecthomas/chroma/v2/styles.Xcode *Style
			  var github.com/alecthomas/chroma/v2/styles.XcodeDark *Style

	 type StyleBuilder (struct)
		A StyleBuilder is a mutable structure for building styles.
		
		Once built, a Style is immutable.

		Methods (total 6)
			(*StyleBuilder) Add(ttype TokenType, entry string) *StyleBuilder
				Add an entry to the Style map.
				
				See http://pygments.org/docs/styles/#style-rules for details.

			(*StyleBuilder) AddAll(entries StyleEntries) *StyleBuilder
			(*StyleBuilder) AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder
			(*StyleBuilder) Build() (*Style, error)
			(*StyleBuilder) Get(ttype TokenType) StyleEntry
			(*StyleBuilder) Transform(transform func(StyleEntry) StyleEntry) *StyleBuilder
				Transform passes each style entry currently defined in the builder to the supplied
				function and saves the returned value. This can be used to adjust a style's colours;
				see Colour's ClampBrightness function, for example.

		As Outputs Of (at least 6)
			func NewStyleBuilder(name string) *StyleBuilder
			func (*Style).Builder() *StyleBuilder
			func (*StyleBuilder).Add(ttype TokenType, entry string) *StyleBuilder
			func (*StyleBuilder).AddAll(entries StyleEntries) *StyleBuilder
			func (*StyleBuilder).AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder
			func (*StyleBuilder).Transform(transform func(StyleEntry) StyleEntry) *StyleBuilder

	 type StyleEntries (map)
		StyleEntries mapping TokenType to colour definition.

		As Inputs Of (at least 3)
			func MustNewStyle(name string, entries StyleEntries) *Style
			func NewStyle(name string, entries StyleEntries) (*Style, error)
			func (*StyleBuilder).AddAll(entries StyleEntries) *StyleBuilder

	 type StyleEntry (struct)
		A StyleEntry in the Style map.

		Fields (total 7)
			Background Colour
			Bold Trilean
			Border Colour
			Colour Colour
				Hex colours.

			Italic Trilean
			NoInherit bool
			Underline Trilean
		Methods (total 5)
			( StyleEntry) Inherit(ancestors ...StyleEntry) StyleEntry
				Inherit styles from ancestors.
				
				Ancestors should be provided from oldest to newest.

			( StyleEntry) IsZero() bool
			( StyleEntry) MarshalText() ([]byte, error)
			( StyleEntry) String() string
			( StyleEntry) Sub(e StyleEntry) StyleEntry
				Sub subtracts e from s where elements match.

		Implements (at least 4)
			 StyleEntry : encoding.TextMarshaler
			 StyleEntry : expvar.Var
			 StyleEntry : fmt.Stringer
			 StyleEntry : gopkg.in/yaml.v3.IsZeroer
		As Outputs Of (at least 6)
			func MustParseStyleEntry(entry string) StyleEntry
			func ParseStyleEntry(entry string) (StyleEntry, error)
			func (*Style).Get(ttype TokenType) StyleEntry
			func (*StyleBuilder).Get(ttype TokenType) StyleEntry
			func StyleEntry.Inherit(ancestors ...StyleEntry) StyleEntry
			func StyleEntry.Sub(e StyleEntry) StyleEntry
		As Inputs Of (at least 5)
			func (*StyleBuilder).AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder
			func StyleEntry.Inherit(ancestors ...StyleEntry) StyleEntry
			func StyleEntry.Sub(e StyleEntry) StyleEntry
			func github.com/alecthomas/chroma/v2/formatters/html.StyleEntryToCSS(e StyleEntry) string
			func github.com/alecthomas/chroma/v2/formatters/svg.StyleEntryToSVG(e StyleEntry) string

	 type Token (struct)
		Token output to formatter.

		Fields (total 2)
			Type TokenType
			Value string
		Methods (total 3)
			(*Token) Clone() Token
				Clone returns a clone of the Token.

			(*Token) GoString() string
			(*Token) String() string
		Implements (at least 3)
			*Token : expvar.Var
			*Token : fmt.GoStringer
			*Token : fmt.Stringer
		As Outputs Of (at least 5)
			func SplitTokensIntoLines(tokens []Token) (out [][]Token)
			func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, error)
			func Iterator.Tokens() []Token
			func (*LexerState).Iterator() Token
			func (*Token).Clone() Token
		As Inputs Of (at least 3)
			func Literator(tokens ...Token) Iterator
			func SplitTokensIntoLines(tokens []Token) (out [][]Token)
			func Stringify(tokens ...Token) string
		As Types Of (only one)
			  var EOF

	 type TokeniseOptions (struct)
		TokeniseOptions contains options for tokenisers.

		Fields (total 3)
			EnsureLF bool
				If true, all EOLs are converted into LF
				by replacing CRLF and CR

			Nested bool
				Nested tokenisation.

			State string
				State to start tokenisation in. Defaults to "root".

		As Inputs Of (at least 3)
			func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, error)
			func Lexer.Tokenise(options *TokeniseOptions, text string) (Iterator, error)
			func (*RegexLexer).Tokenise(options *TokeniseOptions, text string) (Iterator, error)

	 type TokenType int (basic type)
		TokenType is the type of token to highlight.
		
		It is also an Emitter, emitting a single token of itself

		Methods (total 13)
			( TokenType) Category() TokenType
			( TokenType) Emit(groups []string, _ *LexerState) Iterator
			( TokenType) EmitterKind() string
			( TokenType) InCategory(other TokenType) bool
			( TokenType) InSubCategory(other TokenType) bool
			( TokenType) IsATokenType() bool
				IsATokenType returns "true" if the value is listed in the enum definition. "false" otherwise

			( TokenType) MarshalText() ([]byte, error)
				MarshalText implements the encoding.TextMarshaler interface for TokenType

			( TokenType) MarshalXML(e *xml.Encoder, start xml.StartElement) error
			( TokenType) Parent() TokenType
			( TokenType) String() string
			( TokenType) SubCategory() TokenType
			(*TokenType) UnmarshalText(text []byte) error
				UnmarshalText implements the encoding.TextUnmarshaler interface for TokenType

			(*TokenType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
		Implements (at least 8)
			 TokenType : Emitter
			 TokenType : SerialisableEmitter
			 TokenType : encoding.TextMarshaler
			*TokenType : encoding.TextUnmarshaler
			 TokenType : encoding/xml.Marshaler
			*TokenType : encoding/xml.Unmarshaler
			 TokenType : expvar.Var
			 TokenType : fmt.Stringer
		As Outputs Of (at least 6)
			func TokenTypeString(s string) (TokenType, error)
			func TokenTypeValues() []TokenType
			func (*Style).Types() []TokenType
			func TokenType.Category() TokenType
			func TokenType.Parent() TokenType
			func TokenType.SubCategory() TokenType
		As Inputs Of (at least 8)
			func (*Style).Get(ttype TokenType) StyleEntry
			func (*Style).Has(ttype TokenType) bool
			func (*StyleBuilder).Add(ttype TokenType, entry string) *StyleBuilder
			func (*StyleBuilder).AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder
			func (*StyleBuilder).Get(ttype TokenType) StyleEntry
			func TokenType.InCategory(other TokenType) bool
			func TokenType.InSubCategory(other TokenType) bool
			func github.com/alecthomas/chroma/v2/formatters/html.WithCustomCSS(css map[TokenType]string) html.Option
		As Types Of (total 122)
			const Background
			const CodeLine
			const Comment
			const CommentHashbang
			const CommentMultiline
			const CommentPreproc
			const CommentPreprocFile
			const CommentSingle
			const CommentSpecial
			const Date
			const EOFType
			const Error
			const Generic
			const GenericDeleted
			const GenericEmph
			const GenericError
			const GenericHeading
			const GenericInserted
			const GenericOutput
			const GenericPrompt
			const GenericStrong
			const GenericSubheading
			const GenericTraceback
			const GenericUnderline
			const Keyword
			const KeywordConstant
			const KeywordDeclaration
			const KeywordNamespace
			const KeywordPseudo
			const KeywordReserved
			const KeywordType
			const Line
			const LineHighlight
			const LineLink
			const LineNumbers
			const LineNumbersTable
			const LineTable
			const LineTableTD
			const Literal
			const LiteralDate
			const LiteralNumber
			const LiteralNumberBin
			const LiteralNumberFloat
			const LiteralNumberHex
			const LiteralNumberInteger
			const LiteralNumberIntegerLong
			const LiteralNumberOct
			const LiteralOther
			const LiteralString
			const LiteralStringAffix
			const LiteralStringAtom
			const LiteralStringBacktick
			const LiteralStringBoolean
			const LiteralStringChar
			const LiteralStringDelimiter
			const LiteralStringDoc
			const LiteralStringDouble
			const LiteralStringEscape
			const LiteralStringHeredoc
			const LiteralStringInterpol
			const LiteralStringName
			const LiteralStringOther
			const LiteralStringRegex
			const LiteralStringSingle
			const LiteralStringSymbol
			const Name
			const NameAttribute
			const NameBuiltin
			const NameBuiltinPseudo
			const NameClass
			const NameConstant
			const NameDecorator
			const NameEntity
			const NameException
			const NameFunction
			const NameFunctionMagic
			const NameKeyword
			const NameLabel
			const NameNamespace
			const NameOperator
			const NameOther
			const NameProperty
			const NamePseudo
			const NameTag
			const NameVariable
			const NameVariableAnonymous
			const NameVariableClass
			const NameVariableGlobal
			const NameVariableInstance
			const NameVariableMagic
			const None
			const Number
			const NumberBin
			const NumberFloat
			const NumberHex
			const NumberInteger
			const NumberIntegerLong
			const NumberOct
			const Operator
			const OperatorWord
			const Other
			const PreWrapper
			const Punctuation
			const String
			const StringAffix
			const StringBacktick
			const StringChar
			const StringDelimiter
			const StringDoc
			const StringDouble
			const StringEscape
			const StringHeredoc
			const StringInterpol
			const StringOther
			const StringRegex
			const StringSingle
			const StringSymbol
			const Text
			const TextPunctuation
			const TextSymbol
			const TextWhitespace
			const Whitespace

	 type Trilean uint8 (basic type)
		Trilean value for StyleEntry value inheritance.

		Methods (total 2)
			( Trilean) Prefix(s string) string
				Prefix returns s with "no" as a prefix if Trilean is no.

			( Trilean) String() string
		Implements (at least 2)
			 Trilean : expvar.Var
			 Trilean : fmt.Stringer
		As Types Of (total 3)
			const No
			const Pass
			const Yes

	 type TypeMapping ([])
		TypeMapping defines type maps for the TypeRemappingLexer.

		As Inputs Of (at least one exported)
			func TypeRemappingLexer(lexer Lexer, mapping TypeMapping) Lexer


Package-Level Functions (total 43)

	 func ByGroupNames(emitters map[string]Emitter) Emitter
		ByGroupNames emits a token for each named matching group in the rule's regex.

	 func ByGroups(emitters ...Emitter) Emitter
		ByGroups emits a token for each matching group in the rule's regex.

	 func Coalesce(lexer Lexer) Lexer
		Coalesce is a Lexer interceptor that collapses runs of common types into a single token.

	 func Combined(states ...string) Mutator
		Combined creates a new anonymous state from the given states, and pushes that state.

	 func Concaterator(iterators ...Iterator) Iterator
		Concaterator concatenates tokens from a series of iterators.

	 func Default(mutators ...Mutator) Rule
		Default returns a Rule that applies a set of Mutators.

	 func DelegatingLexer(root Lexer, language Lexer) Lexer
		DelegatingLexer combines two lexers to handle the common case of a language embedded inside another, such as PHP
		inside HTML or PHP inside plain text.
		
		It takes two lexer as arguments: a root lexer and a language lexer.  First everything is scanned using the language
		lexer, which must return "Other" for unrecognised tokens. Then all "Other" tokens are lexed using the root lexer.
		Finally, these two sets of tokens are merged.
		
		The lexers from the template lexer package use this base lexer.

	 func Include(state string) Rule
		Include the given state.

	 func Literator(tokens ...Token) Iterator
		Literator converts a sequence of literal Tokens into an Iterator.

	 func Marshal(l *RegexLexer) ([]byte, error)
		Marshal a RegexLexer to XML.

	 func MustNewLexer(config *Config, rules func() Rules) *RegexLexer
		MustNewLexer creates a new Lexer with deferred rules generation or panics.

	 func MustNewStyle(name string, entries StyleEntries) *Style
		MustNewStyle creates a new style or panics.

	 func MustNewXMLLexer(from fs.FS, path string) *RegexLexer
		MustNewXMLLexer constructs a new RegexLexer from an XML file or panics.

	 func MustNewXMLStyle(r io.Reader) *Style
		MustNewXMLStyle is like NewXMLStyle but panics on error.

	 func MustParseColour(colour string) Colour
		MustParseColour is like ParseColour except it panics if the colour is invalid.
		
		Will panic if colour is in an invalid format.

	 func MustParseStyleEntry(entry string) StyleEntry
		MustParseStyleEntry parses a Pygments style entry or panics.

	 func Mutators(modifiers ...Mutator) Mutator
		Mutators applies a set of Mutators in order.

	 func NewColour(r, g, b uint8) Colour
		NewColour creates a Colour directly from RGB values.

	 func NewLexer(config *Config, rulesFunc func() Rules) (*RegexLexer, error)
		NewLexer creates a new regex-based Lexer.
		
		"rules" is a state machine transition map. Each key is a state. Values are sets of rules
		that match input, optionally modify lexer state, and output tokens.

	 func NewLexerRegistry() *LexerRegistry
		NewLexerRegistry creates a new LexerRegistry of Lexers.

	 func NewStyle(name string, entries StyleEntries) (*Style, error)
		NewStyle creates a new style definition.

	 func NewStyleBuilder(name string) *StyleBuilder
	 func NewXMLLexer(from fs.FS, path string) (*RegexLexer, error)
		NewXMLLexer creates a new RegexLexer from a serialised RegexLexer.

	 func NewXMLStyle(r io.Reader) (*Style, error)
		NewXMLStyle parses an XML style definition.

	 func ParseColour(colour string) Colour
		ParseColour in the forms #rgb, #rrggbb, #ansi<colour>, or #<colour>.
		Will return an "unset" colour if invalid.

	 func ParseStyleEntry(entry string) (StyleEntry, error)
		ParseStyleEntry parses a Pygments style entry.

	 func Pop(n int) Mutator
		Pop state from the stack when rule matches.

	 func Push(states ...string) Mutator
		Push states onto the stack.

	 func RecoveringFormatter(formatter Formatter) Formatter
		RecoveringFormatter wraps a formatter with panic recovery.

	 func RemappingLexer(lexer Lexer, mapper func(Token) []Token) Lexer
		RemappingLexer remaps a token to a set of, potentially empty, tokens.

	 func SplitTokensIntoLines(tokens []Token) (out [][]Token)
		SplitTokensIntoLines splits tokens containing newlines in two.

	 func Stringify(tokens ...Token) string
		Stringify returns the raw string for a set of tokens.

	 func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, error)
		Tokenise text using lexer, returning tokens as a slice.

	 func TokenTypeString(s string) (TokenType, error)
		TokenTypeString retrieves an enum value from the enum constants string name.
		Throws an error if the param is not part of the enum.

	 func TokenTypeStrings() []string
		TokenTypeStrings returns a slice of all String values of the enum

	 func TokenTypeValues() []TokenType
		TokenTypeValues returns all values of the enum

	 func TypeRemappingLexer(lexer Lexer, mapping TypeMapping) Lexer
		TypeRemappingLexer remaps types of tokens coming from a parent Lexer.
		
		eg. Map "defvaralias" tokens of type NameVariable to NameFunction:
		
			mapping := TypeMapping{
				{NameVariable, NameFunction, []string{"defvaralias"},
			}
			lexer = TypeRemappingLexer(lexer, mapping)

	 func Unmarshal(data []byte) (*RegexLexer, error)
		Unmarshal a RegexLexer from XML.

	 func Using(lexer string) Emitter
		Using returns an Emitter that uses a given Lexer reference for parsing and emitting.
		
		The referenced lexer must be stored in the same LexerRegistry.

	 func UsingByGroup(sublexerNameGroup, codeGroup int, emitters ...Emitter) Emitter
		UsingByGroup emits tokens for the matched groups in the regex using a
		sublexer. Used when lexing code blocks where the name of a sublexer is
		contained within the block, for example on a Markdown text block or SQL
		language block.
		
		An attempt to load the sublexer will be made using the captured value from
		the text of the matched sublexerNameGroup. If a sublexer matching the
		sublexerNameGroup is available, then tokens for the matched codeGroup will
		be emitted using the sublexer. Otherwise, if no sublexer is available, then
		tokens will be emitted from the passed emitter.
		
		Example:
		
			var Markdown = internal.Register(MustNewLexer(
				&Config{
					Name:      "markdown",
					Aliases:   []string{"md", "mkd"},
					Filenames: []string{"*.md", "*.mkd", "*.markdown"},
					MimeTypes: []string{"text/x-markdown"},
				},
				Rules{
					"root": {
						{"^(```)(\\w+)(\\n)([\\w\\W]*?)(^```$)",
							UsingByGroup(
								2, 4,
								String, String, String, Text, String,
							),
							nil,
						},
					},
				},
			))
		
		See the lexers/markdown.go for the complete example.
		
		Note: panic's if the number of emitters does not equal the number of matched
		groups in the regex.

	 func UsingLexer(lexer Lexer) Emitter
		UsingLexer returns an Emitter that uses a given Lexer for parsing and emitting.
		
		This Emitter is not serialisable.

	 func UsingSelf(stateName string) Emitter
		UsingSelf is like Using, but uses the current Lexer.

	 func Words(prefix, suffix string, words ...string) string
		Words creates a regex that matches any of the given literal words.


Package-Level Variables (total 4)

	  var ANSI2RGB map[string]string
		ANSI2RGB maps ANSI colour names, as supported by Chroma, to hex RGB values.

	  var EOF Token
		EOF is returned by lexers at the end of input.

	  var ErrNotSerialisable error
		ErrNotSerialisable is returned if a lexer contains Rules that cannot be serialised.

	  var StandardTypes map[TokenType]string
Package-Level Constants (total 125)

	const Background TokenType = -1
		Default background style.

	const CodeLine TokenType = -10
		Code line wrapper style.

	const Comment TokenType = 6000
		Comments.

	const CommentHashbang TokenType = 6001
		Comments.

	const CommentMultiline TokenType = 6002
		Comments.

	const CommentPreproc TokenType = 6100
		Preprocessor "comments".

	const CommentPreprocFile TokenType = 6101
		Preprocessor "comments".

	const CommentSingle TokenType = 6003
		Comments.

	const CommentSpecial TokenType = 6004
		Comments.

	const Date TokenType = 3001
		Aliases.

	const EOFType TokenType = 0
		Used as an EOF marker / nil token

	const Error TokenType = -11
		Input that could not be tokenised.

	const Generic TokenType = 7000
		Generic tokens.

	const GenericDeleted TokenType = 7001
		Generic tokens.

	const GenericEmph TokenType = 7002
		Generic tokens.

	const GenericError TokenType = 7003
		Generic tokens.

	const GenericHeading TokenType = 7004
		Generic tokens.

	const GenericInserted TokenType = 7005
		Generic tokens.

	const GenericOutput TokenType = 7006
		Generic tokens.

	const GenericPrompt TokenType = 7007
		Generic tokens.

	const GenericStrong TokenType = 7008
		Generic tokens.

	const GenericSubheading TokenType = 7009
		Generic tokens.

	const GenericTraceback TokenType = 7010
		Generic tokens.

	const GenericUnderline TokenType = 7011
		Generic tokens.

	const Keyword TokenType = 1000
		Keywords.

	const KeywordConstant TokenType = 1001
		Keywords.

	const KeywordDeclaration TokenType = 1002
		Keywords.

	const KeywordNamespace TokenType = 1003
		Keywords.

	const KeywordPseudo TokenType = 1004
		Keywords.

	const KeywordReserved TokenType = 1005
		Keywords.

	const KeywordType TokenType = 1006
		Keywords.

	const Line TokenType = -3
		Line style.

	const LineHighlight TokenType = -6
		Line higlight style.

	const LineLink TokenType = -9
		Line number links.

	const LineNumbers TokenType = -4
		Line numbers in output.

	const LineNumbersTable TokenType = -5
		Line numbers in output when in table.

	const LineTable TokenType = -7
		Line numbers table wrapper style.

	const LineTableTD TokenType = -8
		Line numbers table TD wrapper style.

	const Literal TokenType = 3000
		Literals.

	const LiteralDate TokenType = 3001
		Literals.

	const LiteralNumber TokenType = 3200
		Literals.

	const LiteralNumberBin TokenType = 3201
		Literals.

	const LiteralNumberFloat TokenType = 3202
		Literals.

	const LiteralNumberHex TokenType = 3203
		Literals.

	const LiteralNumberInteger TokenType = 3204
		Literals.

	const LiteralNumberIntegerLong TokenType = 3205
		Literals.

	const LiteralNumberOct TokenType = 3206
		Literals.

	const LiteralOther TokenType = 3002
		Literals.

	const LiteralString TokenType = 3100
		Strings.

	const LiteralStringAffix TokenType = 3101
		Strings.

	const LiteralStringAtom TokenType = 3102
		Strings.

	const LiteralStringBacktick TokenType = 3103
		Strings.

	const LiteralStringBoolean TokenType = 3104
		Strings.

	const LiteralStringChar TokenType = 3105
		Strings.

	const LiteralStringDelimiter TokenType = 3106
		Strings.

	const LiteralStringDoc TokenType = 3107
		Strings.

	const LiteralStringDouble TokenType = 3108
		Strings.

	const LiteralStringEscape TokenType = 3109
		Strings.

	const LiteralStringHeredoc TokenType = 3110
		Strings.

	const LiteralStringInterpol TokenType = 3111
		Strings.

	const LiteralStringName TokenType = 3112
		Strings.

	const LiteralStringOther TokenType = 3113
		Strings.

	const LiteralStringRegex TokenType = 3114
		Strings.

	const LiteralStringSingle TokenType = 3115
		Strings.

	const LiteralStringSymbol TokenType = 3116
		Strings.

	const Name TokenType = 2000
		Names.

	const NameAttribute TokenType = 2001
		Names.

	const NameBuiltin TokenType = 2002
		Names.

	const NameBuiltinPseudo TokenType = 2003
		Names.

	const NameClass TokenType = 2004
		Names.

	const NameConstant TokenType = 2005
		Names.

	const NameDecorator TokenType = 2006
		Names.

	const NameEntity TokenType = 2007
		Names.

	const NameException TokenType = 2008
		Names.

	const NameFunction TokenType = 2009
		Names.

	const NameFunctionMagic TokenType = 2010
		Names.

	const NameKeyword TokenType = 2011
		Names.

	const NameLabel TokenType = 2012
		Names.

	const NameNamespace TokenType = 2013
		Names.

	const NameOperator TokenType = 2014
		Names.

	const NameOther TokenType = 2015
		Names.

	const NameProperty TokenType = 2017
		Names.

	const NamePseudo TokenType = 2016
		Names.

	const NameTag TokenType = 2018
		Names.

	const NameVariable TokenType = 2019
		Names.

	const NameVariableAnonymous TokenType = 2020
		Names.

	const NameVariableClass TokenType = 2021
		Names.

	const NameVariableGlobal TokenType = 2022
		Names.

	const NameVariableInstance TokenType = 2023
		Names.

	const NameVariableMagic TokenType = 2024
		Names.

	const No Trilean = 2
		Trilean states.

	const None TokenType = -13
		No highlighting.

	const Number TokenType = 3200
		Aliases.

	const NumberBin TokenType = 3201
		Aliases.

	const NumberFloat TokenType = 3202
		Aliases.

	const NumberHex TokenType = 3203
		Aliases.

	const NumberInteger TokenType = 3204
		Aliases.

	const NumberIntegerLong TokenType = 3205
		Aliases.

	const NumberOct TokenType = 3206
		Aliases.

	const Operator TokenType = 4000
		Operators.

	const OperatorWord TokenType = 4001
		Operators.

	const Other TokenType = -12
		Other is used by the Delegate lexer to indicate which tokens should be handled by the delegate.

	const Pass Trilean = 0
		Trilean states.

	const PreWrapper TokenType = -2
		PreWrapper style.

	const Punctuation TokenType = 5000
		Punctuation.

	const String TokenType = 3100
		Aliases.

	const StringAffix TokenType = 3101
		Aliases.

	const StringBacktick TokenType = 3103
		Aliases.

	const StringChar TokenType = 3105
		Aliases.

	const StringDelimiter TokenType = 3106
		Aliases.

	const StringDoc TokenType = 3107
		Aliases.

	const StringDouble TokenType = 3108
		Aliases.

	const StringEscape TokenType = 3109
		Aliases.

	const StringHeredoc TokenType = 3110
		Aliases.

	const StringInterpol TokenType = 3111
		Aliases.

	const StringOther TokenType = 3113
		Aliases.

	const StringRegex TokenType = 3114
		Aliases.

	const StringSingle TokenType = 3115
		Aliases.

	const StringSymbol TokenType = 3116
		Aliases.

	const Text TokenType = 8000
		Text.

	const TextPunctuation TokenType = 8003
		Text.

	const TextSymbol TokenType = 8002
		Text.

	const TextWhitespace TokenType = 8001
		Text.

	const Whitespace TokenType = 8001
		Aliases.

	const Yes Trilean = 1
		Trilean states.

The pages are generated with Golds v0.8.2. (GOOS=linux 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 @zigo_101 (reachable from the left QR code) to get the latest news of Golds.