package chroma

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
)

Aliases.

Variables ¶

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",
}

ANSI2RGB maps ANSI colour names, as supported by Chroma, to hex RGB values.

var (
	// ErrNotSerialisable is returned if a lexer contains Rules that cannot be serialised.
	ErrNotSerialisable = fmt.Errorf("not serialisable")
)

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 (
	StandardTypes = map[TokenType]string{
		Background:       "bg",
		PreWrapper:       "chroma",
		Line:             "line",
		LineNumbers:      "ln",
		LineNumbersTable: "lnt",
		LineHighlight:    "hl",
		LineTable:        "lntable",
		LineTableTD:      "lntd",
		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",
	}
)

Functions ¶

func SplitTokensIntoLines ¶

func SplitTokensIntoLines(tokens []Token) (out [][]Token)

SplitTokensIntoLines splits tokens containing newlines in two.

func Stringify ¶

func Stringify(tokens ...Token) string

Stringify returns the raw string for a set of tokens.

func Words ¶

func Words(prefix, suffix string, words ...string) string

Words creates a regex that matches any of the given literal words.

Types ¶

type Analyser ¶

type Analyser interface {
	AnalyseText(text string) float32
}

Analyser determines how appropriate this lexer is for the given text.

func MustParseColour ¶

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 ¶

func NewColour(r, g, b uint8) Colour

NewColour creates a Colour directly from RGB values.

func ParseColour ¶

func ParseColour(colour string) Colour

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

func (Colour) Blue ¶

func (c Colour) Blue() uint8

Blue component of colour.

func (Colour) Brighten ¶

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 (Colour) BrightenOrDarken ¶

func (c Colour) BrightenOrDarken(factor float64) Colour

BrightenOrDarken brightens a colour if it is < 0.5 brighteness or darkens if > 0.5 brightness.

func (Colour) Brightness ¶

func (c Colour) Brightness() float64

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

func (Colour) Distance ¶

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 (Colour) GoString ¶

func (c Colour) GoString() string

func (Colour) Green ¶

func (c Colour) Green() uint8

Green component of colour.

func (Colour) IsSet ¶

func (c Colour) IsSet() bool

IsSet returns true if the colour is set.

func (Colour) Red ¶

func (c Colour) Red() uint8

Red component of colour.

func (Colour) String ¶

func (c Colour) String() string

func (Colours) Len ¶

func (c Colours) Len() int

func (Colours) Less ¶

func (c Colours) Less(i, j int) bool

func (Colours) Swap ¶

func (c Colours) Swap(i, j int)

type CompiledRule ¶

type CompiledRule struct {
	Rule
	Regexp *regexp2.Regexp
	// contains filtered or unexported fields
}

A CompiledRule is a Rule with a pre-compiled regex.

Note that regular expressions are lazily compiled on first use of the lexer.

type CompiledRules ¶

type CompiledRules map[string][]*CompiledRule

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

type Emitter ¶

type Emitter interface {
	// Emit tokens for the given regex groups.
	Emit(groups []string, state *LexerState) Iterator
}

An Emitter takes group matches and returns tokens.

func ByGroupNames ¶

func ByGroupNames(emitters map[string]Emitter) Emitter

ByGroupNames emits a token for each named matching group in the rule's regex.

func ByGroups ¶

func ByGroups(emitters ...Emitter) Emitter

ByGroups emits a token for each matching group in the rule's regex.

func Using ¶

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 ¶

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.

The sublexer will be retrieved using sublexerGetFunc (typically internal.Get), using the captured value from the matched sublexerNameGroup.

If sublexerGetFunc returns a non-nil lexer for the captured sublexerNameGroup, then tokens for the matched codeGroup will be emitted using the retrieved lexer. Otherwise, if the sublexer is nil, 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(
					internal.Get,
					2, 4,
					String, String, String, Text, String,
				),
				nil,
			},
		},
	},
))

See the lexers/m/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 ¶

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 ¶

func UsingSelf(stateName string) Emitter

UsingSelf is like Using, but uses the current Lexer.

type EmitterFunc ¶

type EmitterFunc func(groups []string, state *LexerState) Iterator

EmitterFunc is a function that is an Emitter.

