Aliases.
const (
Whitespace = TextWhitespace
Date = LiteralDate
String = LiteralString
StringAffix = LiteralStringAffix
StringBacktick = LiteralStringBacktick
StringChar = LiteralStringChar
StringDelimiter = LiteralStringDelimiter
StringDoc = LiteralStringDoc
StringDouble = LiteralStringDouble
StringEscape = LiteralStringEscape
StringHeredoc = LiteralStringHeredoc
StringInterpol = LiteralStringInterpol
StringOther = LiteralStringOther
StringRegex = LiteralStringRegex
StringSingle = LiteralStringSingle
StringSymbol = LiteralStringSymbol
Number = LiteralNumber
NumberBin = LiteralNumberBin
NumberFloat = LiteralNumberFloat
NumberHex = LiteralNumberHex
NumberInteger = LiteralNumberInteger
NumberIntegerLong = LiteralNumberIntegerLong
NumberOct = LiteralNumberOct
)
ANSI2RGB maps ANSI colour names, as supported by Chroma, to hex RGB values.
var ANSI2RGB = map[string]string{ "#ansiblack": "000000", "#ansidarkred": "7f0000", "#ansidarkgreen": "007f00", "#ansibrown": "7f7fe0", "#ansidarkblue": "00007f", "#ansipurple": "7f007f", "#ansiteal": "007f7f", "#ansilightgray": "e5e5e5", "#ansidarkgray": "555555", "#ansired": "ff0000", "#ansigreen": "00ff00", "#ansiyellow": "ffff00", "#ansiblue": "0000ff", "#ansifuchsia": "ff00ff", "#ansiturquoise": "00ffff", "#ansiwhite": "ffffff", "#black": "000000", "#darkred": "7f0000", "#darkgreen": "007f00", "#brown": "7f7fe0", "#darkblue": "00007f", "#purple": "7f007f", "#teal": "007f7f", "#lightgray": "e5e5e5", "#darkgray": "555555", "#red": "ff0000", "#green": "00ff00", "#yellow": "ffff00", "#blue": "0000ff", "#fuchsia": "ff00ff", "#turquoise": "00ffff", "#white": "ffffff", }
Serialisation of Chroma rules to XML. The format is:
<rules>
<state name="$STATE">
<rule [pattern="$PATTERN"]>
[<$EMITTER ...>]
[<$MUTATOR ...>]
</rule>
</state>
</rules>
eg. Include("String") would become:
<rule>
<include state="String" />
</rule>
[null, null, {"kind": "include", "state": "String"}]
eg. Rule{`\d+`, Text, nil} would become:
<rule pattern="\\d+"> <token type="Text"/> </rule>
eg. Rule{`"`, String, Push("String")}
<rule pattern="\""> <token type="String" /> <push state="String" /> </rule>
eg. Rule{`(\w+)(\n)`, ByGroups(Keyword, Whitespace), nil},
<rule pattern="(\\w+)(\\n)"> <bygroups token="Keyword" token="Whitespace" /> <push state="String" /> </rule>
var (
// ErrNotSerialisable is returned if a lexer contains Rules that cannot be serialised.
ErrNotSerialisable = fmt.Errorf("not serialisable")
)
var (
StandardTypes = map[TokenType]string{
Background: "bg",
PreWrapper: "chroma",
Line: "line",
LineNumbers: "ln",
LineNumbersTable: "lnt",
LineHighlight: "hl",
LineTable: "lntable",
LineTableTD: "lntd",
LineLink: "lnlinks",
CodeLine: "cl",
Text: "",
Whitespace: "w",
Error: "err",
Other: "x",
Keyword: "k",
KeywordConstant: "kc",
KeywordDeclaration: "kd",
KeywordNamespace: "kn",
KeywordPseudo: "kp",
KeywordReserved: "kr",
KeywordType: "kt",
Name: "n",
NameAttribute: "na",
NameBuiltin: "nb",
NameBuiltinPseudo: "bp",
NameClass: "nc",
NameConstant: "no",
NameDecorator: "nd",
NameEntity: "ni",
NameException: "ne",
NameFunction: "nf",
NameFunctionMagic: "fm",
NameProperty: "py",
NameLabel: "nl",
NameNamespace: "nn",
NameOther: "nx",
NameTag: "nt",
NameVariable: "nv",
NameVariableClass: "vc",
NameVariableGlobal: "vg",
NameVariableInstance: "vi",
NameVariableMagic: "vm",
Literal: "l",
LiteralDate: "ld",
String: "s",
StringAffix: "sa",
StringBacktick: "sb",
StringChar: "sc",
StringDelimiter: "dl",
StringDoc: "sd",
StringDouble: "s2",
StringEscape: "se",
StringHeredoc: "sh",
StringInterpol: "si",
StringOther: "sx",
StringRegex: "sr",
StringSingle: "s1",
StringSymbol: "ss",
Number: "m",
NumberBin: "mb",
NumberFloat: "mf",
NumberHex: "mh",
NumberInteger: "mi",
NumberIntegerLong: "il",
NumberOct: "mo",
Operator: "o",
OperatorWord: "ow",
Punctuation: "p",
Comment: "c",
CommentHashbang: "ch",
CommentMultiline: "cm",
CommentPreproc: "cp",
CommentPreprocFile: "cpf",
CommentSingle: "c1",
CommentSpecial: "cs",
Generic: "g",
GenericDeleted: "gd",
GenericEmph: "ge",
GenericError: "gr",
GenericHeading: "gh",
GenericInserted: "gi",
GenericOutput: "go",
GenericPrompt: "gp",
GenericStrong: "gs",
GenericSubheading: "gu",
GenericTraceback: "gt",
GenericUnderline: "gl",
}
)
func Marshal(l *RegexLexer) ([]byte, error)
Marshal a RegexLexer to XML.
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 Words(prefix, suffix string, words ...string) string
Words creates a regex that matches any of the given literal words.
Analyser determines how appropriate this lexer is for the given text.
type Analyser interface {
AnalyseText(text string) float32
}
Colour represents an RGB colour.
type Colour int32
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 NewColour(r, g, b uint8) Colour
NewColour creates a Colour directly from RGB values.
func ParseColour(colour string) Colour
ParseColour in the forms #rgb, #rrggbb, #ansi<colour>, or #<colour>. Will return an "unset" colour if invalid.
func (c Colour) Blue() uint8
Blue component of colour.
func (c 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).
func (c Colour) BrightenOrDarken(factor float64) Colour
BrightenOrDarken brightens a colour if it is < 0.5 brightness or darkens if > 0.5 brightness.
func (c Colour) Brightness() float64
Brightness of the colour (roughly) in the range 0.0 to 1.0.
func (c 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.
func (c 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.
func (c Colour) GoString() string
func (c Colour) Green() uint8
Green component of colour.
func (c Colour) IsSet() bool
IsSet returns true if the colour is set.
func (c Colour) Red() uint8
Red component of colour.
func (c Colour) String() string
Colours is an orderable set of colours.
type Colours []Colour
func (c Colours) Len() int
func (c Colours) Less(i, j int) bool
func (c Colours) Swap(i, j int)
A CompiledRule is a Rule with a pre-compiled regex.
Note that regular expressions are lazily compiled on first use of the lexer.
type CompiledRule struct {
Rule
Regexp *regexp2.Regexp
// contains filtered or unexported fields
}
CompiledRules is a map of rule name to sequence of compiled rules in that rule.
type CompiledRules map[string][]*CompiledRule
Config for a lexer.
type Config struct {
// Name of the lexer.
Name string `xml:"name,omitempty"`
// Shortcuts for the lexer
Aliases []string `xml:"alias,omitempty"`
// File name globs
Filenames []string `xml:"filename,omitempty"`
// Secondary file name globs
AliasFilenames []string `xml:"alias_filename,omitempty"`
// MIME types
MimeTypes []string `xml:"mime_type,omitempty"`
// Regex matching is case-insensitive.
CaseInsensitive bool `xml:"case_insensitive,omitempty"`
// Regex matches all characters.
DotAll bool `xml:"dot_all,omitempty"`
// Regex does not match across lines ($ matches EOL).
//
// Defaults to multiline.
NotMultiline bool `xml:"not_multiline,omitempty"`
// Make sure that the input ends with a newline. This
// is required for some lexers that consume input linewise.
EnsureNL bool `xml:"ensure_nl,omitempty"`
// Priority of lexer.
//
// If this is 0 it will be treated as a default of 1.
Priority float32 `xml:"priority,omitempty"`
}
An Emitter takes group matches and returns tokens.
type Emitter interface {
// Emit tokens for the given regex groups.
Emit(groups []string, state *LexerState) Iterator
}
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 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.
EmitterFunc is a function that is an Emitter.
type EmitterFunc func(groups []string, state *LexerState) Iterator
func (e EmitterFunc) Emit(groups []string, state *LexerState) Iterator
Emit tokens for groups.
type Emitters []Emitter
func (b Emitters) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (b *Emitters) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
A Formatter for Chroma lexers.
type Formatter interface {
// Format returns a formatting function for tokens.
//
// If the iterator panics, the Formatter should recover.
Format(w io.Writer, style *Style, iterator Iterator) error
}
func RecoveringFormatter(formatter Formatter) Formatter
RecoveringFormatter wraps a formatter with panic recovery.
A FormatterFunc is a Formatter implemented as a function.
Guards against iterator panics.
type FormatterFunc func(w io.Writer, style *Style, iterator Iterator) error
func (f FormatterFunc) Format(w io.Writer, s *Style, it Iterator) (err error)
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.
type Iterator func() Token
func Concaterator(iterators ...Iterator) Iterator
Concaterator concatenates tokens from a series of iterators.
func Literator(tokens ...Token) Iterator
Literator converts a sequence of literal Tokens into an Iterator.
func (i Iterator) Tokens() []Token
Tokens consumes all tokens from the iterator and returns them as a slice.
A Lexer for tokenising source code.
type Lexer interface {
// Config describing the features of the Lexer.
Config() *Config
// Tokenise returns an Iterator over tokens in text.
Tokenise(options *TokeniseOptions, text string) (Iterator, error)
// 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.
SetRegistry(registry *LexerRegistry) 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.
SetAnalyser(analyser func(text string) float32) Lexer
// 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.
AnalyseText(text string) float32
}
func Coalesce(lexer Lexer) Lexer
Coalesce is a Lexer interceptor that collapses runs of common types into a single token.
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 RemappingLexer(lexer Lexer, mapper func(Token) []Token) Lexer
RemappingLexer remaps a token to a set of, potentially empty, tokens.
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)
A LexerMutator is an additional interface that a Mutator can implement to modify the lexer when it is compiled.
type LexerMutator interface {
// 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.
MutateLexer(rules CompiledRules, state string, rule int) error
}
LexerRegistry is a registry of Lexers.
type LexerRegistry struct {
Lexers Lexers
// contains filtered or unexported fields
}
func NewLexerRegistry() *LexerRegistry
NewLexerRegistry creates a new LexerRegistry of Lexers.
func (l *LexerRegistry) Analyse(text string) Lexer
Analyse text content and return the "best" lexer..
func (l *LexerRegistry) Get(name string) Lexer
Get a Lexer by name, alias or file extension.
func (l *LexerRegistry) Match(filename string) Lexer
Match returns the first lexer matching filename.
func (l *LexerRegistry) MatchMimeType(mimeType string) Lexer
MatchMimeType attempts to find a lexer for the given MIME type.
func (l *LexerRegistry) Names(withAliases bool) []string
Names of all lexers, optionally including aliases.
func (l *LexerRegistry) Register(lexer Lexer) Lexer
Register a Lexer with the LexerRegistry.
LexerState contains the state for a single lex.
type LexerState struct {
Lexer *RegexLexer
Registry *LexerRegistry
Text []rune
Pos int
Rules CompiledRules
Stack []string
State string
Rule int
// Group matches.
Groups []string
// Named Group matches.
NamedGroups map[string]string
// Custum context for mutators.
MutatorContext map[interface{}]interface{}
// contains filtered or unexported fields
}
func (l *LexerState) Get(key interface{}) interface{}
Get mutator context.
func (l *LexerState) Iterator() Token
Iterator returns the next Token from the lexer.
func (l *LexerState) Set(key interface{}, value interface{})
Set mutator context.
Lexers is a slice of lexers sortable by name.
type Lexers []Lexer
func (l Lexers) Len() int
func (l Lexers) Less(i, j int) bool
func (l Lexers) Swap(i, j int)
A Mutator modifies the behaviour of the lexer.
type Mutator interface {
// Mutate the lexer state machine as it is processing.
Mutate(state *LexerState) error
}
func Combined(states ...string) Mutator
Combined creates a new anonymous state from the given states, and pushes that state.
func Mutators(modifiers ...Mutator) Mutator
Mutators applies a set of Mutators in order.
func Pop(n int) Mutator
Pop state from the stack when rule matches.
func Push(states ...string) Mutator
Push states onto the stack.
A MutatorFunc is a Mutator that mutates the lexer state machine as it is processing.
type MutatorFunc func(state *LexerState) error
func (m MutatorFunc) Mutate(state *LexerState) error
PrioritisedLexers is a slice of lexers sortable by priority.
type PrioritisedLexers []Lexer
func (l PrioritisedLexers) Len() int
func (l PrioritisedLexers) Less(i, j int) bool
func (l PrioritisedLexers) Swap(i, j int)
RegexLexer is the default lexer implementation used in Chroma.
type RegexLexer struct {
// contains filtered or unexported fields
}
func MustNewLexer(config *Config, rulesFunc func() Rules) *RegexLexer
MustNewLexer creates a new Lexer with deferred rules generation or panics.
func MustNewXMLLexer(from fs.FS, path string) *RegexLexer
MustNewXMLLexer constructs a new RegexLexer from an XML file or panics.
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 NewXMLLexer(from fs.FS, path string) (*RegexLexer, error)
NewXMLLexer creates a new RegexLexer from a serialised RegexLexer.
func Unmarshal(data []byte) (*RegexLexer, error)
Unmarshal a RegexLexer from XML.
func (r *RegexLexer) AnalyseText(text string) float32
func (r *RegexLexer) Config() *Config
func (r *RegexLexer) MustRules() Rules
MustRules is like Rules() but will panic on error.
func (r *RegexLexer) Rules() (Rules, error)
Rules in the Lexer.
func (r *RegexLexer) SetAnalyser(analyser func(text string) float32) Lexer
SetAnalyser sets the analyser function used to perform content inspection.
func (r *RegexLexer) SetConfig(config *Config) *RegexLexer
SetConfig replaces the Config for this Lexer.
func (r *RegexLexer) SetRegistry(registry *LexerRegistry) Lexer
SetRegistry the lexer will use to lookup other lexers if necessary.
func (r *RegexLexer) String() string
func (r *RegexLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error)
func (r *RegexLexer) Trace(trace bool) *RegexLexer
Trace enables debug tracing.
A Rule is the fundamental matching unit of the Regex lexer state machine.
type Rule struct {
Pattern string
Type Emitter
Mutator Mutator
}
func Default(mutators ...Mutator) Rule
Default returns a Rule that applies a set of Mutators.
func Include(state string) Rule
Include the given state.
func (r Rule) MarshalXML(e *xml.Encoder, _ xml.StartElement) error
func (r *Rule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
Rules maps from state to a sequence of Rules.
type Rules map[string][]Rule
func (r Rules) Clone() Rules
Clone returns a clone of the Rules.
func (r Rules) MarshalXML(e *xml.Encoder, _ xml.StartElement) error
func (r Rules) Merge(rules Rules) Rules
Merge creates a clone of "r" then merges "rules" into the clone.
func (r Rules) Rename(oldRule, newRule string) Rules
Rename clones rules then a rule.
func (r *Rules) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
SerialisableEmitter is an Emitter that can be serialised and deserialised to/from JSON.
type SerialisableEmitter interface {
Emitter
EmitterKind() string
}
SerialisableMutator is a Mutator that can be serialised and deserialised.
type SerialisableMutator interface {
Mutator
MutatorKind() string
}
A Style definition.
See http://pygments.org/docs/styles/ for details. Semantics are intended to be identical.
type Style struct {
Name string
// contains filtered or unexported fields
}
func MustNewStyle(name string, entries StyleEntries) *Style
MustNewStyle creates a new style or panics.
func MustNewXMLStyle(r io.Reader) *Style
MustNewXMLStyle is like NewXMLStyle but panics on error.
func NewStyle(name string, entries StyleEntries) (*Style, error)
NewStyle creates a new style definition.
func NewXMLStyle(r io.Reader) (*Style, error)
NewXMLStyle parses an XML style definition.
func (s *Style) Builder() *StyleBuilder
Builder creates a mutable builder from this Style.
The builder can then be safely modified. This is a cheap operation.
func (s *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.
func (s *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.
func (s *Style) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (s *Style) Types() []TokenType
Types that are styled.
func (s *Style) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
A StyleBuilder is a mutable structure for building styles.
Once built, a Style is immutable.
type StyleBuilder struct {
// contains filtered or unexported fields
}
func NewStyleBuilder(name string) *StyleBuilder
func (s *StyleBuilder) Add(ttype TokenType, entry string) *StyleBuilder
Add an entry to the Style map.
See http://pygments.org/docs/styles/#style-rules for details.
func (s *StyleBuilder) AddAll(entries StyleEntries) *StyleBuilder
func (s *StyleBuilder) AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder
func (s *StyleBuilder) Build() (*Style, error)
func (s *StyleBuilder) Get(ttype TokenType) StyleEntry
func (s *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.
StyleEntries mapping TokenType to colour definition.
type StyleEntries map[TokenType]string
A StyleEntry in the Style map.
type StyleEntry struct {
// Hex colours.
Colour Colour
Background Colour
Border Colour
Bold Trilean
Italic Trilean
Underline Trilean
NoInherit bool
}
func MustParseStyleEntry(entry string) StyleEntry
MustParseStyleEntry parses a Pygments style entry or panics.
func ParseStyleEntry(entry string) (StyleEntry, error)
ParseStyleEntry parses a Pygments style entry.
func (s StyleEntry) Inherit(ancestors ...StyleEntry) StyleEntry
Inherit styles from ancestors.
Ancestors should be provided from oldest to newest.
func (s StyleEntry) IsZero() bool
func (s StyleEntry) MarshalText() ([]byte, error)
func (s StyleEntry) String() string
func (s StyleEntry) Sub(e StyleEntry) StyleEntry
Sub subtracts e from s where elements match.
Token output to formatter.
type Token struct {
Type TokenType `json:"type"`
Value string `json:"value"`
}
EOF is returned by lexers at the end of input.
var EOF Token
func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, error)
Tokenise text using lexer, returning tokens as a slice.
func (t *Token) Clone() Token
Clone returns a clone of the Token.
func (t *Token) GoString() string
func (t *Token) String() string
TokenType is the type of token to highlight.
It is also an Emitter, emitting a single token of itself
type TokenType int
Meta token types.
const (
// Default background style.
Background TokenType = -1 - iota
// PreWrapper style.
PreWrapper
// Line style.
Line
// Line numbers in output.
LineNumbers
// Line numbers in output when in table.
LineNumbersTable
// Line higlight style.
LineHighlight
// Line numbers table wrapper style.
LineTable
// Line numbers table TD wrapper style.
LineTableTD
// Line number links.
LineLink
// Code line wrapper style.
CodeLine
// Input that could not be tokenised.
Error
// Other is used by the Delegate lexer to indicate which tokens should be handled by the delegate.
Other
// No highlighting.
None
// Used as an EOF marker / nil token
EOFType TokenType = 0
)
Keywords.
const (
Keyword TokenType = 1000 + iota
KeywordConstant
KeywordDeclaration
KeywordNamespace
KeywordPseudo
KeywordReserved
KeywordType
)
Names.
const (
Name TokenType = 2000 + iota
NameAttribute
NameBuiltin
NameBuiltinPseudo
NameClass
NameConstant
NameDecorator
NameEntity
NameException
NameFunction
NameFunctionMagic
NameKeyword
NameLabel
NameNamespace
NameOperator
NameOther
NamePseudo
NameProperty
NameTag
NameVariable
NameVariableAnonymous
NameVariableClass
NameVariableGlobal
NameVariableInstance
NameVariableMagic
)
Literals.
const (
Literal TokenType = 3000 + iota
LiteralDate
LiteralOther
)
Strings.
const (
LiteralString TokenType = 3100 + iota
LiteralStringAffix
LiteralStringAtom
LiteralStringBacktick
LiteralStringBoolean
LiteralStringChar
LiteralStringDelimiter
LiteralStringDoc
LiteralStringDouble
LiteralStringEscape
LiteralStringHeredoc
LiteralStringInterpol
LiteralStringName
LiteralStringOther
LiteralStringRegex
LiteralStringSingle
LiteralStringSymbol
)
Literals.
const (
LiteralNumber TokenType = 3200 + iota
LiteralNumberBin
LiteralNumberFloat
LiteralNumberHex
LiteralNumberInteger
LiteralNumberIntegerLong
LiteralNumberOct
)
Operators.
const (
Operator TokenType = 4000 + iota
OperatorWord
)
Comments.
const (
Comment TokenType = 6000 + iota
CommentHashbang
CommentMultiline
CommentSingle
CommentSpecial
)
Preprocessor "comments".
const (
CommentPreproc TokenType = 6100 + iota
CommentPreprocFile
)
Generic tokens.
const (
Generic TokenType = 7000 + iota
GenericDeleted
GenericEmph
GenericError
GenericHeading
GenericInserted
GenericOutput
GenericPrompt
GenericStrong
GenericSubheading
GenericTraceback
GenericUnderline
)
Text.
const (
Text TokenType = 8000 + iota
TextWhitespace
TextSymbol
TextPunctuation
)
Punctuation.
const (
Punctuation TokenType = 5000 + iota
)
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 TokenTypeValues() []TokenType
TokenTypeValues returns all values of the enum
func (t TokenType) Category() TokenType
func (t TokenType) Emit(groups []string, _ *LexerState) Iterator
func (t TokenType) EmitterKind() string
func (t TokenType) InCategory(other TokenType) bool
func (t TokenType) InSubCategory(other TokenType) bool
func (i TokenType) IsATokenType() bool
IsATokenType returns "true" if the value is listed in the enum definition. "false" otherwise
func (i TokenType) MarshalText() ([]byte, error)
MarshalText implements the encoding.TextMarshaler interface for TokenType
func (t TokenType) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (t TokenType) Parent() TokenType
func (i TokenType) String() string
func (t TokenType) SubCategory() TokenType
func (i *TokenType) UnmarshalText(text []byte) error
UnmarshalText implements the encoding.TextUnmarshaler interface for TokenType
func (t *TokenType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
TokeniseOptions contains options for tokenisers.
type TokeniseOptions struct {
// State to start tokenisation in. Defaults to "root".
State string
// Nested tokenisation.
Nested bool
// If true, all EOLs are converted into LF
// by replacing CRLF and CR
EnsureLF bool
}
Trilean value for StyleEntry value inheritance.
type Trilean uint8
Trilean states.
const (
Pass Trilean = iota
Yes
No
)
func (t Trilean) Prefix(s string) string
Prefix returns s with "no" as a prefix if Trilean is no.
func (t Trilean) String() string
TypeMapping defines type maps for the TypeRemappingLexer.
type TypeMapping []struct {
From, To TokenType
Words []string
}