func (s *Scheme) Errorln(v ...interface{}) {
	s.Styles["error"].Println(v...)
}
Errorln message print
package color
import (
	"fmt"
	"strings"
)
type Style []Color
func New(colors ...Color) Style {
	return colors
}
func (s Style) Save(name string) {
	AddStyle(name, s)
}
func (s *Style) Add(cs ...Color) {
	*s = append(*s, cs...)
}
func (s Style) Render(a ...interface{}) string {
	return RenderCode(s.String(), a...)
}
func (s Style) Renderln(a ...interface{}) string {
	return RenderWithSpaces(s.String(), a...)
}
func (s Style) Sprint(a ...interface{}) string {
	return RenderCode(s.String(), a...)
}
func (s Style) Sprintf(format string, a ...interface{}) string {
	return RenderString(s.String(), fmt.Sprintf(format, a...))
}
func (s Style) Print(a ...interface{}) {
	doPrintV2(s.String(), fmt.Sprint(a...))
}
func (s Style) Printf(format string, a ...interface{}) {
	doPrintV2(s.Code(), fmt.Sprintf(format, a...))
}
func (s Style) Println(a ...interface{}) {
	doPrintlnV2(s.String(), a)
}
func (s Style) Code() string {
	return s.String()
}
func (s Style) String() string {
	return Colors2code(s...)
}
func (s Style) IsEmpty() bool {
	return len(s) == 0
}
type Theme struct {
	Name string
	Style
}
func NewTheme(name string, style Style) *Theme {
	return &Theme{name, style}
}
func (t *Theme) Save() {
	AddTheme(t.Name, t.Style)
}
func (t *Theme) Tips(format string, a ...interface{}) {
	t.Print(strings.ToUpper(t.Name) + ": ")
	Printf(format+"\n", a...)
}
func (t *Theme) Prompt(format string, a ...interface{}) {
	title := strings.ToUpper(t.Name) + ":"
	t.Println(title, fmt.Sprintf(format, a...))
}
func (t *Theme) Block(format string, a ...interface{}) {
	title := strings.ToUpper(t.Name) + ":\n"
	t.Println(title, fmt.Sprintf(format, a...))
}
var (
	Info = &Theme{"info", Style{OpReset, FgGreen}}
	Note = &Theme{"note", Style{OpBold, FgLightCyan}}
	Warn = &Theme{"warning", Style{OpBold, FgYellow}}
	Light = &Theme{"light", Style{FgLightWhite, BgBlack}}
	Error = &Theme{"error", Style{FgLightWhite, BgRed}}
	Danger = &Theme{"danger", Style{OpBold, FgRed}}
	Debug = &Theme{"debug", Style{OpReset, FgCyan}}
	Notice = &Theme{"notice", Style{OpBold, FgCyan}}
	Comment = &Theme{"comment", Style{OpReset, FgYellow}}
	Success = &Theme{"success", Style{OpBold, FgGreen}}
	Primary = &Theme{"primary", Style{OpReset, FgBlue}}
	Question = &Theme{"question", Style{OpReset, FgMagenta}}
	Secondary = &Theme{"secondary", Style{FgDarkGray}}
)
var Themes = map[string]*Theme{
	"info":  Info,
	"note":  Note,
	"light": Light,
	"error": Error,
	"debug":   Debug,
	"danger":  Danger,
	"notice":  Notice,
	"success": Success,
	"comment": Comment,
	"primary": Primary,
	"warning": Warn,
	"question":  Question,
	"secondary": Secondary,
}
func AddTheme(name string, style Style) {
	Themes[name] = NewTheme(name, style)
	Styles[name] = style
}
func GetTheme(name string) *Theme {
	return Themes[name]
}
var Styles = map[string]Style{
	"info":  {OpReset, FgGreen},
	"note":  {OpBold, FgLightCyan},
	"light": {FgLightWhite, BgRed},
	"error": {FgLightWhite, BgRed},
	"danger":  {OpBold, FgRed},
	"notice":  {OpBold, FgCyan},
	"success": {OpBold, FgGreen},
	"comment": {OpReset, FgMagenta},
	"primary": {OpReset, FgBlue},
	"warning": {OpBold, FgYellow},
	"question":  {OpReset, FgMagenta},
	"secondary": {FgDarkGray},
}
var styleAliases = map[string]string{
	"err":  "error",
	"suc":  "success",
	"warn": "warning",
}
func AddStyle(name string, s Style) {
	Styles[name] = s
}
func GetStyle(name string) Style {
	if s, ok := Styles[name]; ok {
		return s
	}
	if realName, ok := styleAliases[name]; ok {
		return Styles[realName]
	}
	return New()
}
type Scheme struct {
	Name   string
	Styles map[string]Style
}
func NewScheme(name string, styles map[string]Style) *Scheme {
	return &Scheme{Name: name, Styles: styles}
}
func NewDefaultScheme(name string) *Scheme {
	return NewScheme(name, map[string]Style{
		"info":  {OpReset, FgGreen},
		"warn":  {OpBold, FgYellow},
		"error": {FgLightWhite, BgRed},
	})
}
func (s *Scheme) Style(name string) Style {
	return s.Styles[name]
}
func (s *Scheme) Infof(format string, a ...interface{}) {
	s.Styles["info"].Printf(format, a...)
}
func (s *Scheme) Infoln(v ...interface{}) {
	s.Styles["info"].Println(v...)
}
func (s *Scheme) Warnf(format string, a ...interface{}) {
	s.Styles["warn"].Printf(format, a...)
}
func (s *Scheme) Warnln(v ...interface{}) {
	s.Styles["warn"].Println(v...)
}
func (s *Scheme) Errorf(format string, a ...interface{}) {
	s.Styles["error"].Printf(format, a...)
}