func (EmitterFunc) Emit ¶

func (e EmitterFunc) Emit(groups []string, state *LexerState) Iterator

Emit tokens for groups.

type Emitters ¶

type Emitters []Emitter

func (Emitters) MarshalXML ¶

func (b Emitters) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Emitters) UnmarshalXML ¶

func (b *Emitters) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type Formatter ¶

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
}

A Formatter for Chroma lexers.

func RecoveringFormatter ¶

func RecoveringFormatter(formatter Formatter) Formatter

RecoveringFormatter wraps a formatter with panic recovery.

type FormatterFunc ¶

type FormatterFunc func(w io.Writer, style *Style, iterator Iterator) error

A FormatterFunc is a Formatter implemented as a function.

Guards against iterator panics.

func (FormatterFunc) Format ¶

func (f FormatterFunc) Format(w io.Writer, s *Style, it Iterator) (err error)

type Iterator ¶

type Iterator func() Token

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.

func Concaterator ¶

func Concaterator(iterators ...Iterator) Iterator

Concaterator concatenates tokens from a series of iterators.

func Literator ¶

func Literator(tokens ...Token) Iterator

Literator converts a sequence of literal Tokens into an Iterator.

func (Iterator) Tokens ¶

func (i Iterator) Tokens() []Token

Tokens consumes all tokens from the iterator and returns them as a slice.

type Lexer ¶

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
}

A Lexer for tokenising source code.

func Coalesce ¶

func Coalesce(lexer Lexer) Lexer

Coalesce is a Lexer interceptor that collapses runs of common types into a single token.

func DelegatingLexer ¶

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 ¶

func RemappingLexer(lexer Lexer, mapper func(Token) []Token) Lexer

RemappingLexer remaps a token to a set of, potentially empty, tokens.

func TypeRemappingLexer ¶

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)

type LexerMutator ¶

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
}

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

type LexerRegistry ¶

type LexerRegistry struct {
	Lexers Lexers
	// contains filtered or unexported fields
}

LexerRegistry is a registry of Lexers.

func NewLexerRegistry ¶

func NewLexerRegistry() *LexerRegistry

NewLexerRegistry creates a new LexerRegistry of Lexers.

func (*LexerRegistry) Analyse ¶

func (l *LexerRegistry) Analyse(text string) Lexer

Analyse text content and return the "best" lexer..

func (*LexerRegistry) Get ¶

func (l *LexerRegistry) Get(name string) Lexer

Get a Lexer by name, alias or file extension.

func (*LexerRegistry) Match ¶

func (l *LexerRegistry) Match(filename string) Lexer

Match returns the first lexer matching filename.

func (*LexerRegistry) MatchMimeType ¶

func (l *LexerRegistry) MatchMimeType(mimeType string) Lexer

MatchMimeType attempts to find a lexer for the given MIME type.

func (*LexerRegistry) Names ¶

func (l *LexerRegistry) Names(withAliases bool) []string

Names of all lexers, optionally including aliases.

func (*LexerRegistry) Register ¶

func (l *LexerRegistry) Register(lexer Lexer) Lexer

type LexerState ¶

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
}

LexerState contains the state for a single lex.

func (*LexerState) Get ¶

func (l *LexerState) Get(key interface{}) interface{}

Get mutator context.

func (*LexerState) Iterator ¶

func (l *LexerState) Iterator() Token

Iterator returns the next Token from the lexer.

func (*LexerState) Set ¶

func (l *LexerState) Set(key interface{}, value interface{})

Set mutator context.

type Lexers ¶

type Lexers []Lexer

Lexers is a slice of lexers sortable by name.

func (Lexers) Len ¶

func (l Lexers) Len() int

func (Lexers) Less ¶

func (l Lexers) Less(i, j int) bool

func (Lexers) Swap ¶

func (l Lexers) Swap(i, j int)

type Mutator ¶

type Mutator interface {
	// Mutate the lexer state machine as it is processing.
	Mutate(state *LexerState) error
}

A Mutator modifies the behaviour of the lexer.

func Combined ¶

func Combined(states ...string) Mutator

Combined creates a new anonymous state from the given states, and pushes that state.

