theme

type Generic struct {
	Scopes       []scope
	Wrapped      []wrapped
	StaticWords  map[string]theme.LanguageConstruct
	DynamicWords []word
	Custom       []func([]rune, int) (_ theme.LanguageConstruct, end int)
}

type GenericParser interface {
	input.Hook

	// SetParsingRules requests that this GenericParser apply its parsing rules
	// to the Themer (passed in as an input.Operation). The Parser can add rules
	// like so:
	//
	//     type Themer interface {
	//         WithIdent()
	//     }
	//     func SetParsingRules(ctx context.Context, op input.Operation) error {
	//         th
	//     }
	SetParsingRules(context.Context, input.Operation) error
}

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

type Highlighter interface {
	input.Operation
	CurrentHighlights(context.Context, input.Binder) (int, []ui.Span)
	UpdateHighlights(context.Context, input.Binder, int, []ui.Span) bool
	HighlightSyntax(context.Context, ...ui.Span) <-chan input.Operation
}

type Parser interface {
	input.Hook

	// Lex is called with the text of the document and the position of the next
	// rune that needs to be lexed. It returns an enum constant representing its
	// own internal tokens, the start and end indexes of that token, and any
	// error it encountered.
	//
	// The Themer expects Lex to skip any text that it does not want to pass to
	// Parse, so for example a Parser that only cares about `!=` should skip any
	// text that is not `!=`.
	//
	// If Lex returns an error, then no syntax highlighting will be performed -
	// the last successful highlights will remain in place.
	Lex(_ context.Context, text []rune, pos int) (tok int, start, end int, _ error)

	// Parse is called with the list of tokens from Lex and the index and text
	// of the unparsed token. It returns the theme.LanguageConstruct for syntax
	// highlighting purposes, the text to display for that token (usually just
	// nextTokText, although Parsers may return unicode symbols here), and any
	// error encountered.
	//
	// If Parse returns an error, then no syntax highlighting will be performed
	// - the last successful highlights will remain in place.
	//
	// Note that it's possible for multiple Parser types to be run on the same
	// text, and later Parse calls will override earlier Parse calls unless the
	// returned theme.LanguageConstruct is theme.None.
	//
	// This means that it's possible to implement a Parser that only cares about
	// translating `!=` into `≠`, returning theme.None to avoid overriding
	// highlights.
	Parse(_ context.Context, tokens []int, nextTokIdx int, nextTokText []rune) (theme.LanguageConstruct, []rune, error)
}

type SpanApplier interface {
	input.Operation
	WithSpans(...ui.Span) input.Operation
}

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