1 files changed, 0 insertions, 344 deletions
diff --git a/vendor/github.com/alecthomas/chroma/style.go b/vendor/github.com/alecthomas/chroma/style.go
deleted file mode 100644
index 1319fc4248..0000000000
--- a/vendor/github.com/alecthomas/chroma/style.go
+++ /dev/null
@@ -1,344 +0,0 @@
-package chroma
-
-import (
-	"fmt"
-	"strings"
-)
-
-// Trilean value for StyleEntry value inheritance.
-type Trilean uint8
-
-// Trilean states.
-const (
-	Pass Trilean = iota
-	Yes
-	No
-)
-
-func (t Trilean) String() string {
-	switch t {
-	case Yes:
-		return "Yes"
-	case No:
-		return "No"
-	default:
-		return "Pass"
-	}
-}
-
-// Prefix returns s with "no" as a prefix if Trilean is no.
-func (t Trilean) Prefix(s string) string {
-	if t == Yes {
-		return s
-	} else if t == No {
-		return "no" + s
-	}
-	return ""
-}
-
-// 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 (s StyleEntry) String() string {
-	out := []string{}
-	if s.Bold != Pass {
-		out = append(out, s.Bold.Prefix("bold"))
-	}
-	if s.Italic != Pass {
-		out = append(out, s.Italic.Prefix("italic"))
-	}
-	if s.Underline != Pass {
-		out = append(out, s.Underline.Prefix("underline"))
-	}
-	if s.NoInherit {
-		out = append(out, "noinherit")
-	}
-	if s.Colour.IsSet() {
-		out = append(out, s.Colour.String())
-	}
-	if s.Background.IsSet() {
-		out = append(out, "bg:"+s.Background.String())
-	}
-	if s.Border.IsSet() {
-		out = append(out, "border:"+s.Border.String())
-	}
-	return strings.Join(out, " ")
-}
-
-// Sub subtracts e from s where elements match.
-func (s StyleEntry) Sub(e StyleEntry) StyleEntry {
-	out := StyleEntry{}
-	if e.Colour != s.Colour {
-		out.Colour = s.Colour
-	}
-	if e.Background != s.Background {
-		out.Background = s.Background
-	}
-	if e.Bold != s.Bold {
-		out.Bold = s.Bold
-	}
-	if e.Italic != s.Italic {
-		out.Italic = s.Italic
-	}
-	if e.Underline != s.Underline {
-		out.Underline = s.Underline
-	}
-	if e.Border != s.Border {
-		out.Border = s.Border
-	}
-	return out
-}
-
-// Inherit styles from ancestors.
-//
-// Ancestors should be provided from oldest to newest.
-func (s StyleEntry) Inherit(ancestors ...StyleEntry) StyleEntry {
-	out := s
-	for i := len(ancestors) - 1; i >= 0; i-- {
-		if out.NoInherit {
-			return out
-		}
-		ancestor := ancestors[i]
-		if !out.Colour.IsSet() {
-			out.Colour = ancestor.Colour
-		}
-		if !out.Background.IsSet() {
-			out.Background = ancestor.Background
-		}
-		if !out.Border.IsSet() {
-			out.Border = ancestor.Border
-		}
-		if out.Bold == Pass {
-			out.Bold = ancestor.Bold
-		}
-		if out.Italic == Pass {
-			out.Italic = ancestor.Italic
-		}
-		if out.Underline == Pass {
-			out.Underline = ancestor.Underline
-		}
-	}
-	return out
-}
-
-func (s StyleEntry) IsZero() bool {
-	return s.Colour == 0 && s.Background == 0 && s.Border == 0 && s.Bold == Pass && s.Italic == Pass &&
-		s.Underline == Pass && !s.NoInherit
-}
-
-// A StyleBuilder is a mutable structure for building styles.
-//
-// Once built, a Style is immutable.
-type StyleBuilder struct {
-	entries map[TokenType]string
-	name    string
-	parent  *Style
-}
-
-func NewStyleBuilder(name string) *StyleBuilder {
-	return &StyleBuilder{name: name, entries: map[TokenType]string{}}
-}
-
-func (s *StyleBuilder) AddAll(entries StyleEntries) *StyleBuilder {
-	for ttype, entry := range entries {
-		s.entries[ttype] = entry
-	}
-	return s
-}
-
-func (s *StyleBuilder) Get(ttype TokenType) StyleEntry {
-	// This is less than ideal, but it's the price for having to check errors on each Add().
-	entry, _ := ParseStyleEntry(s.entries[ttype])
-	return entry.Inherit(s.parent.Get(ttype))
-}
-
-// Add an entry to the Style map.
-//
-// See http://pygments.org/docs/styles/#style-rules for details.
-func (s *StyleBuilder) Add(ttype TokenType, entry string) *StyleBuilder { // nolint: gocyclo
-	s.entries[ttype] = entry
-	return s
-}
-
-func (s *StyleBuilder) AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder {
-	s.entries[ttype] = entry.String()
-	return s
-}
-
-func (s *StyleBuilder) Build() (*Style, error) {
-	style := &Style{
-		Name:    s.name,
-		entries: map[TokenType]StyleEntry{},
-		parent:  s.parent,
-	}
-	for ttype, descriptor := range s.entries {
-		entry, err := ParseStyleEntry(descriptor)
-		if err != nil {
-			return nil, fmt.Errorf("invalid entry for %s: %s", ttype, err)
-		}
-		style.entries[ttype] = entry
-	}
-	return style, nil
-}
-
-// StyleEntries mapping TokenType to colour definition.
-type StyleEntries map[TokenType]string
-
-// NewStyle creates a new style definition.
-func NewStyle(name string, entries StyleEntries) (*Style, error) {
-	return NewStyleBuilder(name).AddAll(entries).Build()
-}
-
-// MustNewStyle creates a new style or panics.
-func MustNewStyle(name string, entries StyleEntries) *Style {
-	style, err := NewStyle(name, entries)
-	if err != nil {
-		panic(err)
-	}
-	return style
-}
-
-// A Style definition.
-//
-// See http://pygments.org/docs/styles/ for details. Semantics are intended to be identical.
-type Style struct {
-	Name    string
-	entries map[TokenType]StyleEntry
-	parent  *Style
-}
-
-// Types that are styled.
-func (s *Style) Types() []TokenType {
-	dedupe := map[TokenType]bool{}
-	for tt := range s.entries {
-		dedupe[tt] = true
-	}
-	if s.parent != nil {
-		for _, tt := range s.parent.Types() {
-			dedupe[tt] = true
-		}
-	}
-	out := make([]TokenType, 0, len(dedupe))
-	for tt := range dedupe {
-		out = append(out, tt)
-	}
-	return out
-}
-
-// Builder creates a mutable builder from this Style.
-//
-// The builder can then be safely modified. This is a cheap operation.
-func (s *Style) Builder() *StyleBuilder {
-	return &StyleBuilder{
-		name:    s.Name,
-		entries: map[TokenType]string{},
-		parent:  s,
-	}
-}
-
-// 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) Has(ttype TokenType) bool {
-	return !s.get(ttype).IsZero() || s.synthesisable(ttype)
-}
-
-// 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) Get(ttype TokenType) StyleEntry {
-	return s.get(ttype).Inherit(
-		s.get(Background),
-		s.get(Text),
-		s.get(ttype.Category()),
-		s.get(ttype.SubCategory()))
-}
-
-func (s *Style) get(ttype TokenType) StyleEntry {
-	out := s.entries[ttype]
-	if out.IsZero() && s.parent != nil {
-		return s.parent.get(ttype)
-	}
-	if out.IsZero() && s.synthesisable(ttype) {
-		out = s.synthesise(ttype)
-	}
-	return out
-}
-
-func (s *Style) synthesise(ttype TokenType) StyleEntry {
-	bg := s.get(Background)
-	text := StyleEntry{Colour: bg.Colour}
-	text.Colour = text.Colour.BrightenOrDarken(0.5)
-
-	switch ttype {
-	// If we don't have a line highlight colour, make one that is 10% brighter/darker than the background.
-	case LineHighlight:
-		return StyleEntry{Background: bg.Background.BrightenOrDarken(0.1)}
-
-	// If we don't have line numbers, use the text colour but 20% brighter/darker
-	case LineNumbers, LineNumbersTable:
-		return text
-
-	default:
-		return StyleEntry{}
-	}
-}
-
-func (s *Style) synthesisable(ttype TokenType) bool {
-	return ttype == LineHighlight || ttype == LineNumbers || ttype == LineNumbersTable
-}
-
-// ParseStyleEntry parses a Pygments style entry.
-func ParseStyleEntry(entry string) (StyleEntry, error) { // nolint: gocyclo
-	out := StyleEntry{}
-	parts := strings.Fields(entry)
-	for _, part := range parts {
-		switch {
-		case part == "italic":
-			out.Italic = Yes
-		case part == "noitalic":
-			out.Italic = No
-		case part == "bold":
-			out.Bold = Yes
-		case part == "nobold":
-			out.Bold = No
-		case part == "underline":
-			out.Underline = Yes
-		case part == "nounderline":
-			out.Underline = No
-		case part == "inherit":
-			out.NoInherit = false
-		case part == "noinherit":
-			out.NoInherit = true
-		case part == "bg:":
-			out.Background = 0
-		case strings.HasPrefix(part, "bg:#"):
-			out.Background = ParseColour(part[3:])
-			if !out.Background.IsSet() {
-				return StyleEntry{}, fmt.Errorf("invalid background colour %q", part)
-			}
-		case strings.HasPrefix(part, "border:#"):
-			out.Border = ParseColour(part[7:])
-			if !out.Border.IsSet() {
-				return StyleEntry{}, fmt.Errorf("invalid border colour %q", part)
-			}
-		case strings.HasPrefix(part, "#"):
-			out.Colour = ParseColour(part)
-			if !out.Colour.IsSet() {
-				return StyleEntry{}, fmt.Errorf("invalid colour %q", part)
-			}
-		default:
-			return StyleEntry{}, fmt.Errorf("unknown style element %q", part)
-		}
-	}
-	return out, nil
-}