func Mutators ¶

func Mutators(modifiers ...Mutator) Mutator

Mutators applies a set of Mutators in order.

func Pop ¶

func Pop(n int) Mutator

Pop state from the stack when rule matches.

func Push ¶

func Push(states ...string) Mutator

Push states onto the stack.

type MutatorFunc ¶

type MutatorFunc func(state *LexerState) error

A MutatorFunc is a Mutator that mutates the lexer state machine as it is processing.

func (MutatorFunc) Mutate ¶

func (m MutatorFunc) Mutate(state *LexerState) error

type PrioritisedLexers ¶

type PrioritisedLexers []Lexer

PrioritisedLexers is a slice of lexers sortable by priority.

func (PrioritisedLexers) Len ¶

func (l PrioritisedLexers) Len() int

func (PrioritisedLexers) Less ¶

func (l PrioritisedLexers) Less(i, j int) bool

func (PrioritisedLexers) Swap ¶

func (l PrioritisedLexers) Swap(i, j int)

type RegexLexer ¶

type RegexLexer struct {
	// contains filtered or unexported fields
}

RegexLexer is the default lexer implementation used in Chroma.

func MustNewLexer ¶

func MustNewLexer(config *Config, rulesFunc func() Rules) *RegexLexer

MustNewLexer creates a new Lexer with deferred rules generation or panics.

func MustNewXMLLexer ¶

func MustNewXMLLexer(from fs.FS, path string) *RegexLexer

MustNewXMLLexer constructs a new RegexLexer from an XML file or panics.

func NewLexer ¶

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 ¶

func NewXMLLexer(from fs.FS, path string) (*RegexLexer, error)

NewXMLLexer creates a new RegexLexer from a serialised RegexLexer.

func Unmarshal ¶

func Unmarshal(data []byte) (*RegexLexer, error)

Unmarshal a RegexLexer from XML.

func (*RegexLexer) AnalyseText ¶

func (r *RegexLexer) AnalyseText(text string) float32

func (*RegexLexer) Config ¶

func (r *RegexLexer) Config() *Config

func (*RegexLexer) MustRules ¶

func (r *RegexLexer) MustRules() Rules

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

func (*RegexLexer) Rules ¶

func (r *RegexLexer) Rules() (Rules, error)

Rules in the Lexer.

func (*RegexLexer) SetAnalyser ¶

func (r *RegexLexer) SetAnalyser(analyser func(text string) float32) Lexer

SetAnalyser sets the analyser function used to perform content inspection.

func (*RegexLexer) SetConfig ¶

func (r *RegexLexer) SetConfig(config *Config) *RegexLexer

SetConfig replaces the Config for this Lexer.

func (*RegexLexer) SetRegistry ¶

func (r *RegexLexer) SetRegistry(registry *LexerRegistry) Lexer

SetRegistry the lexer will use to lookup other lexers if necessary.

func (*RegexLexer) String ¶

func (r *RegexLexer) String() string

func (*RegexLexer) Tokenise ¶

func (r *RegexLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error)

func (*RegexLexer) Trace ¶

func (r *RegexLexer) Trace(trace bool) *RegexLexer

Trace enables debug tracing.

type Rule ¶

type Rule struct {
	Pattern string
	Type    Emitter
	Mutator Mutator
}

A Rule is the fundamental matching unit of the Regex lexer state machine.

func Default ¶

func Default(mutators ...Mutator) Rule

Default returns a Rule that applies a set of Mutators.

func Include ¶

func Include(state string) Rule

Include the given state.

func (Rule) MarshalXML ¶

func (r Rule) MarshalXML(e *xml.Encoder, _ xml.StartElement) error

func (*Rule) UnmarshalXML ¶

