Forgotten vendored packages and README update.
This commit is contained in:
parent
398aea2697
commit
6150e3c1fd
26
README.md
26
README.md
|
|
@ -36,6 +36,32 @@ Configuration file position is irrelevant, there is no hardcoded paths where
|
|||
Fast Paste Bin looking for it's configuration. Use ``-config`` CLI parameter
|
||||
or ``FASTPASTEBIN_CONFIG`` environment variable to specify path.
|
||||
|
||||
# Developing
|
||||
|
||||
Developers should install https://github.com/UnnoTed/fileb0x/ which is used
|
||||
as replacement to go-bindata for embedding assets into binary. After changing
|
||||
assets they should be recompiled into Go code. At repository root execute
|
||||
this command and you'll be fine:
|
||||
|
||||
```
|
||||
fileb0x fileb0x.yml
|
||||
```
|
||||
|
||||
Also if you're changed list of assets (by creating or deleting them) be sure
|
||||
to fix files list if ``fileb0x.yml`` file!
|
||||
|
||||
The rest is default - use linters, formatters, etc. VSCode with Go plugin is
|
||||
recommended for developing as it will perform most of linting-formatting
|
||||
actions automagically. Try to follow https://github.com/golang/go/wiki/CodeReviewComments
|
||||
with few exceptions:
|
||||
|
||||
* Imports should be organized in 3 groups: stdlib, local, other. See
|
||||
https://github.com/pztrn/fastpastebin/blob/master/pastes/api_http.go for
|
||||
example.
|
||||
|
||||
* We're not forcing any limits on line length for code, only for comments,
|
||||
they should be 72-76 chars long.
|
||||
|
||||
# ToDo
|
||||
|
||||
This is a ToDo list which isn't sorted by any parameter at all. Just a list
|
||||
|
|
|
|||
|
|
@ -0,0 +1,55 @@
|
|||
package formatters
|
||||
|
||||
import (
|
||||
"io"
|
||||
"sort"
|
||||
|
||||
"github.com/alecthomas/chroma"
|
||||
"github.com/alecthomas/chroma/formatters/html"
|
||||
)
|
||||
|
||||
var (
|
||||
// NoOp formatter.
|
||||
NoOp = Register("noop", chroma.FormatterFunc(func(w io.Writer, s *chroma.Style, iterator chroma.Iterator) error {
|
||||
for t := iterator(); t != nil; t = iterator() {
|
||||
if _, err := io.WriteString(w, t.Value); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}))
|
||||
// Default HTML formatter outputs self-contained HTML.
|
||||
htmlFull = Register("html", html.New(html.Standalone(), html.WithClasses()))
|
||||
)
|
||||
|
||||
// Fallback formatter.
|
||||
var Fallback = NoOp
|
||||
|
||||
// Registry of Formatters.
|
||||
var Registry = map[string]chroma.Formatter{}
|
||||
|
||||
// Names of registered formatters.
|
||||
func Names() []string {
|
||||
out := []string{}
|
||||
for name := range Registry {
|
||||
out = append(out, name)
|
||||
}
|
||||
sort.Strings(out)
|
||||
return out
|
||||
}
|
||||
|
||||
// Get formatter by name.
|
||||
//
|
||||
// If the given formatter is not found, the Fallback formatter will be returned.
|
||||
func Get(name string) chroma.Formatter {
|
||||
if f, ok := Registry[name]; ok {
|
||||
return f
|
||||
}
|
||||
return Fallback
|
||||
}
|
||||
|
||||
// Register a named formatter.
|
||||
func Register(name string, formatter chroma.Formatter) chroma.Formatter {
|
||||
Registry[name] = formatter
|
||||
return formatter
|
||||
}
|
||||
|
|
@ -0,0 +1,399 @@
|
|||
package html
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"html"
|
||||
"io"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Option sets an option of the HTML formatter.
|
||||
type Option func(f *Formatter)
|
||||
|
||||
// Standalone configures the HTML formatter for generating a standalone HTML document.
|
||||
func Standalone() Option { return func(f *Formatter) { f.standalone = true } }
|
||||
|
||||
// ClassPrefix sets the CSS class prefix.
|
||||
func ClassPrefix(prefix string) Option { return func(f *Formatter) { f.prefix = prefix } }
|
||||
|
||||
// WithClasses emits HTML using CSS classes, rather than inline styles.
|
||||
func WithClasses() Option { return func(f *Formatter) { f.Classes = true } }
|
||||
|
||||
// TabWidth sets the number of characters for a tab. Defaults to 8.
|
||||
func TabWidth(width int) Option { return func(f *Formatter) { f.tabWidth = width } }
|
||||
|
||||
// WithLineNumbers formats output with line numbers.
|
||||
func WithLineNumbers() Option {
|
||||
return func(f *Formatter) {
|
||||
f.lineNumbers = true
|
||||
}
|
||||
}
|
||||
|
||||
// LineNumbersInTable will, when combined with WithLineNumbers, separate the line numbers
|
||||
// and code in table td's, which make them copy-and-paste friendly.
|
||||
func LineNumbersInTable() Option {
|
||||
return func(f *Formatter) {
|
||||
f.lineNumbersInTable = true
|
||||
}
|
||||
}
|
||||
|
||||
// HighlightLines higlights the given line ranges with the Highlight style.
|
||||
//
|
||||
// A range is the beginning and ending of a range as 1-based line numbers, inclusive.
|
||||
func HighlightLines(ranges [][2]int) Option {
|
||||
return func(f *Formatter) {
|
||||
f.highlightRanges = ranges
|
||||
sort.Sort(f.highlightRanges)
|
||||
}
|
||||
}
|
||||
|
||||
// BaseLineNumber sets the initial number to start line numbering at. Defaults to 1.
|
||||
func BaseLineNumber(n int) Option {
|
||||
return func(f *Formatter) {
|
||||
f.baseLineNumber = n
|
||||
}
|
||||
}
|
||||
|
||||
// New HTML formatter.
|
||||
func New(options ...Option) *Formatter {
|
||||
f := &Formatter{
|
||||
baseLineNumber: 1,
|
||||
}
|
||||
for _, option := range options {
|
||||
option(f)
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
// Formatter that generates HTML.
|
||||
type Formatter struct {
|
||||
standalone bool
|
||||
prefix string
|
||||
Classes bool // Exported field to detect when classes are being used
|
||||
tabWidth int
|
||||
lineNumbers bool
|
||||
lineNumbersInTable bool
|
||||
highlightRanges highlightRanges
|
||||
baseLineNumber int
|
||||
}
|
||||
|
||||
type highlightRanges [][2]int
|
||||
|
||||
func (h highlightRanges) Len() int { return len(h) }
|
||||
func (h highlightRanges) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
|
||||
func (h highlightRanges) Less(i, j int) bool { return h[i][0] < h[j][0] }
|
||||
|
||||
func (f *Formatter) Format(w io.Writer, style *chroma.Style, iterator chroma.Iterator) (err error) {
|
||||
defer func() {
|
||||
if perr := recover(); perr != nil {
|
||||
err = perr.(error)
|
||||
}
|
||||
}()
|
||||
return f.writeHTML(w, style, iterator.Tokens())
|
||||
}
|
||||
|
||||
func brightenOrDarken(colour chroma.Colour, factor float64) chroma.Colour {
|
||||
if colour.Brightness() < 0.5 {
|
||||
return colour.Brighten(factor)
|
||||
}
|
||||
return colour.Brighten(-factor)
|
||||
}
|
||||
|
||||
// Ensure that style entries exist for highlighting, etc.
|
||||
func (f *Formatter) restyle(style *chroma.Style) (*chroma.Style, error) {
|
||||
builder := style.Builder()
|
||||
bg := builder.Get(chroma.Background)
|
||||
// If we don't have a line highlight colour, make one that is 10% brighter/darker than the background.
|
||||
if !style.Has(chroma.LineHighlight) {
|
||||
highlight := chroma.StyleEntry{Background: bg.Background}
|
||||
highlight.Background = brightenOrDarken(highlight.Background, 0.1)
|
||||
builder.AddEntry(chroma.LineHighlight, highlight)
|
||||
}
|
||||
// If we don't have line numbers, use the text colour but 20% brighter/darker
|
||||
if !style.Has(chroma.LineNumbers) {
|
||||
text := chroma.StyleEntry{Colour: bg.Colour}
|
||||
text.Colour = brightenOrDarken(text.Colour, 0.5)
|
||||
builder.AddEntry(chroma.LineNumbers, text)
|
||||
builder.AddEntry(chroma.LineNumbersTable, text)
|
||||
}
|
||||
return builder.Build()
|
||||
}
|
||||
|
||||
// We deliberately don't use html/template here because it is two orders of magnitude slower (benchmarked).
|
||||
//
|
||||
// OTOH we need to be super careful about correct escaping...
|
||||
func (f *Formatter) writeHTML(w io.Writer, style *chroma.Style, tokens []*chroma.Token) (err error) { // nolint: gocyclo
|
||||
style, err = f.restyle(style)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
css := f.styleToCSS(style)
|
||||
if !f.Classes {
|
||||
for t, style := range css {
|
||||
css[t] = compressStyle(style)
|
||||
}
|
||||
}
|
||||
if f.standalone {
|
||||
fmt.Fprint(w, "<html>\n")
|
||||
if f.Classes {
|
||||
fmt.Fprint(w, "<style type=\"text/css\">\n")
|
||||
f.WriteCSS(w, style)
|
||||
fmt.Fprintf(w, "body { %s; }\n", css[chroma.Background])
|
||||
fmt.Fprint(w, "</style>")
|
||||
}
|
||||
fmt.Fprintf(w, "<body%s>\n", f.styleAttr(css, chroma.Background))
|
||||
}
|
||||
|
||||
wrapInTable := f.lineNumbers && f.lineNumbersInTable
|
||||
|
||||
lines := splitTokensIntoLines(tokens)
|
||||
lineDigits := len(fmt.Sprintf("%d", len(lines)))
|
||||
highlightIndex := 0
|
||||
|
||||
if wrapInTable {
|
||||
// List line numbers in its own <td>
|
||||
fmt.Fprintf(w, "<div%s>\n", f.styleAttr(css, chroma.Background))
|
||||
fmt.Fprintf(w, "<table%s><tr>", f.styleAttr(css, chroma.LineTable))
|
||||
fmt.Fprintf(w, "<td%s>\n", f.styleAttr(css, chroma.LineTableTD))
|
||||
fmt.Fprintf(w, "<pre%s>", f.styleAttr(css, chroma.Background))
|
||||
for index := range lines {
|
||||
line := f.baseLineNumber + index
|
||||
highlight, next := f.shouldHighlight(highlightIndex, line)
|
||||
if next {
|
||||
highlightIndex++
|
||||
}
|
||||
if highlight {
|
||||
fmt.Fprintf(w, "<span%s>", f.styleAttr(css, chroma.LineHighlight))
|
||||
}
|
||||
|
||||
fmt.Fprintf(w, "<span%s>%*d\n</span>", f.styleAttr(css, chroma.LineNumbersTable), lineDigits, line)
|
||||
|
||||
if highlight {
|
||||
fmt.Fprintf(w, "</span>")
|
||||
}
|
||||
}
|
||||
fmt.Fprint(w, "</pre></td>\n")
|
||||
fmt.Fprintf(w, "<td%s>\n", f.styleAttr(css, chroma.LineTableTD))
|
||||
}
|
||||
|
||||
fmt.Fprintf(w, "<pre%s>", f.styleAttr(css, chroma.Background))
|
||||
highlightIndex = 0
|
||||
for index, tokens := range lines {
|
||||
// 1-based line number.
|
||||
line := f.baseLineNumber + index
|
||||
highlight, next := f.shouldHighlight(highlightIndex, line)
|
||||
if next {
|
||||
highlightIndex++
|
||||
}
|
||||
if highlight {
|
||||
fmt.Fprintf(w, "<span%s>", f.styleAttr(css, chroma.LineHighlight))
|
||||
}
|
||||
|
||||
if f.lineNumbers && !wrapInTable {
|
||||
fmt.Fprintf(w, "<span%s>%*d</span>", f.styleAttr(css, chroma.LineNumbers), lineDigits, line)
|
||||
}
|
||||
|
||||
for _, token := range tokens {
|
||||
html := html.EscapeString(token.String())
|
||||
attr := f.styleAttr(css, token.Type)
|
||||
if attr != "" {
|
||||
html = fmt.Sprintf("<span%s>%s</span>", attr, html)
|
||||
}
|
||||
fmt.Fprint(w, html)
|
||||
}
|
||||
if highlight {
|
||||
fmt.Fprintf(w, "</span>")
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Fprint(w, "</pre>")
|
||||
|
||||
if wrapInTable {
|
||||
fmt.Fprint(w, "</td></tr></table>\n")
|
||||
fmt.Fprint(w, "</div>\n")
|
||||
}
|
||||
|
||||
if f.standalone {
|
||||
fmt.Fprint(w, "\n</body>\n")
|
||||
fmt.Fprint(w, "</html>\n")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *Formatter) shouldHighlight(highlightIndex, line int) (bool, bool) {
|
||||
next := false
|
||||
for highlightIndex < len(f.highlightRanges) && line > f.highlightRanges[highlightIndex][1] {
|
||||
highlightIndex++
|
||||
next = true
|
||||
}
|
||||
if highlightIndex < len(f.highlightRanges) {
|
||||
hrange := f.highlightRanges[highlightIndex]
|
||||
if line >= hrange[0] && line <= hrange[1] {
|
||||
return true, next
|
||||
}
|
||||
}
|
||||
return false, next
|
||||
}
|
||||
|
||||
func (f *Formatter) class(t chroma.TokenType) string {
|
||||
for t != 0 {
|
||||
if cls, ok := chroma.StandardTypes[t]; ok {
|
||||
if cls != "" {
|
||||
return f.prefix + cls
|
||||
}
|
||||
return ""
|
||||
}
|
||||
t = t.Parent()
|
||||
}
|
||||
if cls := chroma.StandardTypes[t]; cls != "" {
|
||||
return f.prefix + cls
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (f *Formatter) styleAttr(styles map[chroma.TokenType]string, tt chroma.TokenType) string {
|
||||
if f.Classes {
|
||||
cls := f.class(tt)
|
||||
if cls == "" {
|
||||
return ""
|
||||
}
|
||||
return string(fmt.Sprintf(` class="%s"`, cls))
|
||||
}
|
||||
if _, ok := styles[tt]; !ok {
|
||||
tt = tt.SubCategory()
|
||||
if _, ok := styles[tt]; !ok {
|
||||
tt = tt.Category()
|
||||
if _, ok := styles[tt]; !ok {
|
||||
return ""
|
||||
}
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf(` style="%s"`, styles[tt])
|
||||
}
|
||||
|
||||
func (f *Formatter) tabWidthStyle() string {
|
||||
if f.tabWidth != 0 && f.tabWidth != 8 {
|
||||
return fmt.Sprintf("; -moz-tab-size: %[1]d; -o-tab-size: %[1]d; tab-size: %[1]d", f.tabWidth)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// WriteCSS writes CSS style definitions (without any surrounding HTML).
|
||||
func (f *Formatter) WriteCSS(w io.Writer, style *chroma.Style) error {
|
||||
css := f.styleToCSS(style)
|
||||
// Special-case background as it is mapped to the outer ".chroma" class.
|
||||
if _, err := fmt.Fprintf(w, "/* %s */ .%schroma { %s }\n", chroma.Background, f.prefix, css[chroma.Background]); err != nil {
|
||||
return err
|
||||
}
|
||||
// Special-case code column of table to expand width.
|
||||
if f.lineNumbers && f.lineNumbersInTable {
|
||||
if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s:last-child { width: 100%%; }",
|
||||
chroma.LineTableTD, f.prefix, f.class(chroma.LineTableTD)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
tts := []int{}
|
||||
for tt := range css {
|
||||
tts = append(tts, int(tt))
|
||||
}
|
||||
sort.Ints(tts)
|
||||
for _, ti := range tts {
|
||||
tt := chroma.TokenType(ti)
|
||||
if tt == chroma.Background {
|
||||
continue
|
||||
}
|
||||
styles := css[tt]
|
||||
if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s { %s }\n", tt, f.prefix, f.class(tt), styles); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *Formatter) styleToCSS(style *chroma.Style) map[chroma.TokenType]string {
|
||||
classes := map[chroma.TokenType]string{}
|
||||
bg := style.Get(chroma.Background)
|
||||
// Convert the style.
|
||||
for t := range chroma.StandardTypes {
|
||||
entry := style.Get(t)
|
||||
if t != chroma.Background {
|
||||
entry = entry.Sub(bg)
|
||||
}
|
||||
if entry.IsZero() {
|
||||
continue
|
||||
}
|
||||
classes[t] = StyleEntryToCSS(entry)
|
||||
}
|
||||
classes[chroma.Background] += f.tabWidthStyle()
|
||||
lineNumbersStyle := "margin-right: 0.4em; padding: 0 0.4em 0 0.4em;"
|
||||
// All rules begin with default rules followed by user provided rules
|
||||
classes[chroma.LineNumbers] = lineNumbersStyle + classes[chroma.LineNumbers]
|
||||
classes[chroma.LineNumbersTable] = lineNumbersStyle + classes[chroma.LineNumbersTable]
|
||||
classes[chroma.LineHighlight] = "display: block; width: 100%;" + classes[chroma.LineHighlight]
|
||||
classes[chroma.LineTable] = "border-spacing: 0; padding: 0; margin: 0; border: 0; width: auto; overflow: auto; display: block;" + classes[chroma.LineTable]
|
||||
classes[chroma.LineTableTD] = "vertical-align: top; padding: 0; margin: 0; border: 0;" + classes[chroma.LineTableTD]
|
||||
return classes
|
||||
}
|
||||
|
||||
// StyleEntryToCSS converts a chroma.StyleEntry to CSS attributes.
|
||||
func StyleEntryToCSS(e chroma.StyleEntry) string {
|
||||
styles := []string{}
|
||||
if e.Colour.IsSet() {
|
||||
styles = append(styles, "color: "+e.Colour.String())
|
||||
}
|
||||
if e.Background.IsSet() {
|
||||
styles = append(styles, "background-color: "+e.Background.String())
|
||||
}
|
||||
if e.Bold == chroma.Yes {
|
||||
styles = append(styles, "font-weight: bold")
|
||||
}
|
||||
if e.Italic == chroma.Yes {
|
||||
styles = append(styles, "font-style: italic")
|
||||
}
|
||||
return strings.Join(styles, "; ")
|
||||
}
|
||||
|
||||
// Compress CSS attributes - remove spaces, transform 6-digit colours to 3.
|
||||
func compressStyle(s string) string {
|
||||
parts := strings.Split(s, ";")
|
||||
out := []string{}
|
||||
for _, p := range parts {
|
||||
p = strings.Join(strings.Fields(p), " ")
|
||||
p = strings.Replace(p, ": ", ":", 1)
|
||||
if strings.Contains(p, "#") {
|
||||
c := p[len(p)-6:]
|
||||
if c[0] == c[1] && c[2] == c[3] && c[4] == c[5] {
|
||||
p = p[:len(p)-6] + c[0:1] + c[2:3] + c[4:5]
|
||||
}
|
||||
}
|
||||
out = append(out, p)
|
||||
}
|
||||
return strings.Join(out, ";")
|
||||
}
|
||||
|
||||
func splitTokensIntoLines(tokens []*chroma.Token) (out [][]*chroma.Token) {
|
||||
line := []*chroma.Token{}
|
||||
for _, token := range tokens {
|
||||
for strings.Contains(token.Value, "\n") {
|
||||
parts := strings.SplitAfterN(token.Value, "\n", 2)
|
||||
// Token becomes the tail.
|
||||
token.Value = parts[1]
|
||||
|
||||
// Append the head to the line and flush the line.
|
||||
clone := token.Clone()
|
||||
clone.Value = parts[0]
|
||||
line = append(line, clone)
|
||||
out = append(out, line)
|
||||
line = nil
|
||||
}
|
||||
line = append(line, token)
|
||||
}
|
||||
if len(line) > 0 {
|
||||
out = append(out, line)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
package formatters
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// JSON formatter outputs the raw token structures as JSON.
|
||||
var JSON = Register("json", chroma.FormatterFunc(func(w io.Writer, s *chroma.Style, it chroma.Iterator) error {
|
||||
fmt.Fprintln(w, "[")
|
||||
i := 0
|
||||
for t := it(); t != nil; t = it() {
|
||||
if i > 0 {
|
||||
fmt.Fprintln(w, ",")
|
||||
}
|
||||
i++
|
||||
bytes, err := json.Marshal(t)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := fmt.Fprint(w, " "+string(bytes)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
fmt.Fprintln(w)
|
||||
fmt.Fprintln(w, "]")
|
||||
return nil
|
||||
}))
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
package formatters
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Tokens formatter outputs the raw token structures.
|
||||
var Tokens = Register("tokens", chroma.FormatterFunc(func(w io.Writer, s *chroma.Style, it chroma.Iterator) error {
|
||||
for t := it(); t != nil; t = it() {
|
||||
if _, err := fmt.Fprintln(w, t.GoString()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}))
|
||||
|
|
@ -0,0 +1,250 @@
|
|||
package formatters
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"math"
|
||||
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
type ttyTable struct {
|
||||
foreground map[chroma.Colour]string
|
||||
background map[chroma.Colour]string
|
||||
}
|
||||
|
||||
var c = chroma.MustParseColour
|
||||
|
||||
var ttyTables = map[int]*ttyTable{
|
||||
8: {
|
||||
foreground: map[chroma.Colour]string{
|
||||
c("#000000"): "\033[30m", c("#7f0000"): "\033[31m", c("#007f00"): "\033[32m", c("#7f7fe0"): "\033[33m",
|
||||
c("#00007f"): "\033[34m", c("#7f007f"): "\033[35m", c("#007f7f"): "\033[36m", c("#e5e5e5"): "\033[37m",
|
||||
c("#555555"): "\033[90m", c("#ff0000"): "\033[91m", c("#00ff00"): "\033[92m", c("#ffff00"): "\033[93m",
|
||||
c("#0000ff"): "\033[94m", c("#ff00ff"): "\033[95m", c("#00ffff"): "\033[96m", c("#ffffff"): "\033[97m",
|
||||
},
|
||||
background: map[chroma.Colour]string{
|
||||
c("#000000"): "\033[40m", c("#7f0000"): "\033[41m", c("#007f00"): "\033[42m", c("#7f7fe0"): "\033[43m",
|
||||
c("#00007f"): "\033[44m", c("#7f007f"): "\033[45m", c("#007f7f"): "\033[46m", c("#e5e5e5"): "\033[47m",
|
||||
c("#555555"): "\033[100m", c("#ff0000"): "\033[101m", c("#00ff00"): "\033[102m", c("#ffff00"): "\033[103m",
|
||||
c("#0000ff"): "\033[104m", c("#ff00ff"): "\033[105m", c("#00ffff"): "\033[106m", c("#ffffff"): "\033[107m",
|
||||
},
|
||||
},
|
||||
256: {
|
||||
foreground: map[chroma.Colour]string{
|
||||
c("#000000"): "\033[38;5;0m", c("#800000"): "\033[38;5;1m", c("#008000"): "\033[38;5;2m", c("#808000"): "\033[38;5;3m",
|
||||
c("#000080"): "\033[38;5;4m", c("#800080"): "\033[38;5;5m", c("#008080"): "\033[38;5;6m", c("#c0c0c0"): "\033[38;5;7m",
|
||||
c("#808080"): "\033[38;5;8m", c("#ff0000"): "\033[38;5;9m", c("#00ff00"): "\033[38;5;10m", c("#ffff00"): "\033[38;5;11m",
|
||||
c("#0000ff"): "\033[38;5;12m", c("#ff00ff"): "\033[38;5;13m", c("#00ffff"): "\033[38;5;14m", c("#ffffff"): "\033[38;5;15m",
|
||||
c("#000000"): "\033[38;5;16m", c("#00005f"): "\033[38;5;17m", c("#000087"): "\033[38;5;18m", c("#0000af"): "\033[38;5;19m",
|
||||
c("#0000d7"): "\033[38;5;20m", c("#0000ff"): "\033[38;5;21m", c("#005f00"): "\033[38;5;22m", c("#005f5f"): "\033[38;5;23m",
|
||||
c("#005f87"): "\033[38;5;24m", c("#005faf"): "\033[38;5;25m", c("#005fd7"): "\033[38;5;26m", c("#005fff"): "\033[38;5;27m",
|
||||
c("#008700"): "\033[38;5;28m", c("#00875f"): "\033[38;5;29m", c("#008787"): "\033[38;5;30m", c("#0087af"): "\033[38;5;31m",
|
||||
c("#0087d7"): "\033[38;5;32m", c("#0087ff"): "\033[38;5;33m", c("#00af00"): "\033[38;5;34m", c("#00af5f"): "\033[38;5;35m",
|
||||
c("#00af87"): "\033[38;5;36m", c("#00afaf"): "\033[38;5;37m", c("#00afd7"): "\033[38;5;38m", c("#00afff"): "\033[38;5;39m",
|
||||
c("#00d700"): "\033[38;5;40m", c("#00d75f"): "\033[38;5;41m", c("#00d787"): "\033[38;5;42m", c("#00d7af"): "\033[38;5;43m",
|
||||
c("#00d7d7"): "\033[38;5;44m", c("#00d7ff"): "\033[38;5;45m", c("#00ff00"): "\033[38;5;46m", c("#00ff5f"): "\033[38;5;47m",
|
||||
c("#00ff87"): "\033[38;5;48m", c("#00ffaf"): "\033[38;5;49m", c("#00ffd7"): "\033[38;5;50m", c("#00ffff"): "\033[38;5;51m",
|
||||
c("#5f0000"): "\033[38;5;52m", c("#5f005f"): "\033[38;5;53m", c("#5f0087"): "\033[38;5;54m", c("#5f00af"): "\033[38;5;55m",
|
||||
c("#5f00d7"): "\033[38;5;56m", c("#5f00ff"): "\033[38;5;57m", c("#5f5f00"): "\033[38;5;58m", c("#5f5f5f"): "\033[38;5;59m",
|
||||
c("#5f5f87"): "\033[38;5;60m", c("#5f5faf"): "\033[38;5;61m", c("#5f5fd7"): "\033[38;5;62m", c("#5f5fff"): "\033[38;5;63m",
|
||||
c("#5f8700"): "\033[38;5;64m", c("#5f875f"): "\033[38;5;65m", c("#5f8787"): "\033[38;5;66m", c("#5f87af"): "\033[38;5;67m",
|
||||
c("#5f87d7"): "\033[38;5;68m", c("#5f87ff"): "\033[38;5;69m", c("#5faf00"): "\033[38;5;70m", c("#5faf5f"): "\033[38;5;71m",
|
||||
c("#5faf87"): "\033[38;5;72m", c("#5fafaf"): "\033[38;5;73m", c("#5fafd7"): "\033[38;5;74m", c("#5fafff"): "\033[38;5;75m",
|
||||
c("#5fd700"): "\033[38;5;76m", c("#5fd75f"): "\033[38;5;77m", c("#5fd787"): "\033[38;5;78m", c("#5fd7af"): "\033[38;5;79m",
|
||||
c("#5fd7d7"): "\033[38;5;80m", c("#5fd7ff"): "\033[38;5;81m", c("#5fff00"): "\033[38;5;82m", c("#5fff5f"): "\033[38;5;83m",
|
||||
c("#5fff87"): "\033[38;5;84m", c("#5fffaf"): "\033[38;5;85m", c("#5fffd7"): "\033[38;5;86m", c("#5fffff"): "\033[38;5;87m",
|
||||
c("#870000"): "\033[38;5;88m", c("#87005f"): "\033[38;5;89m", c("#870087"): "\033[38;5;90m", c("#8700af"): "\033[38;5;91m",
|
||||
c("#8700d7"): "\033[38;5;92m", c("#8700ff"): "\033[38;5;93m", c("#875f00"): "\033[38;5;94m", c("#875f5f"): "\033[38;5;95m",
|
||||
c("#875f87"): "\033[38;5;96m", c("#875faf"): "\033[38;5;97m", c("#875fd7"): "\033[38;5;98m", c("#875fff"): "\033[38;5;99m",
|
||||
c("#878700"): "\033[38;5;100m", c("#87875f"): "\033[38;5;101m", c("#878787"): "\033[38;5;102m", c("#8787af"): "\033[38;5;103m",
|
||||
c("#8787d7"): "\033[38;5;104m", c("#8787ff"): "\033[38;5;105m", c("#87af00"): "\033[38;5;106m", c("#87af5f"): "\033[38;5;107m",
|
||||
c("#87af87"): "\033[38;5;108m", c("#87afaf"): "\033[38;5;109m", c("#87afd7"): "\033[38;5;110m", c("#87afff"): "\033[38;5;111m",
|
||||
c("#87d700"): "\033[38;5;112m", c("#87d75f"): "\033[38;5;113m", c("#87d787"): "\033[38;5;114m", c("#87d7af"): "\033[38;5;115m",
|
||||
c("#87d7d7"): "\033[38;5;116m", c("#87d7ff"): "\033[38;5;117m", c("#87ff00"): "\033[38;5;118m", c("#87ff5f"): "\033[38;5;119m",
|
||||
c("#87ff87"): "\033[38;5;120m", c("#87ffaf"): "\033[38;5;121m", c("#87ffd7"): "\033[38;5;122m", c("#87ffff"): "\033[38;5;123m",
|
||||
c("#af0000"): "\033[38;5;124m", c("#af005f"): "\033[38;5;125m", c("#af0087"): "\033[38;5;126m", c("#af00af"): "\033[38;5;127m",
|
||||
c("#af00d7"): "\033[38;5;128m", c("#af00ff"): "\033[38;5;129m", c("#af5f00"): "\033[38;5;130m", c("#af5f5f"): "\033[38;5;131m",
|
||||
c("#af5f87"): "\033[38;5;132m", c("#af5faf"): "\033[38;5;133m", c("#af5fd7"): "\033[38;5;134m", c("#af5fff"): "\033[38;5;135m",
|
||||
c("#af8700"): "\033[38;5;136m", c("#af875f"): "\033[38;5;137m", c("#af8787"): "\033[38;5;138m", c("#af87af"): "\033[38;5;139m",
|
||||
c("#af87d7"): "\033[38;5;140m", c("#af87ff"): "\033[38;5;141m", c("#afaf00"): "\033[38;5;142m", c("#afaf5f"): "\033[38;5;143m",
|
||||
c("#afaf87"): "\033[38;5;144m", c("#afafaf"): "\033[38;5;145m", c("#afafd7"): "\033[38;5;146m", c("#afafff"): "\033[38;5;147m",
|
||||
c("#afd700"): "\033[38;5;148m", c("#afd75f"): "\033[38;5;149m", c("#afd787"): "\033[38;5;150m", c("#afd7af"): "\033[38;5;151m",
|
||||
c("#afd7d7"): "\033[38;5;152m", c("#afd7ff"): "\033[38;5;153m", c("#afff00"): "\033[38;5;154m", c("#afff5f"): "\033[38;5;155m",
|
||||
c("#afff87"): "\033[38;5;156m", c("#afffaf"): "\033[38;5;157m", c("#afffd7"): "\033[38;5;158m", c("#afffff"): "\033[38;5;159m",
|
||||
c("#d70000"): "\033[38;5;160m", c("#d7005f"): "\033[38;5;161m", c("#d70087"): "\033[38;5;162m", c("#d700af"): "\033[38;5;163m",
|
||||
c("#d700d7"): "\033[38;5;164m", c("#d700ff"): "\033[38;5;165m", c("#d75f00"): "\033[38;5;166m", c("#d75f5f"): "\033[38;5;167m",
|
||||
c("#d75f87"): "\033[38;5;168m", c("#d75faf"): "\033[38;5;169m", c("#d75fd7"): "\033[38;5;170m", c("#d75fff"): "\033[38;5;171m",
|
||||
c("#d78700"): "\033[38;5;172m", c("#d7875f"): "\033[38;5;173m", c("#d78787"): "\033[38;5;174m", c("#d787af"): "\033[38;5;175m",
|
||||
c("#d787d7"): "\033[38;5;176m", c("#d787ff"): "\033[38;5;177m", c("#d7af00"): "\033[38;5;178m", c("#d7af5f"): "\033[38;5;179m",
|
||||
c("#d7af87"): "\033[38;5;180m", c("#d7afaf"): "\033[38;5;181m", c("#d7afd7"): "\033[38;5;182m", c("#d7afff"): "\033[38;5;183m",
|
||||
c("#d7d700"): "\033[38;5;184m", c("#d7d75f"): "\033[38;5;185m", c("#d7d787"): "\033[38;5;186m", c("#d7d7af"): "\033[38;5;187m",
|
||||
c("#d7d7d7"): "\033[38;5;188m", c("#d7d7ff"): "\033[38;5;189m", c("#d7ff00"): "\033[38;5;190m", c("#d7ff5f"): "\033[38;5;191m",
|
||||
c("#d7ff87"): "\033[38;5;192m", c("#d7ffaf"): "\033[38;5;193m", c("#d7ffd7"): "\033[38;5;194m", c("#d7ffff"): "\033[38;5;195m",
|
||||
c("#ff0000"): "\033[38;5;196m", c("#ff005f"): "\033[38;5;197m", c("#ff0087"): "\033[38;5;198m", c("#ff00af"): "\033[38;5;199m",
|
||||
c("#ff00d7"): "\033[38;5;200m", c("#ff00ff"): "\033[38;5;201m", c("#ff5f00"): "\033[38;5;202m", c("#ff5f5f"): "\033[38;5;203m",
|
||||
c("#ff5f87"): "\033[38;5;204m", c("#ff5faf"): "\033[38;5;205m", c("#ff5fd7"): "\033[38;5;206m", c("#ff5fff"): "\033[38;5;207m",
|
||||
c("#ff8700"): "\033[38;5;208m", c("#ff875f"): "\033[38;5;209m", c("#ff8787"): "\033[38;5;210m", c("#ff87af"): "\033[38;5;211m",
|
||||
c("#ff87d7"): "\033[38;5;212m", c("#ff87ff"): "\033[38;5;213m", c("#ffaf00"): "\033[38;5;214m", c("#ffaf5f"): "\033[38;5;215m",
|
||||
c("#ffaf87"): "\033[38;5;216m", c("#ffafaf"): "\033[38;5;217m", c("#ffafd7"): "\033[38;5;218m", c("#ffafff"): "\033[38;5;219m",
|
||||
c("#ffd700"): "\033[38;5;220m", c("#ffd75f"): "\033[38;5;221m", c("#ffd787"): "\033[38;5;222m", c("#ffd7af"): "\033[38;5;223m",
|
||||
c("#ffd7d7"): "\033[38;5;224m", c("#ffd7ff"): "\033[38;5;225m", c("#ffff00"): "\033[38;5;226m", c("#ffff5f"): "\033[38;5;227m",
|
||||
c("#ffff87"): "\033[38;5;228m", c("#ffffaf"): "\033[38;5;229m", c("#ffffd7"): "\033[38;5;230m", c("#ffffff"): "\033[38;5;231m",
|
||||
c("#080808"): "\033[38;5;232m", c("#121212"): "\033[38;5;233m", c("#1c1c1c"): "\033[38;5;234m", c("#262626"): "\033[38;5;235m",
|
||||
c("#303030"): "\033[38;5;236m", c("#3a3a3a"): "\033[38;5;237m", c("#444444"): "\033[38;5;238m", c("#4e4e4e"): "\033[38;5;239m",
|
||||
c("#585858"): "\033[38;5;240m", c("#626262"): "\033[38;5;241m", c("#6c6c6c"): "\033[38;5;242m", c("#767676"): "\033[38;5;243m",
|
||||
c("#808080"): "\033[38;5;244m", c("#8a8a8a"): "\033[38;5;245m", c("#949494"): "\033[38;5;246m", c("#9e9e9e"): "\033[38;5;247m",
|
||||
c("#a8a8a8"): "\033[38;5;248m", c("#b2b2b2"): "\033[38;5;249m", c("#bcbcbc"): "\033[38;5;250m", c("#c6c6c6"): "\033[38;5;251m",
|
||||
c("#d0d0d0"): "\033[38;5;252m", c("#dadada"): "\033[38;5;253m", c("#e4e4e4"): "\033[38;5;254m", c("#eeeeee"): "\033[38;5;255m",
|
||||
},
|
||||
background: map[chroma.Colour]string{
|
||||
c("#000000"): "\033[48;5;0m", c("#800000"): "\033[48;5;1m", c("#008000"): "\033[48;5;2m", c("#808000"): "\033[48;5;3m",
|
||||
c("#000080"): "\033[48;5;4m", c("#800080"): "\033[48;5;5m", c("#008080"): "\033[48;5;6m", c("#c0c0c0"): "\033[48;5;7m",
|
||||
c("#808080"): "\033[48;5;8m", c("#ff0000"): "\033[48;5;9m", c("#00ff00"): "\033[48;5;10m", c("#ffff00"): "\033[48;5;11m",
|
||||
c("#0000ff"): "\033[48;5;12m", c("#ff00ff"): "\033[48;5;13m", c("#00ffff"): "\033[48;5;14m", c("#ffffff"): "\033[48;5;15m",
|
||||
c("#000000"): "\033[48;5;16m", c("#00005f"): "\033[48;5;17m", c("#000087"): "\033[48;5;18m", c("#0000af"): "\033[48;5;19m",
|
||||
c("#0000d7"): "\033[48;5;20m", c("#0000ff"): "\033[48;5;21m", c("#005f00"): "\033[48;5;22m", c("#005f5f"): "\033[48;5;23m",
|
||||
c("#005f87"): "\033[48;5;24m", c("#005faf"): "\033[48;5;25m", c("#005fd7"): "\033[48;5;26m", c("#005fff"): "\033[48;5;27m",
|
||||
c("#008700"): "\033[48;5;28m", c("#00875f"): "\033[48;5;29m", c("#008787"): "\033[48;5;30m", c("#0087af"): "\033[48;5;31m",
|
||||
c("#0087d7"): "\033[48;5;32m", c("#0087ff"): "\033[48;5;33m", c("#00af00"): "\033[48;5;34m", c("#00af5f"): "\033[48;5;35m",
|
||||
c("#00af87"): "\033[48;5;36m", c("#00afaf"): "\033[48;5;37m", c("#00afd7"): "\033[48;5;38m", c("#00afff"): "\033[48;5;39m",
|
||||
c("#00d700"): "\033[48;5;40m", c("#00d75f"): "\033[48;5;41m", c("#00d787"): "\033[48;5;42m", c("#00d7af"): "\033[48;5;43m",
|
||||
c("#00d7d7"): "\033[48;5;44m", c("#00d7ff"): "\033[48;5;45m", c("#00ff00"): "\033[48;5;46m", c("#00ff5f"): "\033[48;5;47m",
|
||||
c("#00ff87"): "\033[48;5;48m", c("#00ffaf"): "\033[48;5;49m", c("#00ffd7"): "\033[48;5;50m", c("#00ffff"): "\033[48;5;51m",
|
||||
c("#5f0000"): "\033[48;5;52m", c("#5f005f"): "\033[48;5;53m", c("#5f0087"): "\033[48;5;54m", c("#5f00af"): "\033[48;5;55m",
|
||||
c("#5f00d7"): "\033[48;5;56m", c("#5f00ff"): "\033[48;5;57m", c("#5f5f00"): "\033[48;5;58m", c("#5f5f5f"): "\033[48;5;59m",
|
||||
c("#5f5f87"): "\033[48;5;60m", c("#5f5faf"): "\033[48;5;61m", c("#5f5fd7"): "\033[48;5;62m", c("#5f5fff"): "\033[48;5;63m",
|
||||
c("#5f8700"): "\033[48;5;64m", c("#5f875f"): "\033[48;5;65m", c("#5f8787"): "\033[48;5;66m", c("#5f87af"): "\033[48;5;67m",
|
||||
c("#5f87d7"): "\033[48;5;68m", c("#5f87ff"): "\033[48;5;69m", c("#5faf00"): "\033[48;5;70m", c("#5faf5f"): "\033[48;5;71m",
|
||||
c("#5faf87"): "\033[48;5;72m", c("#5fafaf"): "\033[48;5;73m", c("#5fafd7"): "\033[48;5;74m", c("#5fafff"): "\033[48;5;75m",
|
||||
c("#5fd700"): "\033[48;5;76m", c("#5fd75f"): "\033[48;5;77m", c("#5fd787"): "\033[48;5;78m", c("#5fd7af"): "\033[48;5;79m",
|
||||
c("#5fd7d7"): "\033[48;5;80m", c("#5fd7ff"): "\033[48;5;81m", c("#5fff00"): "\033[48;5;82m", c("#5fff5f"): "\033[48;5;83m",
|
||||
c("#5fff87"): "\033[48;5;84m", c("#5fffaf"): "\033[48;5;85m", c("#5fffd7"): "\033[48;5;86m", c("#5fffff"): "\033[48;5;87m",
|
||||
c("#870000"): "\033[48;5;88m", c("#87005f"): "\033[48;5;89m", c("#870087"): "\033[48;5;90m", c("#8700af"): "\033[48;5;91m",
|
||||
c("#8700d7"): "\033[48;5;92m", c("#8700ff"): "\033[48;5;93m", c("#875f00"): "\033[48;5;94m", c("#875f5f"): "\033[48;5;95m",
|
||||
c("#875f87"): "\033[48;5;96m", c("#875faf"): "\033[48;5;97m", c("#875fd7"): "\033[48;5;98m", c("#875fff"): "\033[48;5;99m",
|
||||
c("#878700"): "\033[48;5;100m", c("#87875f"): "\033[48;5;101m", c("#878787"): "\033[48;5;102m", c("#8787af"): "\033[48;5;103m",
|
||||
c("#8787d7"): "\033[48;5;104m", c("#8787ff"): "\033[48;5;105m", c("#87af00"): "\033[48;5;106m", c("#87af5f"): "\033[48;5;107m",
|
||||
c("#87af87"): "\033[48;5;108m", c("#87afaf"): "\033[48;5;109m", c("#87afd7"): "\033[48;5;110m", c("#87afff"): "\033[48;5;111m",
|
||||
c("#87d700"): "\033[48;5;112m", c("#87d75f"): "\033[48;5;113m", c("#87d787"): "\033[48;5;114m", c("#87d7af"): "\033[48;5;115m",
|
||||
c("#87d7d7"): "\033[48;5;116m", c("#87d7ff"): "\033[48;5;117m", c("#87ff00"): "\033[48;5;118m", c("#87ff5f"): "\033[48;5;119m",
|
||||
c("#87ff87"): "\033[48;5;120m", c("#87ffaf"): "\033[48;5;121m", c("#87ffd7"): "\033[48;5;122m", c("#87ffff"): "\033[48;5;123m",
|
||||
c("#af0000"): "\033[48;5;124m", c("#af005f"): "\033[48;5;125m", c("#af0087"): "\033[48;5;126m", c("#af00af"): "\033[48;5;127m",
|
||||
c("#af00d7"): "\033[48;5;128m", c("#af00ff"): "\033[48;5;129m", c("#af5f00"): "\033[48;5;130m", c("#af5f5f"): "\033[48;5;131m",
|
||||
c("#af5f87"): "\033[48;5;132m", c("#af5faf"): "\033[48;5;133m", c("#af5fd7"): "\033[48;5;134m", c("#af5fff"): "\033[48;5;135m",
|
||||
c("#af8700"): "\033[48;5;136m", c("#af875f"): "\033[48;5;137m", c("#af8787"): "\033[48;5;138m", c("#af87af"): "\033[48;5;139m",
|
||||
c("#af87d7"): "\033[48;5;140m", c("#af87ff"): "\033[48;5;141m", c("#afaf00"): "\033[48;5;142m", c("#afaf5f"): "\033[48;5;143m",
|
||||
c("#afaf87"): "\033[48;5;144m", c("#afafaf"): "\033[48;5;145m", c("#afafd7"): "\033[48;5;146m", c("#afafff"): "\033[48;5;147m",
|
||||
c("#afd700"): "\033[48;5;148m", c("#afd75f"): "\033[48;5;149m", c("#afd787"): "\033[48;5;150m", c("#afd7af"): "\033[48;5;151m",
|
||||
c("#afd7d7"): "\033[48;5;152m", c("#afd7ff"): "\033[48;5;153m", c("#afff00"): "\033[48;5;154m", c("#afff5f"): "\033[48;5;155m",
|
||||
c("#afff87"): "\033[48;5;156m", c("#afffaf"): "\033[48;5;157m", c("#afffd7"): "\033[48;5;158m", c("#afffff"): "\033[48;5;159m",
|
||||
c("#d70000"): "\033[48;5;160m", c("#d7005f"): "\033[48;5;161m", c("#d70087"): "\033[48;5;162m", c("#d700af"): "\033[48;5;163m",
|
||||
c("#d700d7"): "\033[48;5;164m", c("#d700ff"): "\033[48;5;165m", c("#d75f00"): "\033[48;5;166m", c("#d75f5f"): "\033[48;5;167m",
|
||||
c("#d75f87"): "\033[48;5;168m", c("#d75faf"): "\033[48;5;169m", c("#d75fd7"): "\033[48;5;170m", c("#d75fff"): "\033[48;5;171m",
|
||||
c("#d78700"): "\033[48;5;172m", c("#d7875f"): "\033[48;5;173m", c("#d78787"): "\033[48;5;174m", c("#d787af"): "\033[48;5;175m",
|
||||
c("#d787d7"): "\033[48;5;176m", c("#d787ff"): "\033[48;5;177m", c("#d7af00"): "\033[48;5;178m", c("#d7af5f"): "\033[48;5;179m",
|
||||
c("#d7af87"): "\033[48;5;180m", c("#d7afaf"): "\033[48;5;181m", c("#d7afd7"): "\033[48;5;182m", c("#d7afff"): "\033[48;5;183m",
|
||||
c("#d7d700"): "\033[48;5;184m", c("#d7d75f"): "\033[48;5;185m", c("#d7d787"): "\033[48;5;186m", c("#d7d7af"): "\033[48;5;187m",
|
||||
c("#d7d7d7"): "\033[48;5;188m", c("#d7d7ff"): "\033[48;5;189m", c("#d7ff00"): "\033[48;5;190m", c("#d7ff5f"): "\033[48;5;191m",
|
||||
c("#d7ff87"): "\033[48;5;192m", c("#d7ffaf"): "\033[48;5;193m", c("#d7ffd7"): "\033[48;5;194m", c("#d7ffff"): "\033[48;5;195m",
|
||||
c("#ff0000"): "\033[48;5;196m", c("#ff005f"): "\033[48;5;197m", c("#ff0087"): "\033[48;5;198m", c("#ff00af"): "\033[48;5;199m",
|
||||
c("#ff00d7"): "\033[48;5;200m", c("#ff00ff"): "\033[48;5;201m", c("#ff5f00"): "\033[48;5;202m", c("#ff5f5f"): "\033[48;5;203m",
|
||||
c("#ff5f87"): "\033[48;5;204m", c("#ff5faf"): "\033[48;5;205m", c("#ff5fd7"): "\033[48;5;206m", c("#ff5fff"): "\033[48;5;207m",
|
||||
c("#ff8700"): "\033[48;5;208m", c("#ff875f"): "\033[48;5;209m", c("#ff8787"): "\033[48;5;210m", c("#ff87af"): "\033[48;5;211m",
|
||||
c("#ff87d7"): "\033[48;5;212m", c("#ff87ff"): "\033[48;5;213m", c("#ffaf00"): "\033[48;5;214m", c("#ffaf5f"): "\033[48;5;215m",
|
||||
c("#ffaf87"): "\033[48;5;216m", c("#ffafaf"): "\033[48;5;217m", c("#ffafd7"): "\033[48;5;218m", c("#ffafff"): "\033[48;5;219m",
|
||||
c("#ffd700"): "\033[48;5;220m", c("#ffd75f"): "\033[48;5;221m", c("#ffd787"): "\033[48;5;222m", c("#ffd7af"): "\033[48;5;223m",
|
||||
c("#ffd7d7"): "\033[48;5;224m", c("#ffd7ff"): "\033[48;5;225m", c("#ffff00"): "\033[48;5;226m", c("#ffff5f"): "\033[48;5;227m",
|
||||
c("#ffff87"): "\033[48;5;228m", c("#ffffaf"): "\033[48;5;229m", c("#ffffd7"): "\033[48;5;230m", c("#ffffff"): "\033[48;5;231m",
|
||||
c("#080808"): "\033[48;5;232m", c("#121212"): "\033[48;5;233m", c("#1c1c1c"): "\033[48;5;234m", c("#262626"): "\033[48;5;235m",
|
||||
c("#303030"): "\033[48;5;236m", c("#3a3a3a"): "\033[48;5;237m", c("#444444"): "\033[48;5;238m", c("#4e4e4e"): "\033[48;5;239m",
|
||||
c("#585858"): "\033[48;5;240m", c("#626262"): "\033[48;5;241m", c("#6c6c6c"): "\033[48;5;242m", c("#767676"): "\033[48;5;243m",
|
||||
c("#808080"): "\033[48;5;244m", c("#8a8a8a"): "\033[48;5;245m", c("#949494"): "\033[48;5;246m", c("#9e9e9e"): "\033[48;5;247m",
|
||||
c("#a8a8a8"): "\033[48;5;248m", c("#b2b2b2"): "\033[48;5;249m", c("#bcbcbc"): "\033[48;5;250m", c("#c6c6c6"): "\033[48;5;251m",
|
||||
c("#d0d0d0"): "\033[48;5;252m", c("#dadada"): "\033[48;5;253m", c("#e4e4e4"): "\033[48;5;254m", c("#eeeeee"): "\033[48;5;255m",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func entryToEscapeSequence(table *ttyTable, entry chroma.StyleEntry) string {
|
||||
out := ""
|
||||
if entry.Bold == chroma.Yes {
|
||||
out += "\033[1m"
|
||||
}
|
||||
if entry.Underline == chroma.Yes {
|
||||
out += "\033[4m"
|
||||
}
|
||||
if entry.Colour.IsSet() {
|
||||
out += table.foreground[findClosest(table, entry.Colour)]
|
||||
}
|
||||
if entry.Background.IsSet() {
|
||||
out += table.background[findClosest(table, entry.Background)]
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func findClosest(table *ttyTable, seeking chroma.Colour) chroma.Colour {
|
||||
closestColour := chroma.Colour(0)
|
||||
closest := float64(math.MaxFloat64)
|
||||
for colour := range table.foreground {
|
||||
distance := colour.Distance(seeking)
|
||||
if distance < closest {
|
||||
closest = distance
|
||||
closestColour = colour
|
||||
}
|
||||
}
|
||||
return closestColour
|
||||
}
|
||||
|
||||
func styleToEscapeSequence(table *ttyTable, style *chroma.Style) map[chroma.TokenType]string {
|
||||
out := map[chroma.TokenType]string{}
|
||||
for _, ttype := range style.Types() {
|
||||
entry := style.Get(ttype)
|
||||
out[ttype] = entryToEscapeSequence(table, entry)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
type indexedTTYFormatter struct {
|
||||
table *ttyTable
|
||||
}
|
||||
|
||||
func (c *indexedTTYFormatter) Format(w io.Writer, style *chroma.Style, it chroma.Iterator) (err error) {
|
||||
defer func() {
|
||||
if perr := recover(); perr != nil {
|
||||
err = perr.(error)
|
||||
}
|
||||
}()
|
||||
theme := styleToEscapeSequence(c.table, style)
|
||||
for token := it(); token != nil; token = it() {
|
||||
// TODO: Cache token lookups?
|
||||
clr, ok := theme[token.Type]
|
||||
if !ok {
|
||||
clr, ok = theme[token.Type.SubCategory()]
|
||||
if !ok {
|
||||
clr = theme[token.Type.Category()]
|
||||
// if !ok {
|
||||
// clr = theme[chroma.InheritStyle]
|
||||
// }
|
||||
}
|
||||
}
|
||||
if clr != "" {
|
||||
fmt.Fprint(w, clr)
|
||||
}
|
||||
fmt.Fprint(w, token.Value)
|
||||
if clr != "" {
|
||||
fmt.Fprintf(w, "\033[0m")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// TTY8 is an 8-colour terminal formatter.
|
||||
//
|
||||
// The Lab colour space is used to map RGB values to the most appropriate index colour.
|
||||
var TTY8 = Register("terminal", &indexedTTYFormatter{ttyTables[8]})
|
||||
|
||||
// TTY256 is a 256-colour terminal formatter.
|
||||
//
|
||||
// The Lab colour space is used to map RGB values to the most appropriate index colour.
|
||||
var TTY256 = Register("terminal256", &indexedTTYFormatter{ttyTables[256]})
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
package formatters
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// TTY16m is a true-colour terminal formatter.
|
||||
var TTY16m = Register("terminal16m", chroma.FormatterFunc(trueColourFormatter))
|
||||
|
||||
func trueColourFormatter(w io.Writer, style *chroma.Style, it chroma.Iterator) error {
|
||||
for token := it(); token != nil; token = it() {
|
||||
entry := style.Get(token.Type)
|
||||
if !entry.IsZero() {
|
||||
out := ""
|
||||
if entry.Bold == chroma.Yes {
|
||||
out += "\033[1m"
|
||||
}
|
||||
if entry.Underline == chroma.Yes {
|
||||
out += "\033[4m"
|
||||
}
|
||||
if entry.Colour.IsSet() {
|
||||
out += fmt.Sprintf("\033[38;2;%d;%d;%dm", entry.Colour.Red(), entry.Colour.Green(), entry.Colour.Blue())
|
||||
}
|
||||
if entry.Background.IsSet() {
|
||||
out += fmt.Sprintf("\033[48;2;%d;%d;%dm", entry.Background.Red(), entry.Background.Green(), entry.Background.Blue())
|
||||
}
|
||||
fmt.Fprint(w, out)
|
||||
}
|
||||
fmt.Fprint(w, token.Value)
|
||||
if !entry.IsZero() {
|
||||
fmt.Fprint(w, "\033[0m")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Abap style.
|
||||
var Abap = Register(chroma.MustNewStyle("abap", chroma.StyleEntries{
|
||||
chroma.Comment: "italic #888",
|
||||
chroma.CommentSpecial: "#888",
|
||||
chroma.Keyword: "#00f",
|
||||
chroma.OperatorWord: "#00f",
|
||||
chroma.Name: "#000",
|
||||
chroma.LiteralNumber: "#3af",
|
||||
chroma.LiteralString: "#5a2",
|
||||
chroma.Error: "#F00",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Algol style.
|
||||
var Algol = Register(chroma.MustNewStyle("algol", chroma.StyleEntries{
|
||||
chroma.Comment: "italic #888",
|
||||
chroma.CommentPreproc: "bold noitalic #888",
|
||||
chroma.CommentSpecial: "bold noitalic #888",
|
||||
chroma.Keyword: "underline bold",
|
||||
chroma.KeywordDeclaration: "italic",
|
||||
chroma.NameBuiltin: "bold italic",
|
||||
chroma.NameBuiltinPseudo: "bold italic",
|
||||
chroma.NameNamespace: "bold italic #666",
|
||||
chroma.NameClass: "bold italic #666",
|
||||
chroma.NameFunction: "bold italic #666",
|
||||
chroma.NameVariable: "bold italic #666",
|
||||
chroma.NameConstant: "bold italic #666",
|
||||
chroma.OperatorWord: "bold",
|
||||
chroma.LiteralString: "italic #666",
|
||||
chroma.Error: "border:#FF0000",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Algol_Nu style.
|
||||
var Algol_Nu = Register(chroma.MustNewStyle("algol_nu", chroma.StyleEntries{
|
||||
chroma.Comment: "italic #888",
|
||||
chroma.CommentPreproc: "bold noitalic #888",
|
||||
chroma.CommentSpecial: "bold noitalic #888",
|
||||
chroma.Keyword: "bold",
|
||||
chroma.KeywordDeclaration: "italic",
|
||||
chroma.NameBuiltin: "bold italic",
|
||||
chroma.NameBuiltinPseudo: "bold italic",
|
||||
chroma.NameNamespace: "bold italic #666",
|
||||
chroma.NameClass: "bold italic #666",
|
||||
chroma.NameFunction: "bold italic #666",
|
||||
chroma.NameVariable: "bold italic #666",
|
||||
chroma.NameConstant: "bold italic #666",
|
||||
chroma.OperatorWord: "bold",
|
||||
chroma.LiteralString: "italic #666",
|
||||
chroma.Error: "border:#FF0000",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"sort"
|
||||
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Registry of Styles.
|
||||
var Registry = map[string]*chroma.Style{}
|
||||
|
||||
// Fallback style. Reassign to change the default fallback style.
|
||||
var Fallback = SwapOff
|
||||
|
||||
// Register a chroma.Style.
|
||||
func Register(style *chroma.Style) *chroma.Style {
|
||||
Registry[style.Name] = style
|
||||
return style
|
||||
}
|
||||
|
||||
// Names of all available styles.
|
||||
func Names() []string {
|
||||
out := []string{}
|
||||
for name := range Registry {
|
||||
out = append(out, name)
|
||||
}
|
||||
sort.Strings(out)
|
||||
return out
|
||||
}
|
||||
|
||||
// Get named style, or Fallback.
|
||||
func Get(name string) *chroma.Style {
|
||||
if style, ok := Registry[name]; ok {
|
||||
return style
|
||||
}
|
||||
return Fallback
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Arduino style.
|
||||
var Arduino = Register(chroma.MustNewStyle("arduino", chroma.StyleEntries{
|
||||
chroma.Error: "#a61717",
|
||||
chroma.Comment: "#95a5a6",
|
||||
chroma.CommentPreproc: "#728E00",
|
||||
chroma.Keyword: "#728E00",
|
||||
chroma.KeywordConstant: "#00979D",
|
||||
chroma.KeywordPseudo: "#00979D",
|
||||
chroma.KeywordReserved: "#00979D",
|
||||
chroma.KeywordType: "#00979D",
|
||||
chroma.Operator: "#728E00",
|
||||
chroma.Name: "#434f54",
|
||||
chroma.NameBuiltin: "#728E00",
|
||||
chroma.NameFunction: "#D35400",
|
||||
chroma.NameOther: "#728E00",
|
||||
chroma.LiteralNumber: "#8A7B52",
|
||||
chroma.LiteralString: "#7F8C8D",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Autumn style.
|
||||
var Autumn = Register(chroma.MustNewStyle("autumn", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "italic #aaaaaa",
|
||||
chroma.CommentPreproc: "noitalic #4c8317",
|
||||
chroma.CommentSpecial: "italic #0000aa",
|
||||
chroma.Keyword: "#0000aa",
|
||||
chroma.KeywordType: "#00aaaa",
|
||||
chroma.OperatorWord: "#0000aa",
|
||||
chroma.NameBuiltin: "#00aaaa",
|
||||
chroma.NameFunction: "#00aa00",
|
||||
chroma.NameClass: "underline #00aa00",
|
||||
chroma.NameNamespace: "underline #00aaaa",
|
||||
chroma.NameVariable: "#aa0000",
|
||||
chroma.NameConstant: "#aa0000",
|
||||
chroma.NameEntity: "bold #800",
|
||||
chroma.NameAttribute: "#1e90ff",
|
||||
chroma.NameTag: "bold #1e90ff",
|
||||
chroma.NameDecorator: "#888888",
|
||||
chroma.LiteralString: "#aa5500",
|
||||
chroma.LiteralStringSymbol: "#0000aa",
|
||||
chroma.LiteralStringRegex: "#009999",
|
||||
chroma.LiteralNumber: "#009999",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#aa0000",
|
||||
chroma.GenericInserted: "#00aa00",
|
||||
chroma.GenericError: "#aa0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "#555555",
|
||||
chroma.GenericOutput: "#888888",
|
||||
chroma.GenericTraceback: "#aa0000",
|
||||
chroma.Error: "#F00 bg:#FAA",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Borland style.
|
||||
var Borland = Register(chroma.MustNewStyle("borland", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "italic #008800",
|
||||
chroma.CommentPreproc: "noitalic #008080",
|
||||
chroma.CommentSpecial: "noitalic bold",
|
||||
chroma.LiteralString: "#0000FF",
|
||||
chroma.LiteralStringChar: "#800080",
|
||||
chroma.LiteralNumber: "#0000FF",
|
||||
chroma.Keyword: "bold #000080",
|
||||
chroma.OperatorWord: "bold",
|
||||
chroma.NameTag: "bold #000080",
|
||||
chroma.NameAttribute: "#FF0000",
|
||||
chroma.GenericHeading: "#999999",
|
||||
chroma.GenericSubheading: "#aaaaaa",
|
||||
chroma.GenericDeleted: "bg:#ffdddd #000000",
|
||||
chroma.GenericInserted: "bg:#ddffdd #000000",
|
||||
chroma.GenericError: "#aa0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "#555555",
|
||||
chroma.GenericOutput: "#888888",
|
||||
chroma.GenericTraceback: "#aa0000",
|
||||
chroma.Error: "bg:#e3d2d2 #a61717",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// BlackWhite style.
|
||||
var BlackWhite = Register(chroma.MustNewStyle("bw", chroma.StyleEntries{
|
||||
chroma.Comment: "italic",
|
||||
chroma.CommentPreproc: "noitalic",
|
||||
chroma.Keyword: "bold",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.KeywordType: "nobold",
|
||||
chroma.OperatorWord: "bold",
|
||||
chroma.NameClass: "bold",
|
||||
chroma.NameNamespace: "bold",
|
||||
chroma.NameException: "bold",
|
||||
chroma.NameEntity: "bold",
|
||||
chroma.NameTag: "bold",
|
||||
chroma.LiteralString: "italic",
|
||||
chroma.LiteralStringInterpol: "bold",
|
||||
chroma.LiteralStringEscape: "bold",
|
||||
chroma.GenericHeading: "bold",
|
||||
chroma.GenericSubheading: "bold",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold",
|
||||
chroma.Error: "border:#FF0000",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Colorful style.
|
||||
var Colorful = Register(chroma.MustNewStyle("colorful", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "#888",
|
||||
chroma.CommentPreproc: "#579",
|
||||
chroma.CommentSpecial: "bold #cc0000",
|
||||
chroma.Keyword: "bold #080",
|
||||
chroma.KeywordPseudo: "#038",
|
||||
chroma.KeywordType: "#339",
|
||||
chroma.Operator: "#333",
|
||||
chroma.OperatorWord: "bold #000",
|
||||
chroma.NameBuiltin: "#007020",
|
||||
chroma.NameFunction: "bold #06B",
|
||||
chroma.NameClass: "bold #B06",
|
||||
chroma.NameNamespace: "bold #0e84b5",
|
||||
chroma.NameException: "bold #F00",
|
||||
chroma.NameVariable: "#963",
|
||||
chroma.NameVariableInstance: "#33B",
|
||||
chroma.NameVariableClass: "#369",
|
||||
chroma.NameVariableGlobal: "bold #d70",
|
||||
chroma.NameConstant: "bold #036",
|
||||
chroma.NameLabel: "bold #970",
|
||||
chroma.NameEntity: "bold #800",
|
||||
chroma.NameAttribute: "#00C",
|
||||
chroma.NameTag: "#070",
|
||||
chroma.NameDecorator: "bold #555",
|
||||
chroma.LiteralString: "bg:#fff0f0",
|
||||
chroma.LiteralStringChar: "#04D bg:",
|
||||
chroma.LiteralStringDoc: "#D42 bg:",
|
||||
chroma.LiteralStringInterpol: "bg:#eee",
|
||||
chroma.LiteralStringEscape: "bold #666",
|
||||
chroma.LiteralStringRegex: "bg:#fff0ff #000",
|
||||
chroma.LiteralStringSymbol: "#A60 bg:",
|
||||
chroma.LiteralStringOther: "#D20",
|
||||
chroma.LiteralNumber: "bold #60E",
|
||||
chroma.LiteralNumberInteger: "bold #00D",
|
||||
chroma.LiteralNumberFloat: "bold #60E",
|
||||
chroma.LiteralNumberHex: "bold #058",
|
||||
chroma.LiteralNumberOct: "bold #40E",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#A00000",
|
||||
chroma.GenericInserted: "#00A000",
|
||||
chroma.GenericError: "#FF0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold #c65d09",
|
||||
chroma.GenericOutput: "#888",
|
||||
chroma.GenericTraceback: "#04D",
|
||||
chroma.Error: "#F00 bg:#FAA",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Dracula Style
|
||||
var Dracula = Register(chroma.MustNewStyle("dracula", chroma.StyleEntries{
|
||||
chroma.Comment: "#6272a4",
|
||||
chroma.CommentHashbang: "#6272a4",
|
||||
chroma.CommentMultiline: "#6272a4",
|
||||
chroma.CommentPreproc: "#ff79c6",
|
||||
chroma.CommentSingle: "#6272a4",
|
||||
chroma.CommentSpecial: "#6272a4",
|
||||
chroma.Generic: "#f8f8f2",
|
||||
chroma.GenericDeleted: "#8b080b",
|
||||
chroma.GenericEmph: "#f8f8f2 underline",
|
||||
chroma.GenericError: "#f8f8f2",
|
||||
chroma.GenericHeading: "#f8f8f2 bold",
|
||||
chroma.GenericInserted: "#f8f8f2 bold",
|
||||
chroma.GenericOutput: "#44475a",
|
||||
chroma.GenericPrompt: "#f8f8f2",
|
||||
chroma.GenericStrong: "#f8f8f2",
|
||||
chroma.GenericSubheading: "#f8f8f2 bold",
|
||||
chroma.GenericTraceback: "#f8f8f2",
|
||||
chroma.Error: "#f8f8f2",
|
||||
chroma.Keyword: "#ff79c6",
|
||||
chroma.KeywordConstant: "#ff79c6",
|
||||
chroma.KeywordDeclaration: "#8be9fd italic",
|
||||
chroma.KeywordNamespace: "#ff79c6",
|
||||
chroma.KeywordPseudo: "#ff79c6",
|
||||
chroma.KeywordReserved: "#ff79c6",
|
||||
chroma.KeywordType: "#8be9fd",
|
||||
chroma.Literal: "#f8f8f2",
|
||||
chroma.LiteralDate: "#f8f8f2",
|
||||
chroma.Name: "#f8f8f2",
|
||||
chroma.NameAttribute: "#50fa7b",
|
||||
chroma.NameBuiltin: "#8be9fd italic",
|
||||
chroma.NameBuiltinPseudo: "#f8f8f2",
|
||||
chroma.NameClass: "#50fa7b",
|
||||
chroma.NameConstant: "#f8f8f2",
|
||||
chroma.NameDecorator: "#f8f8f2",
|
||||
chroma.NameEntity: "#f8f8f2",
|
||||
chroma.NameException: "#f8f8f2",
|
||||
chroma.NameFunction: "#50fa7b",
|
||||
chroma.NameLabel: "#8be9fd italic",
|
||||
chroma.NameNamespace: "#f8f8f2",
|
||||
chroma.NameOther: "#f8f8f2",
|
||||
chroma.NameTag: "#ff79c6",
|
||||
chroma.NameVariable: "#8be9fd italic",
|
||||
chroma.NameVariableClass: "#8be9fd italic",
|
||||
chroma.NameVariableGlobal: "#8be9fd italic",
|
||||
chroma.NameVariableInstance: "#8be9fd italic",
|
||||
chroma.LiteralNumber: "#bd93f9",
|
||||
chroma.LiteralNumberBin: "#bd93f9",
|
||||
chroma.LiteralNumberFloat: "#bd93f9",
|
||||
chroma.LiteralNumberHex: "#bd93f9",
|
||||
chroma.LiteralNumberInteger: "#bd93f9",
|
||||
chroma.LiteralNumberIntegerLong: "#bd93f9",
|
||||
chroma.LiteralNumberOct: "#bd93f9",
|
||||
chroma.Operator: "#ff79c6",
|
||||
chroma.OperatorWord: "#ff79c6",
|
||||
chroma.Other: "#f8f8f2",
|
||||
chroma.Punctuation: "#f8f8f2",
|
||||
chroma.LiteralString: "#f1fa8c",
|
||||
chroma.LiteralStringBacktick: "#f1fa8c",
|
||||
chroma.LiteralStringChar: "#f1fa8c",
|
||||
chroma.LiteralStringDoc: "#f1fa8c",
|
||||
chroma.LiteralStringDouble: "#f1fa8c",
|
||||
chroma.LiteralStringEscape: "#f1fa8c",
|
||||
chroma.LiteralStringHeredoc: "#f1fa8c",
|
||||
chroma.LiteralStringInterpol: "#f1fa8c",
|
||||
chroma.LiteralStringOther: "#f1fa8c",
|
||||
chroma.LiteralStringRegex: "#f1fa8c",
|
||||
chroma.LiteralStringSingle: "#f1fa8c",
|
||||
chroma.LiteralStringSymbol: "#f1fa8c",
|
||||
chroma.Text: "#f8f8f2",
|
||||
chroma.TextWhitespace: "#f8f8f2",
|
||||
chroma.Background: " bg:#282a36",
|
||||
}))
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Emacs style.
|
||||
var Emacs = Register(chroma.MustNewStyle("emacs", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "italic #008800",
|
||||
chroma.CommentPreproc: "noitalic",
|
||||
chroma.CommentSpecial: "noitalic bold",
|
||||
chroma.Keyword: "bold #AA22FF",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.KeywordType: "bold #00BB00",
|
||||
chroma.Operator: "#666666",
|
||||
chroma.OperatorWord: "bold #AA22FF",
|
||||
chroma.NameBuiltin: "#AA22FF",
|
||||
chroma.NameFunction: "#00A000",
|
||||
chroma.NameClass: "#0000FF",
|
||||
chroma.NameNamespace: "bold #0000FF",
|
||||
chroma.NameException: "bold #D2413A",
|
||||
chroma.NameVariable: "#B8860B",
|
||||
chroma.NameConstant: "#880000",
|
||||
chroma.NameLabel: "#A0A000",
|
||||
chroma.NameEntity: "bold #999999",
|
||||
chroma.NameAttribute: "#BB4444",
|
||||
chroma.NameTag: "bold #008000",
|
||||
chroma.NameDecorator: "#AA22FF",
|
||||
chroma.LiteralString: "#BB4444",
|
||||
chroma.LiteralStringDoc: "italic",
|
||||
chroma.LiteralStringInterpol: "bold #BB6688",
|
||||
chroma.LiteralStringEscape: "bold #BB6622",
|
||||
chroma.LiteralStringRegex: "#BB6688",
|
||||
chroma.LiteralStringSymbol: "#B8860B",
|
||||
chroma.LiteralStringOther: "#008000",
|
||||
chroma.LiteralNumber: "#666666",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#A00000",
|
||||
chroma.GenericInserted: "#00A000",
|
||||
chroma.GenericError: "#FF0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold #000080",
|
||||
chroma.GenericOutput: "#888",
|
||||
chroma.GenericTraceback: "#04D",
|
||||
chroma.Error: "border:#FF0000",
|
||||
chroma.Background: " bg:#f8f8f8",
|
||||
}))
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Friendly style.
|
||||
var Friendly = Register(chroma.MustNewStyle("friendly", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "italic #60a0b0",
|
||||
chroma.CommentPreproc: "noitalic #007020",
|
||||
chroma.CommentSpecial: "noitalic bg:#fff0f0",
|
||||
chroma.Keyword: "bold #007020",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.KeywordType: "nobold #902000",
|
||||
chroma.Operator: "#666666",
|
||||
chroma.OperatorWord: "bold #007020",
|
||||
chroma.NameBuiltin: "#007020",
|
||||
chroma.NameFunction: "#06287e",
|
||||
chroma.NameClass: "bold #0e84b5",
|
||||
chroma.NameNamespace: "bold #0e84b5",
|
||||
chroma.NameException: "#007020",
|
||||
chroma.NameVariable: "#bb60d5",
|
||||
chroma.NameConstant: "#60add5",
|
||||
chroma.NameLabel: "bold #002070",
|
||||
chroma.NameEntity: "bold #d55537",
|
||||
chroma.NameAttribute: "#4070a0",
|
||||
chroma.NameTag: "bold #062873",
|
||||
chroma.NameDecorator: "bold #555555",
|
||||
chroma.LiteralString: "#4070a0",
|
||||
chroma.LiteralStringDoc: "italic",
|
||||
chroma.LiteralStringInterpol: "italic #70a0d0",
|
||||
chroma.LiteralStringEscape: "bold #4070a0",
|
||||
chroma.LiteralStringRegex: "#235388",
|
||||
chroma.LiteralStringSymbol: "#517918",
|
||||
chroma.LiteralStringOther: "#c65d09",
|
||||
chroma.LiteralNumber: "#40a070",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#A00000",
|
||||
chroma.GenericInserted: "#00A000",
|
||||
chroma.GenericError: "#FF0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold #c65d09",
|
||||
chroma.GenericOutput: "#888",
|
||||
chroma.GenericTraceback: "#04D",
|
||||
chroma.Error: "border:#FF0000",
|
||||
chroma.Background: " bg:#f0f0f0",
|
||||
}))
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Fruity style.
|
||||
var Fruity = Register(chroma.MustNewStyle("fruity", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#888888",
|
||||
chroma.Background: "#ffffff bg:#111111",
|
||||
chroma.GenericOutput: "#444444 bg:#222222",
|
||||
chroma.Keyword: "#fb660a bold",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.LiteralNumber: "#0086f7 bold",
|
||||
chroma.NameTag: "#fb660a bold",
|
||||
chroma.NameVariable: "#fb660a",
|
||||
chroma.Comment: "#008800 bg:#0f140f italic",
|
||||
chroma.NameAttribute: "#ff0086 bold",
|
||||
chroma.LiteralString: "#0086d2",
|
||||
chroma.NameFunction: "#ff0086 bold",
|
||||
chroma.GenericHeading: "#ffffff bold",
|
||||
chroma.KeywordType: "#cdcaa9 bold",
|
||||
chroma.GenericSubheading: "#ffffff bold",
|
||||
chroma.NameConstant: "#0086d2",
|
||||
chroma.CommentPreproc: "#ff0007 bold",
|
||||
}))
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// GitHub style.
|
||||
var GitHub = Register(chroma.MustNewStyle("github", chroma.StyleEntries{
|
||||
chroma.CommentMultiline: "italic #999988",
|
||||
chroma.CommentPreproc: "bold #999999",
|
||||
chroma.CommentSingle: "italic #999988",
|
||||
chroma.CommentSpecial: "bold italic #999999",
|
||||
chroma.Comment: "italic #999988",
|
||||
chroma.Error: "bg:#e3d2d2 #a61717",
|
||||
chroma.GenericDeleted: "bg:#ffdddd #000000",
|
||||
chroma.GenericEmph: "italic #000000",
|
||||
chroma.GenericError: "#aa0000",
|
||||
chroma.GenericHeading: "#999999",
|
||||
chroma.GenericInserted: "bg:#ddffdd #000000",
|
||||
chroma.GenericOutput: "#888888",
|
||||
chroma.GenericPrompt: "#555555",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericSubheading: "#aaaaaa",
|
||||
chroma.GenericTraceback: "#aa0000",
|
||||
chroma.KeywordType: "bold #445588",
|
||||
chroma.Keyword: "bold #000000",
|
||||
chroma.LiteralNumber: "#009999",
|
||||
chroma.LiteralStringRegex: "#009926",
|
||||
chroma.LiteralStringSymbol: "#990073",
|
||||
chroma.LiteralString: "#d14",
|
||||
chroma.NameAttribute: "#008080",
|
||||
chroma.NameBuiltinPseudo: "#999999",
|
||||
chroma.NameBuiltin: "#0086B3",
|
||||
chroma.NameClass: "bold #445588",
|
||||
chroma.NameConstant: "#008080",
|
||||
chroma.NameDecorator: "bold #3c5d5d",
|
||||
chroma.NameEntity: "#800080",
|
||||
chroma.NameException: "bold #990000",
|
||||
chroma.NameFunction: "bold #990000",
|
||||
chroma.NameLabel: "bold #990000",
|
||||
chroma.NameNamespace: "#555555",
|
||||
chroma.NameTag: "#000080",
|
||||
chroma.NameVariableClass: "#008080",
|
||||
chroma.NameVariableGlobal: "#008080",
|
||||
chroma.NameVariableInstance: "#008080",
|
||||
chroma.NameVariable: "#008080",
|
||||
chroma.Operator: "bold #000000",
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Igor style.
|
||||
var Igor = Register(chroma.MustNewStyle("igor", chroma.StyleEntries{
|
||||
chroma.Comment: "italic #FF0000",
|
||||
chroma.Keyword: "#0000FF",
|
||||
chroma.NameFunction: "#C34E00",
|
||||
chroma.NameDecorator: "#CC00A3",
|
||||
chroma.NameClass: "#007575",
|
||||
chroma.LiteralString: "#009C00",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Lovelace style.
|
||||
var Lovelace = Register(chroma.MustNewStyle("lovelace", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#a89028",
|
||||
chroma.Comment: "italic #888888",
|
||||
chroma.CommentHashbang: "#287088",
|
||||
chroma.CommentMultiline: "#888888",
|
||||
chroma.CommentPreproc: "noitalic #289870",
|
||||
chroma.Keyword: "#2838b0",
|
||||
chroma.KeywordConstant: "italic #444444",
|
||||
chroma.KeywordDeclaration: "italic",
|
||||
chroma.KeywordType: "italic",
|
||||
chroma.Operator: "#666666",
|
||||
chroma.OperatorWord: "#a848a8",
|
||||
chroma.Punctuation: "#888888",
|
||||
chroma.NameAttribute: "#388038",
|
||||
chroma.NameBuiltin: "#388038",
|
||||
chroma.NameBuiltinPseudo: "italic",
|
||||
chroma.NameClass: "#287088",
|
||||
chroma.NameConstant: "#b85820",
|
||||
chroma.NameDecorator: "#287088",
|
||||
chroma.NameEntity: "#709030",
|
||||
chroma.NameException: "#908828",
|
||||
chroma.NameFunction: "#785840",
|
||||
chroma.NameFunctionMagic: "#b85820",
|
||||
chroma.NameLabel: "#289870",
|
||||
chroma.NameNamespace: "#289870",
|
||||
chroma.NameTag: "#2838b0",
|
||||
chroma.NameVariable: "#b04040",
|
||||
chroma.NameVariableGlobal: "#908828",
|
||||
chroma.NameVariableMagic: "#b85820",
|
||||
chroma.LiteralString: "#b83838",
|
||||
chroma.LiteralStringAffix: "#444444",
|
||||
chroma.LiteralStringChar: "#a848a8",
|
||||
chroma.LiteralStringDelimiter: "#b85820",
|
||||
chroma.LiteralStringDoc: "italic #b85820",
|
||||
chroma.LiteralStringEscape: "#709030",
|
||||
chroma.LiteralStringInterpol: "underline",
|
||||
chroma.LiteralStringOther: "#a848a8",
|
||||
chroma.LiteralStringRegex: "#a848a8",
|
||||
chroma.LiteralNumber: "#444444",
|
||||
chroma.GenericDeleted: "#c02828",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericError: "#c02828",
|
||||
chroma.GenericHeading: "#666666",
|
||||
chroma.GenericSubheading: "#444444",
|
||||
chroma.GenericInserted: "#388038",
|
||||
chroma.GenericOutput: "#666666",
|
||||
chroma.GenericPrompt: "#444444",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericTraceback: "#2838b0",
|
||||
chroma.Error: "bg:#a848a8",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Manni style.
|
||||
var Manni = Register(chroma.MustNewStyle("manni", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "italic #0099FF",
|
||||
chroma.CommentPreproc: "noitalic #009999",
|
||||
chroma.CommentSpecial: "bold",
|
||||
chroma.Keyword: "bold #006699",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.KeywordType: "#007788",
|
||||
chroma.Operator: "#555555",
|
||||
chroma.OperatorWord: "bold #000000",
|
||||
chroma.NameBuiltin: "#336666",
|
||||
chroma.NameFunction: "#CC00FF",
|
||||
chroma.NameClass: "bold #00AA88",
|
||||
chroma.NameNamespace: "bold #00CCFF",
|
||||
chroma.NameException: "bold #CC0000",
|
||||
chroma.NameVariable: "#003333",
|
||||
chroma.NameConstant: "#336600",
|
||||
chroma.NameLabel: "#9999FF",
|
||||
chroma.NameEntity: "bold #999999",
|
||||
chroma.NameAttribute: "#330099",
|
||||
chroma.NameTag: "bold #330099",
|
||||
chroma.NameDecorator: "#9999FF",
|
||||
chroma.LiteralString: "#CC3300",
|
||||
chroma.LiteralStringDoc: "italic",
|
||||
chroma.LiteralStringInterpol: "#AA0000",
|
||||
chroma.LiteralStringEscape: "bold #CC3300",
|
||||
chroma.LiteralStringRegex: "#33AAAA",
|
||||
chroma.LiteralStringSymbol: "#FFCC33",
|
||||
chroma.LiteralStringOther: "#CC3300",
|
||||
chroma.LiteralNumber: "#FF6600",
|
||||
chroma.GenericHeading: "bold #003300",
|
||||
chroma.GenericSubheading: "bold #003300",
|
||||
chroma.GenericDeleted: "border:#CC0000 bg:#FFCCCC",
|
||||
chroma.GenericInserted: "border:#00CC00 bg:#CCFFCC",
|
||||
chroma.GenericError: "#FF0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold #000099",
|
||||
chroma.GenericOutput: "#AAAAAA",
|
||||
chroma.GenericTraceback: "#99CC66",
|
||||
chroma.Error: "bg:#FFAAAA #AA0000",
|
||||
chroma.Background: " bg:#f0f3f3",
|
||||
}))
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Monokai style.
|
||||
var Monokai = Register(chroma.MustNewStyle("monokai", chroma.StyleEntries{
|
||||
chroma.Text: "#f8f8f2",
|
||||
chroma.Error: "#960050 bg:#1e0010",
|
||||
chroma.Comment: "#75715e",
|
||||
chroma.Keyword: "#66d9ef",
|
||||
chroma.KeywordNamespace: "#f92672",
|
||||
chroma.Operator: "#f92672",
|
||||
chroma.Punctuation: "#f8f8f2",
|
||||
chroma.Name: "#f8f8f2",
|
||||
chroma.NameAttribute: "#a6e22e",
|
||||
chroma.NameClass: "#a6e22e",
|
||||
chroma.NameConstant: "#66d9ef",
|
||||
chroma.NameDecorator: "#a6e22e",
|
||||
chroma.NameException: "#a6e22e",
|
||||
chroma.NameFunction: "#a6e22e",
|
||||
chroma.NameOther: "#a6e22e",
|
||||
chroma.NameTag: "#f92672",
|
||||
chroma.LiteralNumber: "#ae81ff",
|
||||
chroma.Literal: "#ae81ff",
|
||||
chroma.LiteralDate: "#e6db74",
|
||||
chroma.LiteralString: "#e6db74",
|
||||
chroma.LiteralStringEscape: "#ae81ff",
|
||||
chroma.GenericDeleted: "#f92672",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericInserted: "#a6e22e",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericSubheading: "#75715e",
|
||||
chroma.Background: "bg:#272822",
|
||||
}))
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// MonokaiLight style.
|
||||
var MonokaiLight = Register(chroma.MustNewStyle("monokailight", chroma.StyleEntries{
|
||||
chroma.Text: "#272822",
|
||||
chroma.Error: "#960050 bg:#1e0010",
|
||||
chroma.Comment: "#75715e",
|
||||
chroma.Keyword: "#00a8c8",
|
||||
chroma.KeywordNamespace: "#f92672",
|
||||
chroma.Operator: "#f92672",
|
||||
chroma.Punctuation: "#111111",
|
||||
chroma.Name: "#111111",
|
||||
chroma.NameAttribute: "#75af00",
|
||||
chroma.NameClass: "#75af00",
|
||||
chroma.NameConstant: "#00a8c8",
|
||||
chroma.NameDecorator: "#75af00",
|
||||
chroma.NameException: "#75af00",
|
||||
chroma.NameFunction: "#75af00",
|
||||
chroma.NameOther: "#75af00",
|
||||
chroma.NameTag: "#f92672",
|
||||
chroma.LiteralNumber: "#ae81ff",
|
||||
chroma.Literal: "#ae81ff",
|
||||
chroma.LiteralDate: "#d88200",
|
||||
chroma.LiteralString: "#d88200",
|
||||
chroma.LiteralStringEscape: "#8045FF",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.Background: " bg:#fafafa",
|
||||
}))
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Murphy style.
|
||||
var Murphy = Register(chroma.MustNewStyle("murphy", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "#666 italic",
|
||||
chroma.CommentPreproc: "#579 noitalic",
|
||||
chroma.CommentSpecial: "#c00 bold",
|
||||
chroma.Keyword: "bold #289",
|
||||
chroma.KeywordPseudo: "#08f",
|
||||
chroma.KeywordType: "#66f",
|
||||
chroma.Operator: "#333",
|
||||
chroma.OperatorWord: "bold #000",
|
||||
chroma.NameBuiltin: "#072",
|
||||
chroma.NameFunction: "bold #5ed",
|
||||
chroma.NameClass: "bold #e9e",
|
||||
chroma.NameNamespace: "bold #0e84b5",
|
||||
chroma.NameException: "bold #F00",
|
||||
chroma.NameVariable: "#036",
|
||||
chroma.NameVariableInstance: "#aaf",
|
||||
chroma.NameVariableClass: "#ccf",
|
||||
chroma.NameVariableGlobal: "#f84",
|
||||
chroma.NameConstant: "bold #5ed",
|
||||
chroma.NameLabel: "bold #970",
|
||||
chroma.NameEntity: "#800",
|
||||
chroma.NameAttribute: "#007",
|
||||
chroma.NameTag: "#070",
|
||||
chroma.NameDecorator: "bold #555",
|
||||
chroma.LiteralString: "bg:#e0e0ff",
|
||||
chroma.LiteralStringChar: "#88F bg:",
|
||||
chroma.LiteralStringDoc: "#D42 bg:",
|
||||
chroma.LiteralStringInterpol: "bg:#eee",
|
||||
chroma.LiteralStringEscape: "bold #666",
|
||||
chroma.LiteralStringRegex: "bg:#e0e0ff #000",
|
||||
chroma.LiteralStringSymbol: "#fc8 bg:",
|
||||
chroma.LiteralStringOther: "#f88",
|
||||
chroma.LiteralNumber: "bold #60E",
|
||||
chroma.LiteralNumberInteger: "bold #66f",
|
||||
chroma.LiteralNumberFloat: "bold #60E",
|
||||
chroma.LiteralNumberHex: "bold #058",
|
||||
chroma.LiteralNumberOct: "bold #40E",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#A00000",
|
||||
chroma.GenericInserted: "#00A000",
|
||||
chroma.GenericError: "#FF0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold #c65d09",
|
||||
chroma.GenericOutput: "#888",
|
||||
chroma.GenericTraceback: "#04D",
|
||||
chroma.Error: "#F00 bg:#FAA",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Native style.
|
||||
var Native = Register(chroma.MustNewStyle("native", chroma.StyleEntries{
|
||||
chroma.Background: "#d0d0d0 bg:#202020",
|
||||
chroma.TextWhitespace: "#666666",
|
||||
chroma.Comment: "italic #999999",
|
||||
chroma.CommentPreproc: "noitalic bold #cd2828",
|
||||
chroma.CommentSpecial: "noitalic bold #e50808 bg:#520000",
|
||||
chroma.Keyword: "bold #6ab825",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.OperatorWord: "bold #6ab825",
|
||||
chroma.LiteralString: "#ed9d13",
|
||||
chroma.LiteralStringOther: "#ffa500",
|
||||
chroma.LiteralNumber: "#3677a9",
|
||||
chroma.NameBuiltin: "#24909d",
|
||||
chroma.NameVariable: "#40ffff",
|
||||
chroma.NameConstant: "#40ffff",
|
||||
chroma.NameClass: "underline #447fcf",
|
||||
chroma.NameFunction: "#447fcf",
|
||||
chroma.NameNamespace: "underline #447fcf",
|
||||
chroma.NameException: "#bbbbbb",
|
||||
chroma.NameTag: "bold #6ab825",
|
||||
chroma.NameAttribute: "#bbbbbb",
|
||||
chroma.NameDecorator: "#ffa500",
|
||||
chroma.GenericHeading: "bold #ffffff",
|
||||
chroma.GenericSubheading: "underline #ffffff",
|
||||
chroma.GenericDeleted: "#d22323",
|
||||
chroma.GenericInserted: "#589819",
|
||||
chroma.GenericError: "#d22323",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "#aaaaaa",
|
||||
chroma.GenericOutput: "#cccccc",
|
||||
chroma.GenericTraceback: "#d22323",
|
||||
chroma.Error: "bg:#e3d2d2 #a61717",
|
||||
}))
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// ParaisoDark style.
|
||||
var ParaisoDark = Register(chroma.MustNewStyle("paraiso-dark", chroma.StyleEntries{
|
||||
chroma.Text: "#e7e9db",
|
||||
chroma.Error: "#ef6155",
|
||||
chroma.Comment: "#776e71",
|
||||
chroma.Keyword: "#815ba4",
|
||||
chroma.KeywordNamespace: "#5bc4bf",
|
||||
chroma.KeywordType: "#fec418",
|
||||
chroma.Operator: "#5bc4bf",
|
||||
chroma.Punctuation: "#e7e9db",
|
||||
chroma.Name: "#e7e9db",
|
||||
chroma.NameAttribute: "#06b6ef",
|
||||
chroma.NameClass: "#fec418",
|
||||
chroma.NameConstant: "#ef6155",
|
||||
chroma.NameDecorator: "#5bc4bf",
|
||||
chroma.NameException: "#ef6155",
|
||||
chroma.NameFunction: "#06b6ef",
|
||||
chroma.NameNamespace: "#fec418",
|
||||
chroma.NameOther: "#06b6ef",
|
||||
chroma.NameTag: "#5bc4bf",
|
||||
chroma.NameVariable: "#ef6155",
|
||||
chroma.LiteralNumber: "#f99b15",
|
||||
chroma.Literal: "#f99b15",
|
||||
chroma.LiteralDate: "#48b685",
|
||||
chroma.LiteralString: "#48b685",
|
||||
chroma.LiteralStringChar: "#e7e9db",
|
||||
chroma.LiteralStringDoc: "#776e71",
|
||||
chroma.LiteralStringEscape: "#f99b15",
|
||||
chroma.LiteralStringInterpol: "#f99b15",
|
||||
chroma.GenericDeleted: "#ef6155",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericHeading: "bold #e7e9db",
|
||||
chroma.GenericInserted: "#48b685",
|
||||
chroma.GenericPrompt: "bold #776e71",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericSubheading: "bold #5bc4bf",
|
||||
chroma.Background: "bg:#2f1e2e",
|
||||
}))
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// ParaisoLight style.
|
||||
var ParaisoLight = Register(chroma.MustNewStyle("paraiso-light", chroma.StyleEntries{
|
||||
chroma.Text: "#2f1e2e",
|
||||
chroma.Error: "#ef6155",
|
||||
chroma.Comment: "#8d8687",
|
||||
chroma.Keyword: "#815ba4",
|
||||
chroma.KeywordNamespace: "#5bc4bf",
|
||||
chroma.KeywordType: "#fec418",
|
||||
chroma.Operator: "#5bc4bf",
|
||||
chroma.Punctuation: "#2f1e2e",
|
||||
chroma.Name: "#2f1e2e",
|
||||
chroma.NameAttribute: "#06b6ef",
|
||||
chroma.NameClass: "#fec418",
|
||||
chroma.NameConstant: "#ef6155",
|
||||
chroma.NameDecorator: "#5bc4bf",
|
||||
chroma.NameException: "#ef6155",
|
||||
chroma.NameFunction: "#06b6ef",
|
||||
chroma.NameNamespace: "#fec418",
|
||||
chroma.NameOther: "#06b6ef",
|
||||
chroma.NameTag: "#5bc4bf",
|
||||
chroma.NameVariable: "#ef6155",
|
||||
chroma.LiteralNumber: "#f99b15",
|
||||
chroma.Literal: "#f99b15",
|
||||
chroma.LiteralDate: "#48b685",
|
||||
chroma.LiteralString: "#48b685",
|
||||
chroma.LiteralStringChar: "#2f1e2e",
|
||||
chroma.LiteralStringDoc: "#8d8687",
|
||||
chroma.LiteralStringEscape: "#f99b15",
|
||||
chroma.LiteralStringInterpol: "#f99b15",
|
||||
chroma.GenericDeleted: "#ef6155",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericHeading: "bold #2f1e2e",
|
||||
chroma.GenericInserted: "#48b685",
|
||||
chroma.GenericPrompt: "bold #8d8687",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericSubheading: "bold #5bc4bf",
|
||||
chroma.Background: "bg:#e7e9db",
|
||||
}))
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Pastie style.
|
||||
var Pastie = Register(chroma.MustNewStyle("pastie", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "#888888",
|
||||
chroma.CommentPreproc: "bold #cc0000",
|
||||
chroma.CommentSpecial: "bg:#fff0f0 bold #cc0000",
|
||||
chroma.LiteralString: "bg:#fff0f0 #dd2200",
|
||||
chroma.LiteralStringRegex: "bg:#fff0ff #008800",
|
||||
chroma.LiteralStringOther: "bg:#f0fff0 #22bb22",
|
||||
chroma.LiteralStringSymbol: "#aa6600",
|
||||
chroma.LiteralStringInterpol: "#3333bb",
|
||||
chroma.LiteralStringEscape: "#0044dd",
|
||||
chroma.OperatorWord: "#008800",
|
||||
chroma.Keyword: "bold #008800",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.KeywordType: "#888888",
|
||||
chroma.NameClass: "bold #bb0066",
|
||||
chroma.NameException: "bold #bb0066",
|
||||
chroma.NameFunction: "bold #0066bb",
|
||||
chroma.NameProperty: "bold #336699",
|
||||
chroma.NameNamespace: "bold #bb0066",
|
||||
chroma.NameBuiltin: "#003388",
|
||||
chroma.NameVariable: "#336699",
|
||||
chroma.NameVariableClass: "#336699",
|
||||
chroma.NameVariableInstance: "#3333bb",
|
||||
chroma.NameVariableGlobal: "#dd7700",
|
||||
chroma.NameConstant: "bold #003366",
|
||||
chroma.NameTag: "bold #bb0066",
|
||||
chroma.NameAttribute: "#336699",
|
||||
chroma.NameDecorator: "#555555",
|
||||
chroma.NameLabel: "italic #336699",
|
||||
chroma.LiteralNumber: "bold #0000DD",
|
||||
chroma.GenericHeading: "#333",
|
||||
chroma.GenericSubheading: "#666",
|
||||
chroma.GenericDeleted: "bg:#ffdddd #000000",
|
||||
chroma.GenericInserted: "bg:#ddffdd #000000",
|
||||
chroma.GenericError: "#aa0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "#555555",
|
||||
chroma.GenericOutput: "#888888",
|
||||
chroma.GenericTraceback: "#aa0000",
|
||||
chroma.Error: "bg:#e3d2d2 #a61717",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Perldoc style.
|
||||
var Perldoc = Register(chroma.MustNewStyle("perldoc", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "#228B22",
|
||||
chroma.CommentPreproc: "#1e889b",
|
||||
chroma.CommentSpecial: "#8B008B bold",
|
||||
chroma.LiteralString: "#CD5555",
|
||||
chroma.LiteralStringHeredoc: "#1c7e71 italic",
|
||||
chroma.LiteralStringRegex: "#1c7e71",
|
||||
chroma.LiteralStringOther: "#cb6c20",
|
||||
chroma.LiteralNumber: "#B452CD",
|
||||
chroma.OperatorWord: "#8B008B",
|
||||
chroma.Keyword: "#8B008B bold",
|
||||
chroma.KeywordType: "#00688B",
|
||||
chroma.NameClass: "#008b45 bold",
|
||||
chroma.NameException: "#008b45 bold",
|
||||
chroma.NameFunction: "#008b45",
|
||||
chroma.NameNamespace: "#008b45 underline",
|
||||
chroma.NameVariable: "#00688B",
|
||||
chroma.NameConstant: "#00688B",
|
||||
chroma.NameDecorator: "#707a7c",
|
||||
chroma.NameTag: "#8B008B bold",
|
||||
chroma.NameAttribute: "#658b00",
|
||||
chroma.NameBuiltin: "#658b00",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#aa0000",
|
||||
chroma.GenericInserted: "#00aa00",
|
||||
chroma.GenericError: "#aa0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "#555555",
|
||||
chroma.GenericOutput: "#888888",
|
||||
chroma.GenericTraceback: "#aa0000",
|
||||
chroma.Error: "bg:#e3d2d2 #a61717",
|
||||
chroma.Background: " bg:#eeeedd",
|
||||
}))
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Pygments default theme.
|
||||
var Pygments = Register(chroma.MustNewStyle("pygments", map[chroma.TokenType]string{
|
||||
chroma.Whitespace: "#bbbbbb",
|
||||
chroma.Comment: "italic #408080",
|
||||
chroma.CommentPreproc: "noitalic #BC7A00",
|
||||
|
||||
chroma.Keyword: "bold #008000",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.KeywordType: "nobold #B00040",
|
||||
|
||||
chroma.Operator: "#666666",
|
||||
chroma.OperatorWord: "bold #AA22FF",
|
||||
|
||||
chroma.NameBuiltin: "#008000",
|
||||
chroma.NameFunction: "#0000FF",
|
||||
chroma.NameClass: "bold #0000FF",
|
||||
chroma.NameNamespace: "bold #0000FF",
|
||||
chroma.NameException: "bold #D2413A",
|
||||
chroma.NameVariable: "#19177C",
|
||||
chroma.NameConstant: "#880000",
|
||||
chroma.NameLabel: "#A0A000",
|
||||
chroma.NameEntity: "bold #999999",
|
||||
chroma.NameAttribute: "#7D9029",
|
||||
chroma.NameTag: "bold #008000",
|
||||
chroma.NameDecorator: "#AA22FF",
|
||||
|
||||
chroma.String: "#BA2121",
|
||||
chroma.StringDoc: "italic",
|
||||
chroma.StringInterpol: "bold #BB6688",
|
||||
chroma.StringEscape: "bold #BB6622",
|
||||
chroma.StringRegex: "#BB6688",
|
||||
chroma.StringSymbol: "#19177C",
|
||||
chroma.StringOther: "#008000",
|
||||
chroma.Number: "#666666",
|
||||
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#A00000",
|
||||
chroma.GenericInserted: "#00A000",
|
||||
chroma.GenericError: "#FF0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold #000080",
|
||||
chroma.GenericOutput: "#888",
|
||||
chroma.GenericTraceback: "#04D",
|
||||
|
||||
chroma.Error: "border:#FF0000",
|
||||
}))
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// RainbowDash style.
|
||||
var RainbowDash = Register(chroma.MustNewStyle("rainbow_dash", chroma.StyleEntries{
|
||||
chroma.Comment: "italic #0080ff",
|
||||
chroma.CommentPreproc: "noitalic",
|
||||
chroma.CommentSpecial: "bold",
|
||||
chroma.Error: "bg:#cc0000 #ffffff",
|
||||
chroma.GenericDeleted: "border:#c5060b bg:#ffcccc",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericError: "#ff0000",
|
||||
chroma.GenericHeading: "bold #2c5dcd",
|
||||
chroma.GenericInserted: "border:#00cc00 bg:#ccffcc",
|
||||
chroma.GenericOutput: "#aaaaaa",
|
||||
chroma.GenericPrompt: "bold #2c5dcd",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericSubheading: "bold #2c5dcd",
|
||||
chroma.GenericTraceback: "#c5060b",
|
||||
chroma.Keyword: "bold #2c5dcd",
|
||||
chroma.KeywordPseudo: "nobold",
|
||||
chroma.KeywordType: "#5918bb",
|
||||
chroma.NameAttribute: "italic #2c5dcd",
|
||||
chroma.NameBuiltin: "bold #5918bb",
|
||||
chroma.NameClass: "underline",
|
||||
chroma.NameConstant: "#318495",
|
||||
chroma.NameDecorator: "bold #ff8000",
|
||||
chroma.NameEntity: "bold #5918bb",
|
||||
chroma.NameException: "bold #5918bb",
|
||||
chroma.NameFunction: "bold #ff8000",
|
||||
chroma.NameTag: "bold #2c5dcd",
|
||||
chroma.LiteralNumber: "bold #5918bb",
|
||||
chroma.Operator: "#2c5dcd",
|
||||
chroma.OperatorWord: "bold",
|
||||
chroma.LiteralString: "#00cc66",
|
||||
chroma.LiteralStringDoc: "italic",
|
||||
chroma.LiteralStringEscape: "bold #c5060b",
|
||||
chroma.LiteralStringOther: "#318495",
|
||||
chroma.LiteralStringSymbol: "bold #c5060b",
|
||||
chroma.Text: "#4d4d4d",
|
||||
chroma.TextWhitespace: "#cbcbcb",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Rrt style.
|
||||
var Rrt = Register(chroma.MustNewStyle("rrt", chroma.StyleEntries{
|
||||
chroma.Comment: "#00ff00",
|
||||
chroma.NameFunction: "#ffff00",
|
||||
chroma.NameVariable: "#eedd82",
|
||||
chroma.NameConstant: "#7fffd4",
|
||||
chroma.Keyword: "#ff0000",
|
||||
chroma.CommentPreproc: "#e5e5e5",
|
||||
chroma.LiteralString: "#87ceeb",
|
||||
chroma.KeywordType: "#ee82ee",
|
||||
chroma.Background: " bg:#000000",
|
||||
}))
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// SwapOff theme.
|
||||
var SwapOff = Register(chroma.MustNewStyle("swapoff", map[chroma.TokenType]string{
|
||||
chroma.Background: "#lightgray bg:#black",
|
||||
chroma.Number: "bold #ansiyellow",
|
||||
chroma.Comment: "#ansiteal",
|
||||
chroma.CommentPreproc: "bold #ansigreen",
|
||||
chroma.String: "bold #ansiturquoise",
|
||||
chroma.Keyword: "bold #ansiwhite",
|
||||
chroma.NameKeyword: "bold #ansiwhite",
|
||||
chroma.NameBuiltin: "bold #ansiwhite",
|
||||
chroma.GenericHeading: "bold",
|
||||
chroma.GenericSubheading: "bold",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericUnderline: "underline",
|
||||
chroma.NameTag: "bold",
|
||||
chroma.NameAttribute: "#ansiteal",
|
||||
chroma.Error: "#ansired",
|
||||
chroma.LiteralDate: "bold #ansiyellow",
|
||||
}))
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Tango style.
|
||||
var Tango = Register(chroma.MustNewStyle("tango", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "underline #f8f8f8",
|
||||
chroma.Error: "#a40000 border:#ef2929",
|
||||
chroma.Other: "#000000",
|
||||
chroma.Comment: "italic #8f5902",
|
||||
chroma.CommentMultiline: "italic #8f5902",
|
||||
chroma.CommentPreproc: "italic #8f5902",
|
||||
chroma.CommentSingle: "italic #8f5902",
|
||||
chroma.CommentSpecial: "italic #8f5902",
|
||||
chroma.Keyword: "bold #204a87",
|
||||
chroma.KeywordConstant: "bold #204a87",
|
||||
chroma.KeywordDeclaration: "bold #204a87",
|
||||
chroma.KeywordNamespace: "bold #204a87",
|
||||
chroma.KeywordPseudo: "bold #204a87",
|
||||
chroma.KeywordReserved: "bold #204a87",
|
||||
chroma.KeywordType: "bold #204a87",
|
||||
chroma.Operator: "bold #ce5c00",
|
||||
chroma.OperatorWord: "bold #204a87",
|
||||
chroma.Punctuation: "bold #000000",
|
||||
chroma.Name: "#000000",
|
||||
chroma.NameAttribute: "#c4a000",
|
||||
chroma.NameBuiltin: "#204a87",
|
||||
chroma.NameBuiltinPseudo: "#3465a4",
|
||||
chroma.NameClass: "#000000",
|
||||
chroma.NameConstant: "#000000",
|
||||
chroma.NameDecorator: "bold #5c35cc",
|
||||
chroma.NameEntity: "#ce5c00",
|
||||
chroma.NameException: "bold #cc0000",
|
||||
chroma.NameFunction: "#000000",
|
||||
chroma.NameProperty: "#000000",
|
||||
chroma.NameLabel: "#f57900",
|
||||
chroma.NameNamespace: "#000000",
|
||||
chroma.NameOther: "#000000",
|
||||
chroma.NameTag: "bold #204a87",
|
||||
chroma.NameVariable: "#000000",
|
||||
chroma.NameVariableClass: "#000000",
|
||||
chroma.NameVariableGlobal: "#000000",
|
||||
chroma.NameVariableInstance: "#000000",
|
||||
chroma.LiteralNumber: "bold #0000cf",
|
||||
chroma.LiteralNumberFloat: "bold #0000cf",
|
||||
chroma.LiteralNumberHex: "bold #0000cf",
|
||||
chroma.LiteralNumberInteger: "bold #0000cf",
|
||||
chroma.LiteralNumberIntegerLong: "bold #0000cf",
|
||||
chroma.LiteralNumberOct: "bold #0000cf",
|
||||
chroma.Literal: "#000000",
|
||||
chroma.LiteralDate: "#000000",
|
||||
chroma.LiteralString: "#4e9a06",
|
||||
chroma.LiteralStringBacktick: "#4e9a06",
|
||||
chroma.LiteralStringChar: "#4e9a06",
|
||||
chroma.LiteralStringDoc: "italic #8f5902",
|
||||
chroma.LiteralStringDouble: "#4e9a06",
|
||||
chroma.LiteralStringEscape: "#4e9a06",
|
||||
chroma.LiteralStringHeredoc: "#4e9a06",
|
||||
chroma.LiteralStringInterpol: "#4e9a06",
|
||||
chroma.LiteralStringOther: "#4e9a06",
|
||||
chroma.LiteralStringRegex: "#4e9a06",
|
||||
chroma.LiteralStringSingle: "#4e9a06",
|
||||
chroma.LiteralStringSymbol: "#4e9a06",
|
||||
chroma.Generic: "#000000",
|
||||
chroma.GenericDeleted: "#a40000",
|
||||
chroma.GenericEmph: "italic #000000",
|
||||
chroma.GenericError: "#ef2929",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericInserted: "#00A000",
|
||||
chroma.GenericOutput: "italic #000000",
|
||||
chroma.GenericPrompt: "#8f5902",
|
||||
chroma.GenericStrong: "bold #000000",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericTraceback: "bold #a40000",
|
||||
chroma.Background: " bg:#f8f8f8",
|
||||
}))
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Trac style.
|
||||
var Trac = Register(chroma.MustNewStyle("trac", chroma.StyleEntries{
|
||||
chroma.TextWhitespace: "#bbbbbb",
|
||||
chroma.Comment: "italic #999988",
|
||||
chroma.CommentPreproc: "bold noitalic #999999",
|
||||
chroma.CommentSpecial: "bold #999999",
|
||||
chroma.Operator: "bold",
|
||||
chroma.LiteralString: "#bb8844",
|
||||
chroma.LiteralStringRegex: "#808000",
|
||||
chroma.LiteralNumber: "#009999",
|
||||
chroma.Keyword: "bold",
|
||||
chroma.KeywordType: "#445588",
|
||||
chroma.NameBuiltin: "#999999",
|
||||
chroma.NameFunction: "bold #990000",
|
||||
chroma.NameClass: "bold #445588",
|
||||
chroma.NameException: "bold #990000",
|
||||
chroma.NameNamespace: "#555555",
|
||||
chroma.NameVariable: "#008080",
|
||||
chroma.NameConstant: "#008080",
|
||||
chroma.NameTag: "#000080",
|
||||
chroma.NameAttribute: "#008080",
|
||||
chroma.NameEntity: "#800080",
|
||||
chroma.GenericHeading: "#999999",
|
||||
chroma.GenericSubheading: "#aaaaaa",
|
||||
chroma.GenericDeleted: "bg:#ffdddd #000000",
|
||||
chroma.GenericInserted: "bg:#ddffdd #000000",
|
||||
chroma.GenericError: "#aa0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "#555555",
|
||||
chroma.GenericOutput: "#888888",
|
||||
chroma.GenericTraceback: "#aa0000",
|
||||
chroma.Error: "bg:#e3d2d2 #a61717",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Vim style.
|
||||
var Vim = Register(chroma.MustNewStyle("vim", chroma.StyleEntries{
|
||||
chroma.Background: "#cccccc bg:#000000",
|
||||
chroma.Comment: "#000080",
|
||||
chroma.CommentSpecial: "bold #cd0000",
|
||||
chroma.Keyword: "#cdcd00",
|
||||
chroma.KeywordDeclaration: "#00cd00",
|
||||
chroma.KeywordNamespace: "#cd00cd",
|
||||
chroma.KeywordType: "#00cd00",
|
||||
chroma.Operator: "#3399cc",
|
||||
chroma.OperatorWord: "#cdcd00",
|
||||
chroma.NameClass: "#00cdcd",
|
||||
chroma.NameBuiltin: "#cd00cd",
|
||||
chroma.NameException: "bold #666699",
|
||||
chroma.NameVariable: "#00cdcd",
|
||||
chroma.LiteralString: "#cd0000",
|
||||
chroma.LiteralNumber: "#cd00cd",
|
||||
chroma.GenericHeading: "bold #000080",
|
||||
chroma.GenericSubheading: "bold #800080",
|
||||
chroma.GenericDeleted: "#cd0000",
|
||||
chroma.GenericInserted: "#00cd00",
|
||||
chroma.GenericError: "#FF0000",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold #000080",
|
||||
chroma.GenericOutput: "#888",
|
||||
chroma.GenericTraceback: "#04D",
|
||||
chroma.Error: "border:#FF0000",
|
||||
}))
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// VisualStudio style.
|
||||
var VisualStudio = Register(chroma.MustNewStyle("vs", chroma.StyleEntries{
|
||||
chroma.Comment: "#008000",
|
||||
chroma.CommentPreproc: "#0000ff",
|
||||
chroma.Keyword: "#0000ff",
|
||||
chroma.OperatorWord: "#0000ff",
|
||||
chroma.KeywordType: "#2b91af",
|
||||
chroma.NameClass: "#2b91af",
|
||||
chroma.LiteralString: "#a31515",
|
||||
chroma.GenericHeading: "bold",
|
||||
chroma.GenericSubheading: "bold",
|
||||
chroma.GenericEmph: "italic",
|
||||
chroma.GenericStrong: "bold",
|
||||
chroma.GenericPrompt: "bold",
|
||||
chroma.Error: "border:#FF0000",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
package styles
|
||||
|
||||
import (
|
||||
"github.com/alecthomas/chroma"
|
||||
)
|
||||
|
||||
// Xcode style.
|
||||
var Xcode = Register(chroma.MustNewStyle("xcode", chroma.StyleEntries{
|
||||
chroma.Comment: "#177500",
|
||||
chroma.CommentPreproc: "#633820",
|
||||
chroma.LiteralString: "#C41A16",
|
||||
chroma.LiteralStringChar: "#2300CE",
|
||||
chroma.Operator: "#000000",
|
||||
chroma.Keyword: "#A90D91",
|
||||
chroma.Name: "#000000",
|
||||
chroma.NameAttribute: "#836C28",
|
||||
chroma.NameClass: "#3F6E75",
|
||||
chroma.NameFunction: "#000000",
|
||||
chroma.NameBuiltin: "#A90D91",
|
||||
chroma.NameBuiltinPseudo: "#5B269A",
|
||||
chroma.NameVariable: "#000000",
|
||||
chroma.NameTag: "#000000",
|
||||
chroma.NameDecorator: "#000000",
|
||||
chroma.NameLabel: "#000000",
|
||||
chroma.Literal: "#1C01CE",
|
||||
chroma.LiteralNumber: "#1C01CE",
|
||||
chroma.Error: "#000000",
|
||||
chroma.Background: " bg:#ffffff",
|
||||
}))
|
||||
Loading…
Reference in New Issue