func (r *Rule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type Rules ¶

type Rules map[string][]Rule

Rules maps from state to a sequence of Rules.

func (Rules) Clone ¶

func (r Rules) Clone() Rules

Clone returns a clone of the Rules.

func (Rules) MarshalXML ¶

func (r Rules) MarshalXML(e *xml.Encoder, _ xml.StartElement) error

func (Rules) Merge ¶

func (r Rules) Merge(rules Rules) Rules

Merge creates a clone of "r" then merges "rules" into the clone.

func (Rules) Rename ¶

func (r Rules) Rename(oldRule, newRule string) Rules

Rename clones rules then a rule.

func (*Rules) UnmarshalXML ¶

func (r *Rules) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type SerialisableEmitter ¶

type SerialisableEmitter interface {
	Emitter
	EmitterKind() string
}

SerialisableEmitter is an Emitter that can be serialised and deserialised to/from JSON.

type SerialisableMutator ¶

type SerialisableMutator interface {
	Mutator
	MutatorKind() string
}

SerialisableMutator is a Mutator that can be serialised and deserialised.

type Style ¶

type Style struct {
	Name string
	// contains filtered or unexported fields
}

A Style definition.

See http://pygments.org/docs/styles/ for details. Semantics are intended to be identical.

func MustNewStyle ¶

func MustNewStyle(name string, entries StyleEntries) *Style

MustNewStyle creates a new style or panics.

func NewStyle ¶

func NewStyle(name string, entries StyleEntries) (*Style, error)

NewStyle creates a new style definition.

func (*Style) Builder ¶

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 (*Style) Get ¶

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 (*Style) Has ¶

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 (*Style) Types ¶

func (s *Style) Types() []TokenType

Types that are styled.

type StyleBuilder ¶

type StyleBuilder struct {
	// contains filtered or unexported fields
}

A StyleBuilder is a mutable structure for building styles.

Once built, a Style is immutable.

func NewStyleBuilder ¶

func NewStyleBuilder(name string) *StyleBuilder

func (*StyleBuilder) Add ¶

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 (*StyleBuilder) AddAll ¶

func (s *StyleBuilder) AddAll(entries StyleEntries) *StyleBuilder

func (*StyleBuilder) AddEntry ¶

func (s *StyleBuilder) AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder

func (*StyleBuilder) Build ¶

func (s *StyleBuilder) Build() (*Style, error)

func (*StyleBuilder) Get ¶

func (s *StyleBuilder) Get(ttype TokenType) StyleEntry

type StyleEntries ¶

type StyleEntries map[TokenType]string

StyleEntries mapping TokenType to colour definition.

type StyleEntry ¶

type StyleEntry struct {
	// Hex colours.
	Colour     Colour
	Background Colour
	Border     Colour

	Bold      Trilean
	Italic    Trilean
	Underline Trilean
	NoInherit bool
}

A StyleEntry in the Style map.

func ParseStyleEntry ¶

func ParseStyleEntry(entry string) (StyleEntry, error)

ParseStyleEntry parses a Pygments style entry.

func (StyleEntry) Inherit ¶

func (s StyleEntry) Inherit(ancestors ...StyleEntry) StyleEntry

Inherit styles from ancestors.

Ancestors should be provided from oldest to newest.

func (StyleEntry) IsZero ¶

func (s StyleEntry) IsZero() bool

func (StyleEntry) String ¶

func (s StyleEntry) String() string

func (StyleEntry) Sub ¶

func (s StyleEntry) Sub(e StyleEntry) StyleEntry

Sub subtracts e from s where elements match.

type Token ¶

type Token struct {
	Type  TokenType `json:"type"`
	Value string    `json:"value"`
}

Token output to formatter.

var EOF Token

EOF is returned by lexers at the end of input.

func Tokenise ¶

func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, error)

Tokenise text using lexer, returning tokens as a slice.

func (*Token) Clone ¶

func (t *Token) Clone() Token

Clone returns a clone of the Token.

func (*Token) GoString ¶

func (t *Token) GoString() string

func (*Token) String ¶

func (t *Token) String() string

type TokenType ¶

type TokenType int

TokenType is the type of token to highlight.

It is also an Emitter, emitting a single token of itself

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
	// 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
)

Meta token types.

const (
	Keyword TokenType = 1000 + iota
	KeywordConstant
	KeywordDeclaration
	KeywordNamespace
	KeywordPseudo
	KeywordReserved
	KeywordType
)

Keywords.

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
)

Names.

const (
	Literal TokenType = 3000 + iota
	LiteralDate
	LiteralOther
)

Literals.

const (
	LiteralString TokenType = 3100 + iota
	LiteralStringAffix
	LiteralStringAtom
	LiteralStringBacktick
	LiteralStringBoolean
	LiteralStringChar
	LiteralStringDelimiter
	LiteralStringDoc
	LiteralStringDouble
	LiteralStringEscape
	LiteralStringHeredoc
	LiteralStringInterpol
	LiteralStringName
	LiteralStringOther
	LiteralStringRegex
	LiteralStringSingle
	LiteralStringSymbol
)

Strings.

const (
	LiteralNumber TokenType = 3200 + iota
	LiteralNumberBin
	LiteralNumberFloat
	LiteralNumberHex
	LiteralNumberInteger
	LiteralNumberIntegerLong
	LiteralNumberOct
)

Literals.

const (
	Operator TokenType = 4000 + iota
	OperatorWord
)

Operators.

const (
	Comment TokenType = 6000 + iota
	CommentHashbang
	CommentMultiline
	CommentSingle
	CommentSpecial
)

Comments.

const (
	CommentPreproc TokenType = 6100 + iota
	CommentPreprocFile
)

Preprocessor "comments".

const (
	Generic TokenType = 7000 + iota
	GenericDeleted
	GenericEmph
	GenericError
	GenericHeading
	GenericInserted
	GenericOutput
	GenericPrompt
	GenericStrong
	GenericSubheading
	GenericTraceback
	GenericUnderline
)

Generic tokens.

const (
	Text TokenType = 8000 + iota
	TextWhitespace
	TextSymbol
	TextPunctuation
)

Text.

const (
	Punctuation TokenType = 5000 + iota
)

Punctuation.

func (TokenType) Category ¶

func (t TokenType) Category() TokenType

func (TokenType) Emit ¶

func (t TokenType) Emit(groups []string, _ *LexerState) Iterator

func (TokenType) EmitterKind ¶

func (t TokenType) EmitterKind() string

func (TokenType) InCategory ¶

func (t TokenType) InCategory(other TokenType) bool

func (TokenType) InSubCategory ¶

func (t TokenType) InSubCategory(other TokenType) bool

func (TokenType) MarshalText ¶

func (t TokenType) MarshalText() ([]byte, error)

func (TokenType) MarshalXML ¶

func (t TokenType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (TokenType) Parent ¶

func (t TokenType) Parent() TokenType

func (TokenType) String ¶

func (i TokenType) String() string

func (TokenType) SubCategory ¶

func (t TokenType) SubCategory() TokenType

func (*TokenType) UnmarshalText ¶

func (t *TokenType) UnmarshalText(data []byte) error

func (*TokenType) UnmarshalXML ¶

func (t *TokenType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type TokeniseOptions ¶

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
}

TokeniseOptions contains options for tokenisers.

type Trilean ¶

type Trilean uint8

Trilean value for StyleEntry value inheritance.

const (
	Pass Trilean = iota
	Yes
	No
)

Trilean states.

func (Trilean) Prefix ¶

func (t Trilean) Prefix(s string) string

Prefix returns s with "no" as a prefix if Trilean is no.

func (Trilean) String ¶

func (t Trilean) String() string

type TypeMapping ¶

type TypeMapping []struct {
	From, To TokenType
	Words    []string
}

TypeMapping defines type maps for the TypeRemappingLexer.

Source Files ¶

coalesce.go colour.go delegate.go doc.go emitters.go formatter.go iterator.go lexer.go mutators.go regexp.go registry.go remap.go serialise.go style.go tokentype_string.go types.go

Directories ¶

Path	Synopsis
formatters
formatters/html
formatters/svg	Package svg contains an SVG formatter.
lexers
quick	Package quick provides simple, no-configuration source code highlighting.
styles
_tools
_tools/css2style
_tools/exercise

Version: v2.0.0-alpha1
Published: Jan 27, 2022
Platform: windows/amd64
Imports: 19 packages
Last checked: 32 minutes ago –

Tools for package owners.

?	: This menu
/	: Search site
f	: Jump to identifier
g then g	: Go to top of page
g then b	: Go to end of page
G	: Go to end of page
g then i	: Go to index
g then e	: Go to examples