test: updated colorscheme related tests. tested loader

Now we can load them in via JSON files at launch time. They are embded
in the final exe though...

cmd/theme-loader/main.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+
+	"git.gophernest.net/azpect/TextEditor/internal/theme"
+)
+
+func main() {
+	themes, err := theme.LoadEmbeddedThemesJSON()
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("%+v\n", themes)
+
+	names := make([]string, 0, len(themes))
+	for name := range themes {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	fmt.Printf("loaded %d embedded themes:\n", len(names))
+	for _, name := range names {
+		fmt.Printf("- %s\n", name)
+	}
+}

internal/action/interface.go

@@ -54,8 +54,14 @@ type Model interface {
 
 	Settings() core.EditorSettings
 	SetSettings(s core.EditorSettings)
-	Theme() theme.EditorTheme
+
-	SetTheme(t theme.EditorTheme)
+	// ==================================================
+	// Themes
+	// ==================================================
+	Theme() (string, theme.EditorTheme)
+	SetTheme(name string)
+	Themes() map[string]theme.EditorTheme
+	SetThemes(t map[string]theme.EditorTheme)
 
 	// ==================================================
 	// Registers

internal/action/mock.go

@@ -23,7 +23,8 @@ type MockModel struct {
 	CommandHistoryList []string
 	CommandHistoryCur  int
 	LastFindVal        core.LastFindCommand
-	ThemeVal           theme.EditorTheme
+	CurrentThemeName   string
+	ThemesMap          map[string]theme.EditorTheme
 	LastChangeKeysList []string
 }
 
@@ -40,12 +41,14 @@ func NewMockModel() *MockModel {
 		Build()
 
 	return &MockModel{
-		WindowsList:     []*core.Window{&win},
+		WindowsList:      []*core.Window{&win},
-		ActiveWindowVal: &win,
+		ActiveWindowVal:  &win,
-		BuffersList:     []*core.Buffer{&buf},
+		BuffersList:      []*core.Buffer{&buf},
-		SettingsVal:     core.NewDefaultSettings(),
+		SettingsVal:      core.NewDefaultSettings(),
-		ModeVal:         core.NormalMode,
+		ModeVal:          core.NormalMode,
-		RegistersMap:    core.DefaultRegisters(),
+		RegistersMap:     core.DefaultRegisters(),
+		CurrentThemeName: "default",
+		ThemesMap:        map[string]theme.EditorTheme{"default": {}},
 	}
 }
 
@@ -58,24 +61,28 @@ func NewMockModelWithBuffer(buf *core.Buffer) *MockModel {
 		Build()
 
 	return &MockModel{
-		WindowsList:     []*core.Window{&win},
+		WindowsList:      []*core.Window{&win},
-		ActiveWindowVal: &win,
+		ActiveWindowVal:  &win,
-		BuffersList:     []*core.Buffer{buf},
+		BuffersList:      []*core.Buffer{buf},
-		SettingsVal:     core.NewDefaultSettings(),
+		SettingsVal:      core.NewDefaultSettings(),
-		ModeVal:         core.NormalMode,
+		ModeVal:          core.NormalMode,
-		RegistersMap:    core.DefaultRegisters(),
+		RegistersMap:     core.DefaultRegisters(),
+		CurrentThemeName: "default",
+		ThemesMap:        map[string]theme.EditorTheme{"default": {}},
 	}
 }
 
 // NewMockModelWithWindow creates a mock with a custom window.
 func NewMockModelWithWindow(win *core.Window) *MockModel {
 	return &MockModel{
-		WindowsList:     []*core.Window{win},
+		WindowsList:      []*core.Window{win},
-		ActiveWindowVal: win,
+		ActiveWindowVal:  win,
-		BuffersList:     []*core.Buffer{win.Buffer},
+		BuffersList:      []*core.Buffer{win.Buffer},
-		SettingsVal:     core.NewDefaultSettings(),
+		SettingsVal:      core.NewDefaultSettings(),
-		ModeVal:         core.NormalMode,
+		ModeVal:          core.NormalMode,
-		RegistersMap:    core.DefaultRegisters(),
+		RegistersMap:     core.DefaultRegisters(),
+		CurrentThemeName: "default",
+		ThemesMap:        map[string]theme.EditorTheme{"default": {}},
 	}
 }
 
@@ -117,8 +124,26 @@ func (m *MockModel) Mode() core.Mode                   { return m.ModeVal }
 func (m *MockModel) SetMode(mode core.Mode)            { m.ModeVal = mode }
 func (m *MockModel) Settings() core.EditorSettings     { return m.SettingsVal }
 func (m *MockModel) SetSettings(s core.EditorSettings) { m.SettingsVal = s }
-func (m *MockModel) Theme() theme.EditorTheme          { return m.ThemeVal }
+func (m *MockModel) Theme() (string, theme.EditorTheme) {
-func (m *MockModel) SetTheme(t theme.EditorTheme)      { m.ThemeVal = t }
+	if m.ThemesMap != nil {
+		if t, ok := m.ThemesMap[m.CurrentThemeName]; ok {
+			return m.CurrentThemeName, t
+		}
+		if t, ok := m.ThemesMap["default"]; ok {
+			return "default", t
+		}
+	}
+
+	return m.CurrentThemeName, theme.EditorTheme{}
+}
+func (m *MockModel) SetTheme(name string) { m.CurrentThemeName = name }
+func (m *MockModel) Themes() map[string]theme.EditorTheme {
+	if m.ThemesMap == nil {
+		m.ThemesMap = map[string]theme.EditorTheme{}
+	}
+	return m.ThemesMap
+}
+func (m *MockModel) SetThemes(t map[string]theme.EditorTheme) { m.ThemesMap = t }
 
 // Registers
 func (m *MockModel) Registers() map[rune]core.Register { return m.RegistersMap }

internal/command/handlers.go

@@ -887,8 +887,9 @@ func cmdColorscheme(m action.Model, args []string, force bool) tea.Cmd {
 
 	// No args, just print the current scheme
 	if len(args) == 0 {
+		name, _ := m.Theme()
 		m.SetCommandOutput(&core.CommandOutput{
-			Lines:   []string{"default"},
+			Lines:   []string{name},
 			Inline:  true,
 			IsError: false,
 		})
@@ -897,15 +898,9 @@ func cmdColorscheme(m action.Model, args []string, force bool) tea.Cmd {
 
 	// Theme switching is disabled while migrating away from Chroma.
 	name := strings.TrimSpace(strings.Join(args, " "))
-	if name == "" {
+	_, found := m.Themes()[name]
-		m.SetCommandOutput(&core.CommandOutput{
+
-			Lines:   []string{"colorscheme not found: "},
+	if name == "" || !found {
-			Inline:  true,
-			IsError: true,
-		})
-		return nil
-	}
-	if name != "" && strings.ToLower(name) != "default" {
 		m.SetCommandOutput(&core.CommandOutput{
 			Lines:   []string{fmt.Sprintf("colorscheme not found: %s", name)},
 			Inline:  true,
@@ -914,14 +909,19 @@ func cmdColorscheme(m action.Model, args []string, force bool) tea.Cmd {
 		return nil
 	}
 
-	// m.SetStyles(style.DefaultStyles())
+	m.SetTheme(name)
 	return nil
 }
 
 func cmdListColorschemes(m action.Model, args []string, force bool) tea.Cmd {
 	_, _ = args, force
 
-	colors := []string{"default"}
+	var colors []string
+	for k := range m.Themes() {
+		colors = append(colors, k)
+	}
+
+	slices.Sort(colors)
 
 	m.SetMode(core.CommandOutputMode)
 	m.SetCommandOutput(&core.CommandOutput{

internal/command/handlers_test.go

@@ -9,6 +9,7 @@ import (
 
 	"git.gophernest.net/azpect/TextEditor/internal/action"
 	"git.gophernest.net/azpect/TextEditor/internal/core"
+	"git.gophernest.net/azpect/TextEditor/internal/theme"
 	tea "github.com/charmbracelet/bubbletea"
 )
 
@@ -5506,6 +5507,12 @@ func TestCmdDeleteBuffer(t *testing.T) {
 // ==================================================
 
 func TestCmdColorscheme(t *testing.T) {
+	pickTheme := func(m *action.MockModel) string {
+		for name := range m.Themes() {
+			return name
+		}
+		return ""
+	}
 
 	// --------------------------------------------------
 	// Group 1: Valid name — styles are updated
@@ -5540,8 +5547,12 @@ func TestCmdColorscheme(t *testing.T) {
 
 	t.Run("valid name sets no error output", func(t *testing.T) {
 		m := action.NewMockModel()
+		name := pickTheme(m)
+		if name == "" {
+			t.Fatal("expected at least one theme in mock")
+		}
 
-		cmdColorscheme(m, []string{"default"}, false)
+		cmdColorscheme(m, []string{name}, false)
 
 		if m.CommandOutputVal != nil && m.CommandOutputVal.IsError {
 			t.Error("expected no error output for a valid colorscheme name")
@@ -5550,8 +5561,12 @@ func TestCmdColorscheme(t *testing.T) {
 
 	t.Run("valid name returns nil tea.Cmd", func(t *testing.T) {
 		m := action.NewMockModel()
+		name := pickTheme(m)
+		if name == "" {
+			t.Fatal("expected at least one theme in mock")
+		}
 
-		cmd := cmdColorscheme(m, []string{"default"}, false)
+		cmd := cmdColorscheme(m, []string{name}, false)
 
 		if cmd != nil {
 			t.Error("expected nil tea.Cmd for colorscheme command")
@@ -5650,8 +5665,12 @@ func TestCmdColorscheme(t *testing.T) {
 
 	t.Run("extra args beyond name do not panic", func(t *testing.T) {
 		m := action.NewMockModel()
+		name := pickTheme(m)
+		if name == "" {
+			t.Fatal("expected at least one theme in mock")
+		}
 
-		cmdColorscheme(m, []string{"default", "extra", "args"}, false)
+		cmdColorscheme(m, []string{name, "extra", "args"}, false)
 	})
 
 	// --------------------------------------------------
@@ -5660,8 +5679,12 @@ func TestCmdColorscheme(t *testing.T) {
 
 	t.Run("force flag with valid name still sets styles", func(t *testing.T) {
 		m := action.NewMockModel()
+		name := pickTheme(m)
+		if name == "" {
+			t.Fatal("expected at least one theme in mock")
+		}
 
-		cmdColorscheme(m, []string{"default"}, true)
+		cmdColorscheme(m, []string{name}, true)
 
 		if m.CommandOutputVal != nil && m.CommandOutputVal.IsError {
 			t.Error("expected styles to change with force=true and valid name")
@@ -5737,11 +5760,17 @@ func TestCmdListColorschemes(t *testing.T) {
 
 	t.Run("commandOutput lines contains known built-in styles", func(t *testing.T) {
 		m := action.NewMockModel()
+		m.SetThemes(map[string]theme.EditorTheme{
+			"kanagawa":         {},
+			"kanagawa-dragon":  {},
+			"kanagawa-lotus":   {},
+			"tokyonight-storm": {},
+		})
 
 		cmdListColorschemes(m, []string{}, false)
 
 		lines := m.CommandOutputVal.Lines
-		known := []string{"default"}
+		known := []string{"kanagawa", "kanagawa-dragon", "kanagawa-lotus", "tokyonight-storm"}
 		for _, name := range known {
 			found := false
 			for _, l := range lines {
@@ -5756,14 +5785,18 @@ func TestCmdListColorschemes(t *testing.T) {
 		}
 	})
 
-	t.Run("commandOutput lines matches styles.Names()", func(t *testing.T) {
+	t.Run("commandOutput lines matches themes map size", func(t *testing.T) {
 		m := action.NewMockModel()
+		m.SetThemes(map[string]theme.EditorTheme{
+			"kanagawa":        {},
+			"kanagawa-dragon": {},
+			"kanagawa-lotus":  {},
+		})
 
 		cmdListColorschemes(m, []string{}, false)
 
-		expected := []string{"default"}
+		if len(m.CommandOutputVal.Lines) != len(m.Themes()) {
-		if len(m.CommandOutputVal.Lines) != len(expected) {
+			t.Errorf("expected %d colorschemes, got %d", len(m.Themes()), len(m.CommandOutputVal.Lines))
-			t.Errorf("expected %d colorschemes, got %d", len(expected), len(m.CommandOutputVal.Lines))
 		}
 	})
 
@@ -5782,9 +5815,19 @@ func TestCmdListColorschemes(t *testing.T) {
 	t.Run("args and force are ignored", func(t *testing.T) {
 		m1 := action.NewMockModel()
 		m2 := action.NewMockModel()
+		m1.SetThemes(map[string]theme.EditorTheme{
+			"kanagawa":        {},
+			"kanagawa-dragon": {},
+			"kanagawa-lotus":  {},
+		})
+		m2.SetThemes(map[string]theme.EditorTheme{
+			"kanagawa":        {},
+			"kanagawa-dragon": {},
+			"kanagawa-lotus":  {},
+		})
 
 		cmdListColorschemes(m1, []string{}, false)
-		cmdListColorschemes(m2, []string{"default", "extra"}, true)
+		cmdListColorschemes(m2, []string{"kanagawa", "extra"}, true)
 
 		if len(m1.CommandOutputVal.Lines) != len(m2.CommandOutputVal.Lines) {
 			t.Error("expected args and force to have no effect on list output")

internal/editor/model.go

@@ -51,8 +51,9 @@ type Model struct {
 	registers map[rune]core.Register // name -> register
 
 	// Visual styles
-	theme  theme.EditorTheme
+	currentTheme string // Name of current theme
-	syntax syntax.Engine
+	themes       map[string]theme.EditorTheme
+	syntax       syntax.Engine
 
 	// Dot operator state
 	lastChangeKeys []string
@@ -341,12 +342,39 @@ func (m *Model) SetSettings(s core.EditorSettings) {
 	m.settings = s
 }
 
-func (m *Model) Theme() theme.EditorTheme {
+// ==================================================
-	return m.theme
+// Themes
+// ==================================================
+func (m *Model) Theme() (string, theme.EditorTheme) {
+	t, ok := m.themes[m.currentTheme]
+	if ok {
+		return m.currentTheme, t
+	}
+	return "default", m.themes["default"]
 }
 
-func (m *Model) SetTheme(t theme.EditorTheme) {
+func (m *Model) SetTheme(name string) {
-	m.theme = t
+	m.currentTheme = name
+
+	if m.syntax == nil {
+		return
+	}
+
+	// Need to invalidate the buffers to force a redraw
+	for _, buf := range m.buffers {
+		if buf == nil {
+			continue
+		}
+		m.syntax.InvalidateBuffer(buf)
+	}
+}
+
+func (m *Model) Themes() map[string]theme.EditorTheme {
+	return m.themes
+}
+
+func (m *Model) SetThemes(t map[string]theme.EditorTheme) {
+	m.themes = t
 }
 
 func (m *Model) Syntax() syntax.Engine {

internal/editor/model_builder.go

@@ -4,6 +4,7 @@ import (
 	"git.gophernest.net/azpect/TextEditor/internal/core"
 	"git.gophernest.net/azpect/TextEditor/internal/input"
 	"git.gophernest.net/azpect/TextEditor/internal/syntax"
+	"git.gophernest.net/azpect/TextEditor/internal/theme"
 	"git.gophernest.net/azpect/TextEditor/internal/theme/themes"
 )
 
@@ -15,6 +16,16 @@ type ModelBuilder struct {
 func NewModelBuilder() *ModelBuilder {
 	editorTheme := themes.NewDefaultTheme()
 
+	// Embed the themes
+	var embededThemes map[string]theme.EditorTheme
+	embededThemesJson, err := theme.LoadEmbeddedThemesJSON()
+	if err == nil {
+		embededThemes = theme.MapEmbededThemeToEditorTheme(embededThemesJson)
+	}
+
+	// Always have a default theme
+	embededThemes["default"] = themes.NewDefaultTheme()
+
 	return &ModelBuilder{
 		model: Model{
 			buffers:        []*core.Buffer{},
@@ -33,7 +44,8 @@ func NewModelBuilder() *ModelBuilder {
 			settings:       core.NewDefaultSettings(),
 			registers:      core.DefaultRegisters(),
 			syntax:         syntax.NewTreeSitterEngine(editorTheme),
-			theme:          editorTheme,
+			currentTheme:   "default",
+			themes:         embededThemes,
 		},
 	}
 }

internal/editor/view.go

@@ -21,7 +21,7 @@ func (m Model) View() string {
 	// Each window has its own line numbers and gutter
 	// Each window has its own status bar and mode
 
-	t := m.Theme()
+	_, t := m.Theme()
 	options := win.Options
 
 	// Adjust gutter to fit line len
@@ -51,7 +51,7 @@ func viewWindow(w *core.Window, t theme.EditorTheme, options core.WinOptions, mo
 	buf := w.Buffer
 	var view strings.Builder
 	if sx != nil {
-		sx.PrepareBuffer(buf)
+		sx.PrepareBuffer(buf, t)
 	}
 
 	// Compute window size (y)
@@ -63,7 +63,7 @@ func viewWindow(w *core.Window, t theme.EditorTheme, options core.WinOptions, mo
 		if lineNum < buf.LineCount() {
 			styleMap := make([]lipgloss.Style, len([]rune(buf.Line(lineNum))))
 			if sx != nil {
-				styleMap = sx.LineStyleMap(buf, lineNum)
+				styleMap = sx.LineStyleMap(buf, lineNum, t)
 			}
 			line := drawLine(w, t, options, mode, buf.Line(lineNum), lineNum, styleMap)
 			view.WriteString(line)

internal/syntax/engine.go

@@ -2,6 +2,7 @@ package syntax
 
 import (
 	"git.gophernest.net/azpect/TextEditor/internal/core"
+	"git.gophernest.net/azpect/TextEditor/internal/theme"
 	"github.com/charmbracelet/lipgloss"
 )
 
@@ -11,13 +12,13 @@ import (
 // directly.
 type Engine interface {
 	// Engine.PrepareBuffer: Ensure syntax state for a buffer is ready.
-	PrepareBuffer(buf *core.Buffer)
+	PrepareBuffer(buf *core.Buffer, t theme.EditorTheme)
 
 	// Engine.ApplyEdit: Apply an incremental text edit to syntax state.
 	ApplyEdit(buf *core.Buffer, edit *core.BufferEdit)
 
 	// Engine.LineStyleMap: Returns per-rune styles for a line.
-	LineStyleMap(buf *core.Buffer, line int) []lipgloss.Style
+	LineStyleMap(buf *core.Buffer, line int, t theme.EditorTheme) []lipgloss.Style
 
 	// Engine.InvalidateBuffer: Marks all syntax state for a buffer as stale.
 	InvalidateBuffer(buf *core.Buffer)

internal/syntax/treesitter.go

@@ -20,8 +20,7 @@ import (
 //
 // Cached styles are represented as one style per rune for each line.
 type TreeSitterEngine struct {
-	editorTheme theme.EditorTheme
+	registry *languageRegistry
-	registry    *languageRegistry
 
 	cache map[*core.Buffer]*bufferCache
 }
@@ -74,9 +73,8 @@ type captureRange struct {
 // work with any language/query pair registered there.
 func NewTreeSitterEngine(t theme.EditorTheme) *TreeSitterEngine {
 	return &TreeSitterEngine{
-		editorTheme: t,
+		registry: newLanguageRegistry(),
-		registry:    newLanguageRegistry(),
+		cache:    map[*core.Buffer]*bufferCache{},
-		cache:       map[*core.Buffer]*bufferCache{},
 	}
 }
 
@@ -88,7 +86,7 @@ func NewTreeSitterEngine(t theme.EditorTheme) *TreeSitterEngine {
 //
 // If the buffer language is unsupported or resolution fails, it still marks the
 // cache as built with an empty style map so callers can safely continue.
-func (e *TreeSitterEngine) PrepareBuffer(buf *core.Buffer) {
+func (e *TreeSitterEngine) PrepareBuffer(buf *core.Buffer, t theme.EditorTheme) {
 	// Cannot prepare a nil buffer
 	if buf == nil {
 		return
@@ -115,7 +113,7 @@ func (e *TreeSitterEngine) PrepareBuffer(buf *core.Buffer) {
 	}
 	_ = lang
 
-	e.buildFullBuffer(buf, bc)
+	e.buildFullBuffer(buf, bc, t)
 }
 
 // LineStyleMap returns the style row for a specific line in buf.
@@ -123,12 +121,12 @@ func (e *TreeSitterEngine) PrepareBuffer(buf *core.Buffer) {
 // It first guarantees buffer preparation, then returns cached styles when
 // available. Missing lines are lazily initialized to the base line style and
 // stored in cache to keep downstream rendering logic simple.
-func (e *TreeSitterEngine) LineStyleMap(buf *core.Buffer, line int) []lipgloss.Style {
+func (e *TreeSitterEngine) LineStyleMap(buf *core.Buffer, line int, t theme.EditorTheme) []lipgloss.Style {
 	if buf == nil {
 		return nil
 	}
 
-	e.PrepareBuffer(buf)
+	e.PrepareBuffer(buf, t)
 	bc := e.getCache(buf)
 
 	if s, ok := bc.lines[line]; ok {
@@ -138,7 +136,7 @@ func (e *TreeSitterEngine) LineStyleMap(buf *core.Buffer, line int) []lipgloss.S
 	runes := []rune(buf.Line(line))
 	out := make([]lipgloss.Style, len(runes))
 	for i := range out {
-		out[i] = e.editorTheme.Line
+		out[i] = t.Line
 	}
 	bc.lines[line] = out
 	return out
@@ -297,7 +295,7 @@ func (e *TreeSitterEngine) getCache(buf *core.Buffer) *bufferCache {
 // It (re)parses source when needed, collects query captures, sorts captures by
 // precedence order, then writes styles onto per-rune line slices. After a
 // successful pass it clears dirty flags and marks the cache as built.
-func (e *TreeSitterEngine) buildFullBuffer(buf *core.Buffer, bc *bufferCache) {
+func (e *TreeSitterEngine) buildFullBuffer(buf *core.Buffer, bc *bufferCache, t theme.EditorTheme) {
 	lineCount := buf.LineCount()
 
 	// Load the lines into memory. There is no method for this due to the buffers
@@ -312,13 +310,13 @@ func (e *TreeSitterEngine) buildFullBuffer(buf *core.Buffer, bc *bufferCache) {
 	if fullRebuild {
 		bc.lines = map[int][]lipgloss.Style{}
 		for i := range lineCount {
-			bc.lines[i] = defaultLineStyles(lines[i], e.editorTheme.Line)
+			bc.lines[i] = defaultLineStyles(lines[i], t.Line)
 		}
 	} else {
 		dirty := normalizedDirtyRanges(bc.dirty, lineCount)
 		for _, r := range dirty {
 			for i := r.start; i <= r.end; i++ {
-				bc.lines[i] = defaultLineStyles(lines[i], e.editorTheme.Line)
+				bc.lines[i] = defaultLineStyles(lines[i], t.Line)
 			}
 		}
 	}
@@ -397,7 +395,7 @@ func (e *TreeSitterEngine) buildFullBuffer(buf *core.Buffer, bc *bufferCache) {
 	// rewrites.
 	targetDirty := normalizedDirtyRanges(bc.dirty, lineCount)
 	for _, c := range captures {
-		sty := e.editorTheme.CaptureStyle(c.name)
+		sty := t.CaptureStyle(c.name)
 		for row := c.startRow; row <= c.endRow; row++ {
 			if int(row) >= len(lines) {
 				break

internal/syntax/treesitter_behavior_test.go

@@ -23,13 +23,14 @@ func TestTreeSitterEngineHighlightsGoKeywordAndString(t *testing.T) {
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 
-	base := engine.editorTheme.Line
+	base := editorTheme.Line
 
 	line0 := buf.Line(0)
-	map0 := engine.LineStyleMap(buf, 0)
+	map0 := engine.LineStyleMap(buf, 0, editorTheme)
 	if len(map0) != len([]rune(line0)) {
 		t.Fatalf("line 0 style map length mismatch")
 	}
@@ -42,7 +43,7 @@ func TestTreeSitterEngineHighlightsGoKeywordAndString(t *testing.T) {
 	if stringStart < 0 {
 		t.Fatalf("test setup failed: string literal not found")
 	}
-	map2 := engine.LineStyleMap(buf, 2)
+	map2 := engine.LineStyleMap(buf, 2, editorTheme)
 	if styleEquivalent(map2[stringStart+1], base) {
 		t.Fatalf("expected string contents to be highlighted")
 	}
@@ -63,11 +64,12 @@ func TestTreeSitterEngineHighlightsMultilineRawString(t *testing.T) {
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 
-	base := engine.editorTheme.Line
+	base := editorTheme.Line
-	map3 := engine.LineStyleMap(buf, 3)
+	map3 := engine.LineStyleMap(buf, 3, editorTheme)
 	if len(map3) == 0 {
 		t.Fatalf("expected style map on multiline raw string line")
 	}
@@ -89,15 +91,16 @@ func TestTreeSitterEngineApplyEditUpdatesStyleCategory(t *testing.T) {
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 
 	oldLine := buf.Line(2)
 	oldIdx := strings.Index(oldLine, "123")
 	if oldIdx < 0 {
 		t.Fatalf("test setup failed: number not found")
 	}
-	oldMap := engine.LineStyleMap(buf, 2)
+	oldMap := engine.LineStyleMap(buf, 2, editorTheme)
 	oldStyle := oldMap[oldIdx]
 
 	var edit *core.BufferEdit
@@ -111,17 +114,17 @@ func TestTreeSitterEngineApplyEditUpdatesStyleCategory(t *testing.T) {
 	}
 
 	engine.ApplyEdit(buf, edit)
-	engine.PrepareBuffer(buf)
+	engine.PrepareBuffer(buf, editorTheme)
 
 	newLine := buf.Line(2)
 	newIdx := strings.Index(newLine, "abc")
 	if newIdx < 0 {
 		t.Fatalf("test setup failed: string not found")
 	}
-	newMap := engine.LineStyleMap(buf, 2)
+	newMap := engine.LineStyleMap(buf, 2, editorTheme)
 	newStyle := newMap[newIdx]
 
-	if styleEquivalent(newStyle, engine.editorTheme.Line) {
+	if styleEquivalent(newStyle, editorTheme.Line) {
 		t.Fatalf("expected updated string to be highlighted")
 	}
 	if styleEquivalent(oldStyle, newStyle) {
@@ -137,8 +140,9 @@ func TestTreeSitterEngineApplyEditLineCountChangeForcesFullDirty(t *testing.T) {
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 	bc := engine.getCache(buf)
 
 	var edit *core.BufferEdit
@@ -156,7 +160,7 @@ func TestTreeSitterEngineApplyEditLineCountChangeForcesFullDirty(t *testing.T) {
 		t.Fatalf("expected line count change to set dirtyAll")
 	}
 
-	engine.PrepareBuffer(buf)
+	engine.PrepareBuffer(buf, editorTheme)
 	if !bc.built {
 		t.Fatalf("expected cache rebuilt after prepare")
 	}
@@ -176,12 +180,13 @@ func TestTreeSitterEngineUnsupportedBufferFallsBackToDefaultStyles(t *testing.T)
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 
-	base := engine.editorTheme.Line
+	base := editorTheme.Line
 	line := buf.Line(0)
-	m := engine.LineStyleMap(buf, 0)
+	m := engine.LineStyleMap(buf, 0, editorTheme)
 	if len(m) != len([]rune(line)) {
 		t.Fatalf("style map length mismatch on fallback buffer")
 	}
@@ -200,8 +205,9 @@ func TestTreeSitterEngineLastLineEditDoesNotPanicAndRebuilds(t *testing.T) {
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 	bc := engine.getCache(buf)
 
 	var edit *core.BufferEdit
@@ -215,7 +221,7 @@ func TestTreeSitterEngineLastLineEditDoesNotPanicAndRebuilds(t *testing.T) {
 	}
 
 	engine.ApplyEdit(buf, edit)
-	engine.PrepareBuffer(buf)
+	engine.PrepareBuffer(buf, editorTheme)
 
 	if !bc.built {
 		t.Fatalf("expected cache built after last-line edit")

internal/syntax/treesitter_bench_test.go

@@ -18,9 +18,10 @@ func BenchmarkTreeSitterPrepareAndIncrementalEdit(b *testing.B) {
 
 	bld := core.NewBufferBuilder().WithFilename("bench.go").WithFiletype("go").WithLines(lines).Build()
 	buf := &bld
-	eng := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
+	eng := NewTreeSitterEngine(editorTheme)
 
-	eng.PrepareBuffer(buf)
+	eng.PrepareBuffer(buf, editorTheme)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -32,6 +33,6 @@ func BenchmarkTreeSitterPrepareAndIncrementalEdit(b *testing.B) {
 
 		// Synthetic direct invalidate path benchmark (current API entrypoints)
 		eng.InvalidateLines(buf, lineIdx, lineIdx)
-		eng.PrepareBuffer(buf)
+		eng.PrepareBuffer(buf, editorTheme)
 	}
 }

internal/syntax/treesitter_engine_test.go

@@ -15,8 +15,9 @@ func TestTreeSitterEngineApplyEditMarksDirtyWithoutFullInvalidation(t *testing.T
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 
 	bc := engine.getCache(buf)
 	if !bc.built {
@@ -45,7 +46,7 @@ func TestTreeSitterEngineApplyEditMarksDirtyWithoutFullInvalidation(t *testing.T
 		t.Fatalf("expected dirty ranges after apply edit")
 	}
 
-	engine.PrepareBuffer(buf)
+	engine.PrepareBuffer(buf, editorTheme)
 	if !bc.built {
 		t.Fatalf("expected cache rebuilt after prepare")
 	}
@@ -62,8 +63,9 @@ func TestTreeSitterEngineInvalidateLinesAndBuffer(t *testing.T) {
 		Build()
 	buf := &b
 
-	engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+	editorTheme := themes.NewDefaultTheme()
-	engine.PrepareBuffer(buf)
+	engine := NewTreeSitterEngine(editorTheme)
+	engine.PrepareBuffer(buf, editorTheme)
 
 	bc := engine.getCache(buf)
 	engine.InvalidateLines(buf, 1, 1)

internal/syntax/treesitter_sequences_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"git.gophernest.net/azpect/TextEditor/internal/core"
+	"git.gophernest.net/azpect/TextEditor/internal/theme"
 	"git.gophernest.net/azpect/TextEditor/internal/theme/themes"
 )
 
@@ -66,7 +67,8 @@ func TestTreeSitterEngineEditSequences(t *testing.T) {
 			w := core.NewWindowBuilder().WithBuffer(buf).WithDimensions(120, 40).Build()
 			win := &w
 
-			engine := NewTreeSitterEngine(themes.NewDefaultTheme())
+			editorTheme := themes.NewDefaultTheme()
+			engine := NewTreeSitterEngine(editorTheme)
 
 			buf.OnChange = func(change core.BufferChange) {
 				if change.Edit != nil {
@@ -76,19 +78,19 @@ func TestTreeSitterEngineEditSequences(t *testing.T) {
 				}
 			}
 
-			engine.PrepareBuffer(buf)
+			engine.PrepareBuffer(buf, editorTheme)
-			assertEngineInvariants(t, engine, buf, "initial")
+			assertEngineInvariants(t, engine, buf, editorTheme, "initial")
 
 			for i, op := range tc.opList {
 				op(buf, win)
-				engine.PrepareBuffer(buf)
+				engine.PrepareBuffer(buf, editorTheme)
-				assertEngineInvariants(t, engine, buf, fmt.Sprintf("after op %d", i+1))
+				assertEngineInvariants(t, engine, buf, editorTheme, fmt.Sprintf("after op %d", i+1))
 			}
 		})
 	}
 }
 
-func assertEngineInvariants(t *testing.T, engine *TreeSitterEngine, buf *core.Buffer, phase string) {
+func assertEngineInvariants(t *testing.T, engine *TreeSitterEngine, buf *core.Buffer, editorTheme theme.EditorTheme, phase string) {
 	t.Helper()
 
 	bc := engine.getCache(buf)
@@ -104,7 +106,7 @@ func assertEngineInvariants(t *testing.T, engine *TreeSitterEngine, buf *core.Bu
 
 	for i := 0; i < buf.LineCount(); i++ {
 		line := buf.Line(i)
-		m := engine.LineStyleMap(buf, i)
+		m := engine.LineStyleMap(buf, i, editorTheme)
 		if len(m) != len([]rune(line)) {
 			t.Fatalf("%s: line %d style length mismatch: got %d want %d", phase, i, len(m), len([]rune(line)))
 		}

internal/theme/loader.go

@@ -0,0 +1,154 @@
+package theme
+
+import (
+	"embed"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+//go:embed themes/*.json
+var embeddedThemes embed.FS
+
+// LoadEmbeddedThemesJSON reads all embedded theme JSON files and unmarshals
+// them into ThemeJSON objects keyed by theme name.
+func LoadEmbeddedThemesJSON() (map[string]ThemeJSON, error) {
+	paths, err := fs.Glob(embeddedThemes, "themes/*.json")
+	if err != nil {
+		return nil, err
+	}
+	sort.Strings(paths)
+
+	out := make(map[string]ThemeJSON, len(paths))
+	for _, path := range paths {
+		b, readErr := embeddedThemes.ReadFile(path)
+		if readErr != nil {
+			return nil, fmt.Errorf("read embedded theme %q: %w", path, readErr)
+		}
+
+		var th ThemeJSON
+		if unmarshalErr := json.Unmarshal(b, &th); unmarshalErr != nil {
+			return nil, fmt.Errorf("decode embedded theme %q: %w", path, unmarshalErr)
+		}
+
+		if strings.TrimSpace(th.Name) == "" {
+			th.Name = strings.TrimSuffix(filepath.Base(path), ".json")
+		}
+
+		out[th.Name] = th
+	}
+
+	return out, nil
+}
+
+func MapEmbededThemeToEditorTheme(em map[string]ThemeJSON) map[string]EditorTheme {
+	out := make(map[string]EditorTheme, len(em))
+
+	for name, in := range em {
+		line := styleFromJSON(in.Line)
+		lineBg := colorString(in.Line.BG)
+
+		syntaxExact := make(map[string]lipgloss.Style, len(in.Syntax.Exact))
+		for capture, col := range in.Syntax.Exact {
+			c := normalizeCaptureKey(capture)
+			if c == "" {
+				continue
+			}
+			syntaxExact[c] = syntaxColorStyle(col, lineBg)
+		}
+
+		syntaxGroup := make(map[string]lipgloss.Style, len(in.Syntax.Group))
+		for group, col := range in.Syntax.Group {
+			g := normalizeCaptureKey(group)
+			if g == "" {
+				continue
+			}
+			syntaxGroup[g] = syntaxColorStyle(col, lineBg)
+		}
+
+		key := strings.TrimSpace(name)
+		if key == "" {
+			key = strings.TrimSpace(in.Name)
+		}
+		if key == "" {
+			continue
+		}
+
+		out[key] = EditorTheme{
+			Cursors: CursorTheme{
+				Normal:  styleFromJSON(in.Cursors.Normal),
+				Insert:  styleFromJSON(in.Cursors.Insert),
+				Command: styleFromJSON(in.Cursors.Command),
+				Replace: styleFromJSON(in.Cursors.Replace),
+			},
+			Gutter: GutterTheme{
+				Default:     styleFromJSON(in.Gutter.Default),
+				CurrentLine: styleFromJSON(in.Gutter.CurrentLine),
+			},
+			VisualHightlight: styleFromJSON(in.VisualHighlight),
+			StatusBar: StatusBarTheme{
+				Default: styleFromJSON(in.StatusBar.Default),
+			},
+			CommandLine: CommandLineTheme{
+				Error:           styleFromJSON(in.CommandLine.Error),
+				OutputBorder:    styleFromJSON(in.CommandLine.OutputBorder),
+				ContinueMessage: styleFromJSON(in.CommandLine.ContinueMessage),
+			},
+			Line:       line,
+			Background: styleFromJSON(in.Background),
+			Syntax: SyntaxTheme{
+				Exact: syntaxExact,
+				Group: syntaxGroup,
+			},
+		}
+	}
+
+	return out
+}
+
+// MapEmbeddedThemeToEditorTheme is a correctly spelled alias for
+// MapEmbededThemeToEditorTheme.
+func MapEmbeddedThemeToEditorTheme(em map[string]ThemeJSON) map[string]EditorTheme {
+	return MapEmbededThemeToEditorTheme(em)
+}
+
+func styleFromJSON(in ColorStyleJSON) lipgloss.Style {
+	out := lipgloss.NewStyle()
+
+	if fg := colorString(in.FG); fg != "" {
+		out = out.Foreground(lipgloss.Color(fg))
+	}
+	if bg := colorString(in.BG); bg != "" {
+		out = out.Background(lipgloss.Color(bg))
+	}
+
+	return out
+}
+
+func colorString(c string) string {
+	return strings.TrimSpace(c)
+}
+
+func normalizeCaptureKey(k string) string {
+	k = strings.TrimSpace(strings.ToLower(k))
+	k = strings.TrimPrefix(k, "@")
+	return k
+}
+
+func syntaxColorStyle(fg, bg string) lipgloss.Style {
+	out := lipgloss.NewStyle()
+
+	if f := colorString(fg); f != "" {
+		out = out.Foreground(lipgloss.Color(f))
+	}
+	if b := colorString(bg); b != "" {
+		out = out.Background(lipgloss.Color(b))
+	}
+
+	return out
+}

internal/theme/loader_test.go

@@ -0,0 +1,117 @@
+package theme
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestLoadEmbeddedThemesJSON_LoadsExpectedThemes(t *testing.T) {
+	themesJSON, err := LoadEmbeddedThemesJSON()
+	if err != nil {
+		t.Fatalf("LoadEmbeddedThemesJSON returned error: %v", err)
+	}
+
+	want := []string{"kanagawa", "kanagawa-dragon", "kanagawa-lotus"}
+	for _, name := range want {
+		th, ok := themesJSON[name]
+		if !ok {
+			t.Fatalf("expected embedded theme %q to be loaded", name)
+		}
+		if th.Name == "" {
+			t.Fatalf("expected embedded theme %q to have a name", name)
+		}
+		if th.Line.BG == "" {
+			t.Fatalf("expected embedded theme %q to include line background", name)
+		}
+	}
+}
+
+func TestMapEmbeddedThemeToEditorTheme_MapsStylesAndNormalizesSyntaxKeys(t *testing.T) {
+	in := map[string]ThemeJSON{
+		"custom": {
+			Name:            "custom",
+			Line:            ColorStyleJSON{FG: "#dddddd", BG: "#101010"},
+			Background:      ColorStyleJSON{BG: "#101010"},
+			VisualHighlight: ColorStyleJSON{BG: "#202020"},
+			Cursors: CursorJSON{
+				Normal:  ColorStyleJSON{FG: "#101010", BG: "#dddddd"},
+				Insert:  ColorStyleJSON{FG: "#101010", BG: "#cccccc"},
+				Command: ColorStyleJSON{FG: "#101010", BG: "#bbbbbb"},
+				Replace: ColorStyleJSON{FG: "#101010", BG: "#aaaaaa"},
+			},
+			Gutter: GutterJSON{
+				Default:     ColorStyleJSON{FG: "#666666", BG: "#0a0a0a"},
+				CurrentLine: ColorStyleJSON{FG: "#eeeeee", BG: "#0a0a0a"},
+			},
+			StatusBar: StatusBarJSON{
+				Default: ColorStyleJSON{FG: "#cccccc", BG: "#0a0a0a"},
+			},
+			CommandLine: CommandLineJSON{
+				Error:           ColorStyleJSON{FG: "#ff0000", BG: "#101010"},
+				OutputBorder:    ColorStyleJSON{FG: "#dddddd", BG: "#0a0a0a"},
+				ContinueMessage: ColorStyleJSON{FG: "#00aaff", BG: "#101010"},
+			},
+			Syntax: SyntaxJSON{
+				Group: map[string]string{
+					"  String ": "#00ff00",
+				},
+				Exact: map[string]string{
+					" @KEYWORD.Return ": "#ff00ff",
+				},
+			},
+		},
+	}
+
+	out := MapEmbeddedThemeToEditorTheme(in)
+	th, ok := out["custom"]
+	if !ok {
+		t.Fatalf("expected mapped theme with key %q", "custom")
+	}
+
+	if got := colorHex(th.Line.GetForeground()); got != "#dddddd" {
+		t.Fatalf("line fg mismatch: got %q want %q", got, "#dddddd")
+	}
+	if got := colorHex(th.Line.GetBackground()); got != "#101010" {
+		t.Fatalf("line bg mismatch: got %q want %q", got, "#101010")
+	}
+
+	if got := colorHex(th.Syntax.Exact["keyword.return"].GetForeground()); got != "#ff00ff" {
+		t.Fatalf("exact capture fg mismatch: got %q want %q", got, "#ff00ff")
+	}
+	if got := colorHex(th.Syntax.Exact["keyword.return"].GetBackground()); got != "#101010" {
+		t.Fatalf("exact capture bg mismatch: got %q want %q", got, "#101010")
+	}
+	if got := colorHex(th.Syntax.Group["string"].GetForeground()); got != "#00ff00" {
+		t.Fatalf("group capture fg mismatch: got %q want %q", got, "#00ff00")
+	}
+
+	if got := colorHex(th.CommandLine.Error.GetForeground()); got != "#ff0000" {
+		t.Fatalf("command error fg mismatch: got %q want %q", got, "#ff0000")
+	}
+}
+
+func TestMapEmbededThemeToEditorTheme_AliasMatchesPrimary(t *testing.T) {
+	in := map[string]ThemeJSON{
+		"x": {
+			Name: "x",
+			Line: ColorStyleJSON{FG: "#ffffff", BG: "#000000"},
+			Syntax: SyntaxJSON{
+				Group: map[string]string{"keyword": "#123456"},
+			},
+		},
+	}
+
+	a := MapEmbededThemeToEditorTheme(in)
+	b := MapEmbeddedThemeToEditorTheme(in)
+
+	if len(a) != len(b) {
+		t.Fatalf("alias map size mismatch: %d vs %d", len(a), len(b))
+	}
+	if colorHex(a["x"].Syntax.Group["keyword"].GetForeground()) != colorHex(b["x"].Syntax.Group["keyword"].GetForeground()) {
+		t.Fatalf("alias should produce identical mapped styles")
+	}
+}
+
+func colorHex(c any) string {
+	return fmt.Sprint(c)
+}

internal/theme/theme_json.go

@@ -0,0 +1,53 @@
+package theme
+
+// ThemeJSON is the file-backed theme DTO used for JSON unmarshalling.
+//
+// This mirrors the format documented in internal/theme/themes/README.md.
+// It is intentionally string-based so values can be validated and compiled
+// into EditorTheme styles in a separate step.
+type ThemeJSON struct {
+	Name            string          `json:"name"`
+	Line            ColorStyleJSON  `json:"line"`
+	Background      ColorStyleJSON  `json:"background"`
+	VisualHighlight ColorStyleJSON  `json:"visual_highlight"`
+	Cursors         CursorJSON      `json:"cursors"`
+	Gutter          GutterJSON      `json:"gutter"`
+	StatusBar       StatusBarJSON   `json:"status_bar"`
+	CommandLine     CommandLineJSON `json:"command_line"`
+	Syntax          SyntaxJSON      `json:"syntax"`
+}
+
+// ColorStyleJSON represents a simple fg/bg style entry.
+//
+// For v1 themes, only color values are supported.
+type ColorStyleJSON struct {
+	FG string `json:"fg,omitempty"`
+	BG string `json:"bg,omitempty"`
+}
+
+type CursorJSON struct {
+	Normal  ColorStyleJSON `json:"normal"`
+	Insert  ColorStyleJSON `json:"insert"`
+	Command ColorStyleJSON `json:"command"`
+	Replace ColorStyleJSON `json:"replace"`
+}
+
+type GutterJSON struct {
+	Default     ColorStyleJSON `json:"default"`
+	CurrentLine ColorStyleJSON `json:"current_line"`
+}
+
+type StatusBarJSON struct {
+	Default ColorStyleJSON `json:"default"`
+}
+
+type CommandLineJSON struct {
+	Error           ColorStyleJSON `json:"error"`
+	OutputBorder    ColorStyleJSON `json:"output_border"`
+	ContinueMessage ColorStyleJSON `json:"continue_message"`
+}
+
+type SyntaxJSON struct {
+	Group map[string]string `json:"group"`
+	Exact map[string]string `json:"exact"`
+}

internal/theme/themes/README.md

@@ -0,0 +1,81 @@
+# Theme JSON Format (v1)
+
+This document defines the JSON structure for editor themes.
+
+- All color values are 6-digit hex strings (for example `#d4d8e1`).
+- Capture keys must be lowercase and must not include `@`.
+- `syntax.exact` overrides `syntax.group`. **These can be any values!**
+- If a capture is missing from both maps, the editor should fall back to the base `line` style.
+
+## Full structure
+
+```json
+{
+  "name": "default",
+  "line": { "fg": "#d4d8e1", "bg": "#111418" },
+  "background": { "bg": "#111418" },
+  "visual_highlight": { "bg": "#2f334d" },
+
+  "cursors": {
+    "normal": { "fg": "#111418", "bg": "#d4d8e1" },
+    "insert": { "fg": "#d4d8e1", "bg": "#111418" },
+    "command": { "fg": "#111418", "bg": "#d4d8e1" },
+    "replace": { "fg": "#d4d8e1", "bg": "#111418" }
+  },
+
+  "gutter": {
+    "default": { "fg": "#6b7280", "bg": "#0d1014" },
+    "current_line": { "fg": "#c0c8d8", "bg": "#0d1014" }
+  },
+
+  "status_bar": {
+    "default": { "fg": "#8f99aa", "bg": "#0d1014" }
+  },
+
+  "command_line": {
+    "error": { "fg": "#bf616a", "bg": "#111418" },
+    "output_border": { "fg": "#d4d8e1", "bg": "#0d1014" },
+    "continue_message": { "fg": "#81a1c1", "bg": "#111418" }
+  },
+
+  "syntax": {
+    "group": {
+      "comment": "#7f8795",
+      "function": "#81a1c1",
+      "keyword": "#b48ead",
+      "number": "#88c0d0",
+      "string": "#a3be8c",
+      "type": "#ebcb8b",
+      "variable": "#d4d8e1"
+        ...
+    },
+    "exact": {
+      "comment.documentation": "#8f99aa",
+      "function.call": "#81a1c1",
+      "keyword.return": "#b48ead",
+      "string.escape": "#d08770",
+      "variable.parameter": "#c0c8d8",
+        ...
+    }
+  }
+}
+```
+
+## Field notes
+
+- `name`: theme name shown by `:colorscheme`.
+- `line`: base text style used as the default fallback.
+- `background`: background fill style used for empty space.
+- `visual_highlight`: selection background style.
+- `syntax.group`: fallback colors by capture group (`keyword`, `string`, `comment`, etc.).
+- `syntax.exact`: exact capture overrides (`keyword.function`, `string.escape`, etc.).
+
+## Future ideas
+
+For now, styles only support foreground/background colors.
+
+In a future version we may add optional text attributes such as:
+
+- `bold`
+- `italic`
+- `underline`

internal/theme/themes/ayu-mirage.json

@@ -0,0 +1,79 @@
+{
+  "name": "ayu-mirage",
+  "line": {
+    "fg": "#d9d7ce",
+    "bg": "#212733"
+  },
+  "background": {
+    "bg": "#212733"
+  },
+  "visual_highlight": {
+    "bg": "#343f4c"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#212733",
+      "bg": "#ffcc66"
+    },
+    "insert": {
+      "fg": "#212733",
+      "bg": "#bae67e"
+    },
+    "command": {
+      "fg": "#212733",
+      "bg": "#5ccfe6"
+    },
+    "replace": {
+      "fg": "#212733",
+      "bg": "#ff3333"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#5c6773",
+      "bg": "#212733"
+    },
+    "current_line": {
+      "fg": "#d9d7ce",
+      "bg": "#212733"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#d9d7ce",
+      "bg": "#191e2a"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#ff3333",
+      "bg": "#212733"
+    },
+    "output_border": {
+      "fg": "#343f4c",
+      "bg": "#191e2a"
+    },
+    "continue_message": {
+      "fg": "#ffad66",
+      "bg": "#212733"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#5c6773",
+      "function": "#ffcc66",
+      "keyword": "#ffa759",
+      "number": "#ffad66",
+      "string": "#bae67e",
+      "type": "#5ccfe6",
+      "variable": "#d9d7ce"
+    },
+    "exact": {
+      "comment.documentation": "#5c6773",
+      "function.call": "#ffcc66",
+      "keyword.return": "#ffa759",
+      "string.escape": "#95e6cb",
+      "variable.parameter": "#d9d7ce"
+    }
+  }
+}

internal/theme/themes/catppuccin-frappe.json

@@ -0,0 +1,79 @@
+{
+  "name": "catppuccin-frappe",
+  "line": {
+    "fg": "#c6d0f5",
+    "bg": "#303446"
+  },
+  "background": {
+    "bg": "#303446"
+  },
+  "visual_highlight": {
+    "bg": "#414559"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#303446",
+      "bg": "#c6d0f5"
+    },
+    "insert": {
+      "fg": "#303446",
+      "bg": "#a6d189"
+    },
+    "command": {
+      "fg": "#303446",
+      "bg": "#ca9ee6"
+    },
+    "replace": {
+      "fg": "#303446",
+      "bg": "#e78284"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#838ba7",
+      "bg": "#292c3c"
+    },
+    "current_line": {
+      "fg": "#c6d0f5",
+      "bg": "#292c3c"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#a5adce",
+      "bg": "#232634"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#e78284",
+      "bg": "#303446"
+    },
+    "output_border": {
+      "fg": "#414559",
+      "bg": "#232634"
+    },
+    "continue_message": {
+      "fg": "#8caaee",
+      "bg": "#303446"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#838ba7",
+      "function": "#8caaee",
+      "keyword": "#ca9ee6",
+      "number": "#ef9f76",
+      "string": "#a6d189",
+      "type": "#e5c890",
+      "variable": "#c6d0f5"
+    },
+    "exact": {
+      "comment.documentation": "#949cbb",
+      "function.call": "#8caaee",
+      "keyword.return": "#e78284",
+      "string.escape": "#81c8be",
+      "variable.parameter": "#eebebe"
+    }
+  }
+}

internal/theme/themes/catppuccin-latte.json

@@ -0,0 +1,79 @@
+{
+  "name": "catppuccin-latte",
+  "line": {
+    "fg": "#4c4f69",
+    "bg": "#eff1f5"
+  },
+  "background": {
+    "bg": "#eff1f5"
+  },
+  "visual_highlight": {
+    "bg": "#ccd0da"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#eff1f5",
+      "bg": "#4c4f69"
+    },
+    "insert": {
+      "fg": "#eff1f5",
+      "bg": "#40a02b"
+    },
+    "command": {
+      "fg": "#eff1f5",
+      "bg": "#8839ef"
+    },
+    "replace": {
+      "fg": "#eff1f5",
+      "bg": "#d20f39"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#9ca0b0",
+      "bg": "#e6e9ef"
+    },
+    "current_line": {
+      "fg": "#4c4f69",
+      "bg": "#e6e9ef"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#6c6f85",
+      "bg": "#dce0e8"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#d20f39",
+      "bg": "#eff1f5"
+    },
+    "output_border": {
+      "fg": "#ccd0da",
+      "bg": "#dce0e8"
+    },
+    "continue_message": {
+      "fg": "#1e66f5",
+      "bg": "#eff1f5"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#9ca0b0",
+      "function": "#1e66f5",
+      "keyword": "#8839ef",
+      "number": "#fe640b",
+      "string": "#40a02b",
+      "type": "#df8e1d",
+      "variable": "#4c4f69"
+    },
+    "exact": {
+      "comment.documentation": "#7c7f93",
+      "function.call": "#1e66f5",
+      "keyword.return": "#d20f39",
+      "string.escape": "#179287",
+      "variable.parameter": "#dd7878"
+    }
+  }
+}

internal/theme/themes/catppuccin-macchiato.json

@@ -0,0 +1,79 @@
+{
+  "name": "catppuccin-macchiato",
+  "line": {
+    "fg": "#cad3f5",
+    "bg": "#24273a"
+  },
+  "background": {
+    "bg": "#24273a"
+  },
+  "visual_highlight": {
+    "bg": "#363a4f"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#24273a",
+      "bg": "#cad3f5"
+    },
+    "insert": {
+      "fg": "#24273a",
+      "bg": "#a6da95"
+    },
+    "command": {
+      "fg": "#24273a",
+      "bg": "#c6a0f6"
+    },
+    "replace": {
+      "fg": "#24273a",
+      "bg": "#ed8796"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#8087a2",
+      "bg": "#1e2030"
+    },
+    "current_line": {
+      "fg": "#cad3f5",
+      "bg": "#1e2030"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#a5adcb",
+      "bg": "#181926"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#ed8796",
+      "bg": "#24273a"
+    },
+    "output_border": {
+      "fg": "#363a4f",
+      "bg": "#181926"
+    },
+    "continue_message": {
+      "fg": "#8aadf4",
+      "bg": "#24273a"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#8087a2",
+      "function": "#8aadf4",
+      "keyword": "#c6a0f6",
+      "number": "#f5a97f",
+      "string": "#a6da95",
+      "type": "#eed49f",
+      "variable": "#cad3f5"
+    },
+    "exact": {
+      "comment.documentation": "#939ab7",
+      "function.call": "#8aadf4",
+      "keyword.return": "#ed8796",
+      "string.escape": "#8bd5ca",
+      "variable.parameter": "#ee99a0"
+    }
+  }
+}

internal/theme/themes/catppuccin-mocha.json

@@ -0,0 +1,79 @@
+{
+  "name": "catppuccin-mocha",
+  "line": {
+    "fg": "#cdd6f4",
+    "bg": "#1e1e2e"
+  },
+  "background": {
+    "bg": "#1e1e2e"
+  },
+  "visual_highlight": {
+    "bg": "#313244"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#1e1e2e",
+      "bg": "#cdd6f4"
+    },
+    "insert": {
+      "fg": "#1e1e2e",
+      "bg": "#a6e3a1"
+    },
+    "command": {
+      "fg": "#1e1e2e",
+      "bg": "#cba6f7"
+    },
+    "replace": {
+      "fg": "#1e1e2e",
+      "bg": "#f38ba8"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#7f849c",
+      "bg": "#181825"
+    },
+    "current_line": {
+      "fg": "#cdd6f4",
+      "bg": "#181825"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#a6adc8",
+      "bg": "#11111b"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#f38ba8",
+      "bg": "#1e1e2e"
+    },
+    "output_border": {
+      "fg": "#313244",
+      "bg": "#11111b"
+    },
+    "continue_message": {
+      "fg": "#89b4fa",
+      "bg": "#1e1e2e"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#7f849c",
+      "function": "#89b4fa",
+      "keyword": "#cba6f7",
+      "number": "#fab387",
+      "string": "#a6e3a1",
+      "type": "#f9e2af",
+      "variable": "#cdd6f4"
+    },
+    "exact": {
+      "comment.documentation": "#9399b2",
+      "function.call": "#89b4fa",
+      "keyword.return": "#f38ba8",
+      "string.escape": "#94e2d5",
+      "variable.parameter": "#eba0ac"
+    }
+  }
+}

internal/theme/themes/dracula.json

@@ -0,0 +1,79 @@
+{
+  "name": "dracula",
+  "line": {
+    "fg": "#f8f8f2",
+    "bg": "#282a36"
+  },
+  "background": {
+    "bg": "#282a36"
+  },
+  "visual_highlight": {
+    "bg": "#44475a"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#282a36",
+      "bg": "#f8f8f2"
+    },
+    "insert": {
+      "fg": "#282a36",
+      "bg": "#50fa7b"
+    },
+    "command": {
+      "fg": "#282a36",
+      "bg": "#bd93f9"
+    },
+    "replace": {
+      "fg": "#282a36",
+      "bg": "#ff5555"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#6272a4",
+      "bg": "#282a36"
+    },
+    "current_line": {
+      "fg": "#f8f8f2",
+      "bg": "#343746"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#f8f8f2",
+      "bg": "#191a21"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#ff5555",
+      "bg": "#282a36"
+    },
+    "output_border": {
+      "fg": "#44475a",
+      "bg": "#191a21"
+    },
+    "continue_message": {
+      "fg": "#8be9fd",
+      "bg": "#282a36"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#6272a4",
+      "function": "#50fa7b",
+      "keyword": "#ff79c6",
+      "number": "#bd93f9",
+      "string": "#f1fa8c",
+      "type": "#8be9fd",
+      "variable": "#f8f8f2"
+    },
+    "exact": {
+      "comment.documentation": "#6272a4",
+      "function.call": "#50fa7b",
+      "keyword.return": "#ff79c6",
+      "string.escape": "#ffb86c",
+      "variable.parameter": "#ffb86c"
+    }
+  }
+}

internal/theme/themes/github-dark.json

@@ -0,0 +1,79 @@
+{
+  "name": "github-dark",
+  "line": {
+    "fg": "#c9d1d9",
+    "bg": "#0d1117"
+  },
+  "background": {
+    "bg": "#0d1117"
+  },
+  "visual_highlight": {
+    "bg": "#21262d"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#0d1117",
+      "bg": "#58a6ff"
+    },
+    "insert": {
+      "fg": "#0d1117",
+      "bg": "#3fb950"
+    },
+    "command": {
+      "fg": "#0d1117",
+      "bg": "#bc8cff"
+    },
+    "replace": {
+      "fg": "#0d1117",
+      "bg": "#f85149"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#484f58",
+      "bg": "#0d1117"
+    },
+    "current_line": {
+      "fg": "#c9d1d9",
+      "bg": "#161b22"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#8b949e",
+      "bg": "#010409"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#f85149",
+      "bg": "#0d1117"
+    },
+    "output_border": {
+      "fg": "#30363d",
+      "bg": "#010409"
+    },
+    "continue_message": {
+      "fg": "#58a6ff",
+      "bg": "#0d1117"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#8b949e",
+      "function": "#d2a8ff",
+      "keyword": "#ff7b72",
+      "number": "#79c0ff",
+      "string": "#a5d6ff",
+      "type": "#ffa657",
+      "variable": "#c9d1d9"
+    },
+    "exact": {
+      "comment.documentation": "#8b949e",
+      "function.call": "#d2a8ff",
+      "keyword.return": "#ff7b72",
+      "string.escape": "#79c0ff",
+      "variable.parameter": "#ffa657"
+    }
+  }
+}

internal/theme/themes/github-light.json

@@ -0,0 +1,79 @@
+{
+  "name": "github-light",
+  "line": {
+    "fg": "#24292f",
+    "bg": "#ffffff"
+  },
+  "background": {
+    "bg": "#ffffff"
+  },
+  "visual_highlight": {
+    "bg": "#afdbff"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#ffffff",
+      "bg": "#0969da"
+    },
+    "insert": {
+      "fg": "#ffffff",
+      "bg": "#1a7f37"
+    },
+    "command": {
+      "fg": "#ffffff",
+      "bg": "#8250df"
+    },
+    "replace": {
+      "fg": "#ffffff",
+      "bg": "#cf222e"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#8c959f",
+      "bg": "#ffffff"
+    },
+    "current_line": {
+      "fg": "#24292f",
+      "bg": "#f6f8fa"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#57606a",
+      "bg": "#f6f8fa"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#cf222e",
+      "bg": "#ffffff"
+    },
+    "output_border": {
+      "fg": "#d0d7de",
+      "bg": "#f6f8fa"
+    },
+    "continue_message": {
+      "fg": "#0969da",
+      "bg": "#ffffff"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#6e7781",
+      "function": "#8250df",
+      "keyword": "#cf222e",
+      "number": "#0550ae",
+      "string": "#0a3069",
+      "type": "#953800",
+      "variable": "#24292f"
+    },
+    "exact": {
+      "comment.documentation": "#57606a",
+      "function.call": "#8250df",
+      "keyword.return": "#cf222e",
+      "string.escape": "#0550ae",
+      "variable.parameter": "#24292f"
+    }
+  }
+}

internal/theme/themes/gruvbox-dark.json

@@ -0,0 +1,79 @@
+{
+  "name": "gruvbox-dark",
+  "line": {
+    "fg": "#ebdbb2",
+    "bg": "#282828"
+  },
+  "background": {
+    "bg": "#282828"
+  },
+  "visual_highlight": {
+    "bg": "#504945"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#282828",
+      "bg": "#ebdbb2"
+    },
+    "insert": {
+      "fg": "#282828",
+      "bg": "#b8bb26"
+    },
+    "command": {
+      "fg": "#282828",
+      "bg": "#83a598"
+    },
+    "replace": {
+      "fg": "#282828",
+      "bg": "#fb4934"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#928374",
+      "bg": "#282828"
+    },
+    "current_line": {
+      "fg": "#ebdbb2",
+      "bg": "#3c3836"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#a89984",
+      "bg": "#3c3836"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#fb4934",
+      "bg": "#282828"
+    },
+    "output_border": {
+      "fg": "#504945",
+      "bg": "#3c3836"
+    },
+    "continue_message": {
+      "fg": "#83a598",
+      "bg": "#282828"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#928374",
+      "function": "#b8bb26",
+      "keyword": "#fb4934",
+      "number": "#d3869b",
+      "string": "#b8bb26",
+      "type": "#fabd2f",
+      "variable": "#ebdbb2"
+    },
+    "exact": {
+      "comment.documentation": "#a89984",
+      "function.call": "#8ec07c",
+      "keyword.return": "#fb4934",
+      "string.escape": "#fe8019",
+      "variable.parameter": "#83a598"
+    }
+  }
+}

internal/theme/themes/gruvbox-light.json

@@ -0,0 +1,79 @@
+{
+  "name": "gruvbox-light",
+  "line": {
+    "fg": "#3c3836",
+    "bg": "#fbf1c7"
+  },
+  "background": {
+    "bg": "#fbf1c7"
+  },
+  "visual_highlight": {
+    "bg": "#ebdbb2"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#fbf1c7",
+      "bg": "#3c3836"
+    },
+    "insert": {
+      "fg": "#fbf1c7",
+      "bg": "#79740e"
+    },
+    "command": {
+      "fg": "#fbf1c7",
+      "bg": "#076678"
+    },
+    "replace": {
+      "fg": "#fbf1c7",
+      "bg": "#9d0006"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#928374",
+      "bg": "#fbf1c7"
+    },
+    "current_line": {
+      "fg": "#3c3836",
+      "bg": "#f2e5bc"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#665c54",
+      "bg": "#f2e5bc"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#9d0006",
+      "bg": "#fbf1c7"
+    },
+    "output_border": {
+      "fg": "#ebdbb2",
+      "bg": "#f2e5bc"
+    },
+    "continue_message": {
+      "fg": "#076678",
+      "bg": "#fbf1c7"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#928374",
+      "function": "#79740e",
+      "keyword": "#9d0006",
+      "number": "#8f3f71",
+      "string": "#79740e",
+      "type": "#b57614",
+      "variable": "#3c3836"
+    },
+    "exact": {
+      "comment.documentation": "#7c6f64",
+      "function.call": "#427b58",
+      "keyword.return": "#9d0006",
+      "string.escape": "#af3a03",
+      "variable.parameter": "#076678"
+    }
+  }
+}

internal/theme/themes/kanagawa-dragon.json

@@ -0,0 +1,153 @@
+{
+  "name": "kanagawa-dragon",
+  "line": {
+    "fg": "#c5c9c5",
+    "bg": "#181616"
+  },
+  "background": {
+    "bg": "#181616"
+  },
+  "visual_highlight": {
+    "bg": "#223249"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#181616",
+      "bg": "#c5c9c5"
+    },
+    "insert": {
+      "fg": "#181616",
+      "bg": "#c5c9c5"
+    },
+    "command": {
+      "fg": "#181616",
+      "bg": "#c5c9c5"
+    },
+    "replace": {
+      "fg": "#181616",
+      "bg": "#c5c9c5"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#625e5a",
+      "bg": "#282727"
+    },
+    "current_line": {
+      "fg": "#c4b28a",
+      "bg": "#282727"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#c5c9c5",
+      "bg": "#282727"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#e82424",
+      "bg": "#181616"
+    },
+    "output_border": {
+      "fg": "#c5c9c5",
+      "bg": "#0d0c0c"
+    },
+    "continue_message": {
+      "fg": "#8ba4b0",
+      "bg": "#181616"
+    }
+  },
+  "syntax": {
+    "group": {
+      "attribute": "#c4b28a",
+      "boolean": "#a292a3",
+      "character": "#8a9a7b",
+      "charset": "#8ea4a2",
+      "comment": "#737c73",
+      "conceal": "#737c73",
+      "constant": "#b6927b",
+      "constructor": "#c4b28a",
+      "error": "#e82424",
+      "function": "#8ba4b0",
+      "import": "#8992a7",
+      "interface": "#8ea4a2",
+      "keyframes": "#c4746e",
+      "keyword": "#8992a7",
+      "label": "#949fb5",
+      "media": "#c4746e",
+      "module": "#949fb5",
+      "namespace": "#949fb5",
+      "none": "#c5c9c5",
+      "nospell": "#c5c9c5",
+      "number": "#a292a3",
+      "operator": "#c4746e",
+      "property": "#c4b28a",
+      "spell": "#c5c9c5",
+      "string": "#8a9a7b",
+      "supports": "#c4746e",
+      "tag": "#8ba4b0",
+      "type": "#8ea4a2",
+      "variable": "#c5c9c5"
+    },
+    "exact": {
+      "attribute.builtin": "#c4b28a",
+      "character.special": "#c4746e",
+      "comment.documentation": "#a6a69c",
+      "constant.builtin": "#b6927b",
+      "constant.macro": "#c4746e",
+      "function.builtin": "#949fb5",
+      "function.call": "#8ba4b0",
+      "function.macro": "#c4746e",
+      "function.method": "#8ba4b0",
+      "function.method.call": "#8ba4b0",
+      "keyword.conditional": "#8992a7",
+      "keyword.conditional.ternary": "#8992a7",
+      "keyword.coroutine": "#8992a7",
+      "keyword.debug": "#8992a7",
+      "keyword.directive": "#c4746e",
+      "keyword.directive.define": "#c4746e",
+      "keyword.exception": "#8992a7",
+      "keyword.function": "#8992a7",
+      "keyword.import": "#8992a7",
+      "keyword.modifier": "#8992a7",
+      "keyword.operator": "#c4746e",
+      "keyword.repeat": "#8992a7",
+      "keyword.return": "#8992a7",
+      "keyword.type": "#8ea4a2",
+      "markup.heading": "#c4b28a",
+      "markup.heading.1": "#c4b28a",
+      "markup.heading.2": "#b6927b",
+      "markup.heading.3": "#a292a3",
+      "markup.heading.4": "#949fb5",
+      "markup.heading.5": "#8ba4b0",
+      "markup.heading.6": "#8ea4a2",
+      "markup.italic": "#a6a69c",
+      "markup.link.label": "#8ba4b0",
+      "markup.raw": "#8a9a7b",
+      "markup.strikethrough": "#737c73",
+      "markup.strong": "#c5c9c5",
+      "markup.underline": "#949fb5",
+      "module.builtin": "#949fb5",
+      "number.float": "#a292a3",
+      "punctuation.bracket": "#9e9b93",
+      "punctuation.delimiter": "#9e9b93",
+      "punctuation.special": "#c4746e",
+      "string.documentation": "#a6a69c",
+      "string.escape": "#c4746e",
+      "string.regexp": "#c4746e",
+      "string.special.path": "#8a9a7b",
+      "string.special.symbol": "#b6927b",
+      "string.special.url": "#8ba4b0",
+      "tag.attribute": "#c4b28a",
+      "tag.attribute.url": "#8ba4b0",
+      "tag.builtin": "#949fb5",
+      "tag.delimiter": "#9e9b93",
+      "type.builtin": "#8ea4a2",
+      "type.definition": "#8ea4a2",
+      "variable.builtin": "#b6927b",
+      "variable.member": "#c4b28a",
+      "variable.parameter": "#a6a69c"
+    }
+  }
+}

internal/theme/themes/kanagawa-dragon.xml

@@ -1,83 +0,0 @@
-<style name="kanagawa-dragon">
-  <entry type="Background" style="bg:#181616 #c5c9c5" />
-  <entry type="CodeLine" style="#c5c9c5" />
-  <entry type="Error" style="#e82424" />
-  <entry type="Other" style="#c5c9c5" />
-  <entry type="LineTableTD" style="" />
-  <entry type="LineTable" style="" />
-  <entry type="LineHighlight" style="bg:#393836" />
-  <entry type="LineNumbersTable" style="#625e5a" />
-  <entry type="LineNumbers" style="#625e5a" />
-  <entry type="Keyword" style="#8992a7" />
-  <entry type="KeywordReserved" style="#8992a7" />
-  <entry type="KeywordPseudo" style="#8992a7" />
-  <entry type="KeywordConstant" style="#b6927b" />
-  <entry type="KeywordDeclaration" style="#8992a7" />
-  <entry type="KeywordNamespace" style="#c4b28a" />
-  <entry type="KeywordType" style="#8ea4a2" />
-  <entry type="Name" style="#c5c9c5" />
-  <entry type="NameClass" style="#8ea4a2" />
-  <entry type="NameConstant" style="#b6927b" />
-  <entry type="NameDecorator" style="bold #b6927b" />
-  <entry type="NameEntity" style="#c4b28a" />
-  <entry type="NameException" style="#b6927b" />
-  <entry type="NameFunction" style="#8ba4b0" />
-  <entry type="NameFunctionMagic" style="#8ba4b0" />
-  <entry type="NameLabel" style="#949fb5" />
-  <entry type="NameNamespace" style="#c4b28a" />
-  <entry type="NameProperty" style="#c4b28a" />
-  <entry type="NameTag" style="#8ba4b0" />
-  <entry type="NameVariable" style="#c5c9c5" />
-  <entry type="NameVariableClass" style="#c5c9c5" />
-  <entry type="NameVariableGlobal" style="#c5c9c5" />
-  <entry type="NameVariableInstance" style="#c5c9c5" />
-  <entry type="NameVariableMagic" style="#c5c9c5" />
-  <entry type="NameAttribute" style="#c4b28a" />
-  <entry type="NameBuiltin" style="#c4746e" />
-  <entry type="NameBuiltinPseudo" style="#c4746e" />
-  <entry type="NameOther" style="#c5c9c5" />
-  <entry type="Literal" style="#c5c9c5" />
-  <entry type="LiteralDate" style="#c5c9c5" />
-  <entry type="LiteralString" style="#8a9a7b" />
-  <entry type="LiteralStringChar" style="#8a9a7b" />
-  <entry type="LiteralStringSingle" style="#8a9a7b" />
-  <entry type="LiteralStringDouble" style="#8a9a7b" />
-  <entry type="LiteralStringBacktick" style="#8a9a7b" />
-  <entry type="LiteralStringOther" style="#8a9a7b" />
-  <entry type="LiteralStringSymbol" style="#8a9a7b" />
-  <entry type="LiteralStringInterpol" style="#949fb5" />
-  <entry type="LiteralStringAffix" style="#c4746e" />
-  <entry type="LiteralStringDelimiter" style="#949fb5" />
-  <entry type="LiteralStringEscape" style="#c4746e" />
-  <entry type="LiteralStringRegex" style="#c4746e" />
-  <entry type="LiteralStringDoc" style="#737c73" />
-  <entry type="LiteralStringHeredoc" style="#737c73" />
-  <entry type="LiteralNumber" style="#a292a3" />
-  <entry type="LiteralNumberBin" style="#a292a3" />
-  <entry type="LiteralNumberHex" style="#a292a3" />
-  <entry type="LiteralNumberInteger" style="#a292a3" />
-  <entry type="LiteralNumberFloat" style="#a292a3" />
-  <entry type="LiteralNumberIntegerLong" style="#a292a3" />
-  <entry type="LiteralNumberOct" style="#a292a3" />
-  <entry type="Operator" style="bold #c4746e" />
-  <entry type="OperatorWord" style="bold #c4746e" />
-  <entry type="Comment" style="italic #737c73" />
-  <entry type="CommentSingle" style="italic #737c73" />
-  <entry type="CommentMultiline" style="italic #737c73" />
-  <entry type="CommentSpecial" style="italic #737c73" />
-  <entry type="CommentHashbang" style="italic #737c73" />
-  <entry type="CommentPreproc" style="italic #c4746e" />
-  <entry type="CommentPreprocFile" style="bold #c4746e" />
-  <entry type="Generic" style="#c5c9c5" />
-  <entry type="GenericInserted" style="bg:#2b3328 #76946a" />
-  <entry type="GenericDeleted" style="bg:#43242b #c34043" />
-  <entry type="GenericEmph" style="italic #c5c9c5" />
-  <entry type="GenericStrong" style="bold #c5c9c5" />
-  <entry type="GenericUnderline" style="underline #c5c9c5" />
-  <entry type="GenericHeading" style="bold #8ba4b0" />
-  <entry type="GenericSubheading" style="bold #8ba4b0" />
-  <entry type="GenericOutput" style="#c5c9c5" />
-  <entry type="GenericPrompt" style="#c5c9c5" />
-  <entry type="GenericError" style="#e82424" />
-  <entry type="GenericTraceback" style="#e82424" />
-</style>

internal/theme/themes/kanagawa-lotus.json

@@ -0,0 +1,153 @@
+{
+  "name": "kanagawa-lotus",
+  "line": {
+    "fg": "#545464",
+    "bg": "#f2ecbc"
+  },
+  "background": {
+    "bg": "#f2ecbc"
+  },
+  "visual_highlight": {
+    "bg": "#c9cbd1"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#f2ecbc",
+      "bg": "#545464"
+    },
+    "insert": {
+      "fg": "#f2ecbc",
+      "bg": "#545464"
+    },
+    "command": {
+      "fg": "#f2ecbc",
+      "bg": "#545464"
+    },
+    "replace": {
+      "fg": "#f2ecbc",
+      "bg": "#545464"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#a09cac",
+      "bg": "#e7dba0"
+    },
+    "current_line": {
+      "fg": "#77713f",
+      "bg": "#e7dba0"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#43436c",
+      "bg": "#e7dba0"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#e82424",
+      "bg": "#f2ecbc"
+    },
+    "output_border": {
+      "fg": "#545464",
+      "bg": "#e7dba0"
+    },
+    "continue_message": {
+      "fg": "#4d699b",
+      "bg": "#f2ecbc"
+    }
+  },
+  "syntax": {
+    "group": {
+      "attribute": "#77713f",
+      "boolean": "#b35b79",
+      "character": "#6f894e",
+      "charset": "#597b75",
+      "comment": "#8a8980",
+      "conceal": "#8a8980",
+      "constant": "#cc6d00",
+      "constructor": "#77713f",
+      "error": "#e82424",
+      "function": "#4d699b",
+      "import": "#624c83",
+      "interface": "#597b75",
+      "keyframes": "#c84053",
+      "keyword": "#624c83",
+      "label": "#6693bf",
+      "media": "#c84053",
+      "module": "#6693bf",
+      "namespace": "#6693bf",
+      "none": "#545464",
+      "nospell": "#545464",
+      "number": "#b35b79",
+      "operator": "#836f4a",
+      "property": "#77713f",
+      "spell": "#545464",
+      "string": "#6f894e",
+      "supports": "#c84053",
+      "tag": "#4d699b",
+      "type": "#597b75",
+      "variable": "#545464"
+    },
+    "exact": {
+      "attribute.builtin": "#77713f",
+      "character.special": "#836f4a",
+      "comment.documentation": "#716e61",
+      "constant.builtin": "#cc6d00",
+      "constant.macro": "#c84053",
+      "function.builtin": "#6693bf",
+      "function.call": "#4d699b",
+      "function.macro": "#c84053",
+      "function.method": "#4d699b",
+      "function.method.call": "#4d699b",
+      "keyword.conditional": "#624c83",
+      "keyword.conditional.ternary": "#624c83",
+      "keyword.coroutine": "#624c83",
+      "keyword.debug": "#624c83",
+      "keyword.directive": "#c84053",
+      "keyword.directive.define": "#c84053",
+      "keyword.exception": "#624c83",
+      "keyword.function": "#624c83",
+      "keyword.import": "#624c83",
+      "keyword.modifier": "#624c83",
+      "keyword.operator": "#836f4a",
+      "keyword.repeat": "#624c83",
+      "keyword.return": "#624c83",
+      "keyword.type": "#597b75",
+      "markup.heading": "#77713f",
+      "markup.heading.1": "#77713f",
+      "markup.heading.2": "#836f4a",
+      "markup.heading.3": "#cc6d00",
+      "markup.heading.4": "#4d699b",
+      "markup.heading.5": "#624c83",
+      "markup.heading.6": "#6693bf",
+      "markup.italic": "#716e61",
+      "markup.link.label": "#4d699b",
+      "markup.raw": "#6f894e",
+      "markup.strikethrough": "#8a8980",
+      "markup.strong": "#545464",
+      "markup.underline": "#6693bf",
+      "module.builtin": "#6693bf",
+      "number.float": "#b35b79",
+      "punctuation.bracket": "#4e8ca2",
+      "punctuation.delimiter": "#4e8ca2",
+      "punctuation.special": "#836f4a",
+      "string.documentation": "#716e61",
+      "string.escape": "#836f4a",
+      "string.regexp": "#836f4a",
+      "string.special.path": "#6f894e",
+      "string.special.symbol": "#cc6d00",
+      "string.special.url": "#4d699b",
+      "tag.attribute": "#77713f",
+      "tag.attribute.url": "#4d699b",
+      "tag.builtin": "#6693bf",
+      "tag.delimiter": "#4e8ca2",
+      "type.builtin": "#597b75",
+      "type.definition": "#597b75",
+      "variable.builtin": "#c84053",
+      "variable.member": "#77713f",
+      "variable.parameter": "#5d57a3"
+    }
+  }
+}

internal/theme/themes/kanagawa-lotus.xml

@@ -1,83 +0,0 @@
-<style name="kanagawa-lotus">
-  <entry type="Background" style="bg:#f2ecbc #545464" />
-  <entry type="CodeLine" style="#545464" />
-  <entry type="Error" style="#e82424" />
-  <entry type="Other" style="#545464" />
-  <entry type="LineTableTD" style="" />
-  <entry type="LineTable" style="" />
-  <entry type="LineHighlight" style="bg:#e4d794" />
-  <entry type="LineNumbersTable" style="#a09cac" />
-  <entry type="LineNumbers" style="#a09cac" />
-  <entry type="Keyword" style="#624c83" />
-  <entry type="KeywordReserved" style="#624c83" />
-  <entry type="KeywordPseudo" style="#624c83" />
-  <entry type="KeywordConstant" style="#cc6d00" />
-  <entry type="KeywordDeclaration" style="#624c83" />
-  <entry type="KeywordNamespace" style="#77713f" />
-  <entry type="KeywordType" style="#597b75" />
-  <entry type="Name" style="#545464" />
-  <entry type="NameClass" style="#597b75" />
-  <entry type="NameConstant" style="#cc6d00" />
-  <entry type="NameDecorator" style="bold #cc6d00" />
-  <entry type="NameEntity" style="#77713f" />
-  <entry type="NameException" style="#cc6d00" />
-  <entry type="NameFunction" style="#4d699b" />
-  <entry type="NameFunctionMagic" style="#4d699b" />
-  <entry type="NameLabel" style="#6693bf" />
-  <entry type="NameNamespace" style="#77713f" />
-  <entry type="NameProperty" style="#77713f" />
-  <entry type="NameTag" style="#4d699b" />
-  <entry type="NameVariable" style="#545464" />
-  <entry type="NameVariableClass" style="#545464" />
-  <entry type="NameVariableGlobal" style="#545464" />
-  <entry type="NameVariableInstance" style="#545464" />
-  <entry type="NameVariableMagic" style="#545464" />
-  <entry type="NameAttribute" style="#77713f" />
-  <entry type="NameBuiltin" style="#c84053" />
-  <entry type="NameBuiltinPseudo" style="#c84053" />
-  <entry type="NameOther" style="#545464" />
-  <entry type="Literal" style="#545464" />
-  <entry type="LiteralDate" style="#545464" />
-  <entry type="LiteralString" style="#6f894e" />
-  <entry type="LiteralStringChar" style="#6f894e" />
-  <entry type="LiteralStringSingle" style="#6f894e" />
-  <entry type="LiteralStringDouble" style="#6f894e" />
-  <entry type="LiteralStringBacktick" style="#6f894e" />
-  <entry type="LiteralStringOther" style="#6f894e" />
-  <entry type="LiteralStringSymbol" style="#6f894e" />
-  <entry type="LiteralStringInterpol" style="#6693bf" />
-  <entry type="LiteralStringAffix" style="#c84053" />
-  <entry type="LiteralStringDelimiter" style="#6693bf" />
-  <entry type="LiteralStringEscape" style="#836f4a" />
-  <entry type="LiteralStringRegex" style="#836f4a" />
-  <entry type="LiteralStringDoc" style="#8a8980" />
-  <entry type="LiteralStringHeredoc" style="#8a8980" />
-  <entry type="LiteralNumber" style="#b35b79" />
-  <entry type="LiteralNumberBin" style="#b35b79" />
-  <entry type="LiteralNumberHex" style="#b35b79" />
-  <entry type="LiteralNumberInteger" style="#b35b79" />
-  <entry type="LiteralNumberFloat" style="#b35b79" />
-  <entry type="LiteralNumberIntegerLong" style="#b35b79" />
-  <entry type="LiteralNumberOct" style="#b35b79" />
-  <entry type="Operator" style="bold #836f4a" />
-  <entry type="OperatorWord" style="bold #836f4a" />
-  <entry type="Comment" style="italic #8a8980" />
-  <entry type="CommentSingle" style="italic #8a8980" />
-  <entry type="CommentMultiline" style="italic #8a8980" />
-  <entry type="CommentSpecial" style="italic #8a8980" />
-  <entry type="CommentHashbang" style="italic #8a8980" />
-  <entry type="CommentPreproc" style="italic #c84053" />
-  <entry type="CommentPreprocFile" style="bold #c84053" />
-  <entry type="Generic" style="#545464" />
-  <entry type="GenericInserted" style="bg:#b7d0ae #6e915f" />
-  <entry type="GenericDeleted" style="bg:#d9a594 #d7474b" />
-  <entry type="GenericEmph" style="italic #545464" />
-  <entry type="GenericStrong" style="bold #545464" />
-  <entry type="GenericUnderline" style="underline #545464" />
-  <entry type="GenericHeading" style="bold #4d699b" />
-  <entry type="GenericSubheading" style="bold #4d699b" />
-  <entry type="GenericOutput" style="#545464" />
-  <entry type="GenericPrompt" style="#545464" />
-  <entry type="GenericError" style="#e82424" />
-  <entry type="GenericTraceback" style="#e82424" />
-</style>

internal/theme/themes/kanagawa-wave.xml

@@ -1,83 +0,0 @@
-<style name="kanagawa-wave">
-  <entry type="Background" style="bg:#1f1f28 #dcd7ba" />
-  <entry type="CodeLine" style="#dcd7ba" />
-  <entry type="Error" style="#e82424" />
-  <entry type="Other" style="#dcd7ba" />
-  <entry type="LineTableTD" style="" />
-  <entry type="LineTable" style="" />
-  <entry type="LineHighlight" style="bg:#363646" />
-  <entry type="LineNumbersTable" style="#54546d" />
-  <entry type="LineNumbers" style="#54546d" />
-  <entry type="Keyword" style="#957fb8" />
-  <entry type="KeywordReserved" style="#957fb8" />
-  <entry type="KeywordPseudo" style="#957fb8" />
-  <entry type="KeywordConstant" style="#ffa066" />
-  <entry type="KeywordDeclaration" style="#957fb8" />
-  <entry type="KeywordNamespace" style="#e6c384" />
-  <entry type="KeywordType" style="#7aa89f" />
-  <entry type="Name" style="#dcd7ba" />
-  <entry type="NameClass" style="#7aa89f" />
-  <entry type="NameConstant" style="#ffa066" />
-  <entry type="NameDecorator" style="bold #ffa066" />
-  <entry type="NameEntity" style="#e6c384" />
-  <entry type="NameException" style="#ffa066" />
-  <entry type="NameFunction" style="#7e9cd8" />
-  <entry type="NameFunctionMagic" style="#7e9cd8" />
-  <entry type="NameLabel" style="#7fb4ca" />
-  <entry type="NameNamespace" style="#e6c384" />
-  <entry type="NameProperty" style="#e6c384" />
-  <entry type="NameTag" style="#7e9cd8" />
-  <entry type="NameVariable" style="#dcd7ba" />
-  <entry type="NameVariableClass" style="#dcd7ba" />
-  <entry type="NameVariableGlobal" style="#dcd7ba" />
-  <entry type="NameVariableInstance" style="#dcd7ba" />
-  <entry type="NameVariableMagic" style="#dcd7ba" />
-  <entry type="NameAttribute" style="#e6c384" />
-  <entry type="NameBuiltin" style="#e46876" />
-  <entry type="NameBuiltinPseudo" style="#e46876" />
-  <entry type="NameOther" style="#dcd7ba" />
-  <entry type="Literal" style="#dcd7ba" />
-  <entry type="LiteralDate" style="#dcd7ba" />
-  <entry type="LiteralString" style="#98bb6c" />
-  <entry type="LiteralStringChar" style="#98bb6c" />
-  <entry type="LiteralStringSingle" style="#98bb6c" />
-  <entry type="LiteralStringDouble" style="#98bb6c" />
-  <entry type="LiteralStringBacktick" style="#98bb6c" />
-  <entry type="LiteralStringOther" style="#98bb6c" />
-  <entry type="LiteralStringSymbol" style="#98bb6c" />
-  <entry type="LiteralStringInterpol" style="#7fb4ca" />
-  <entry type="LiteralStringAffix" style="#ff5d62" />
-  <entry type="LiteralStringDelimiter" style="#7fb4ca" />
-  <entry type="LiteralStringEscape" style="#c0a36e" />
-  <entry type="LiteralStringRegex" style="#c0a36e" />
-  <entry type="LiteralStringDoc" style="#727169" />
-  <entry type="LiteralStringHeredoc" style="#727169" />
-  <entry type="LiteralNumber" style="#d27e99" />
-  <entry type="LiteralNumberBin" style="#d27e99" />
-  <entry type="LiteralNumberHex" style="#d27e99" />
-  <entry type="LiteralNumberInteger" style="#d27e99" />
-  <entry type="LiteralNumberFloat" style="#d27e99" />
-  <entry type="LiteralNumberIntegerLong" style="#d27e99" />
-  <entry type="LiteralNumberOct" style="#d27e99" />
-  <entry type="Operator" style="bold #c0a36e" />
-  <entry type="OperatorWord" style="bold #c0a36e" />
-  <entry type="Comment" style="italic #727169" />
-  <entry type="CommentSingle" style="italic #727169" />
-  <entry type="CommentMultiline" style="italic #727169" />
-  <entry type="CommentSpecial" style="italic #727169" />
-  <entry type="CommentHashbang" style="italic #727169" />
-  <entry type="CommentPreproc" style="italic #e46876" />
-  <entry type="CommentPreprocFile" style="bold #e46876" />
-  <entry type="Generic" style="#dcd7ba" />
-  <entry type="GenericInserted" style="bg:#2b3328 #76946a" />
-  <entry type="GenericDeleted" style="bg:#43242b #c34043" />
-  <entry type="GenericEmph" style="italic #dcd7ba" />
-  <entry type="GenericStrong" style="bold #dcd7ba" />
-  <entry type="GenericUnderline" style="underline #dcd7ba" />
-  <entry type="GenericHeading" style="bold #7e9cd8" />
-  <entry type="GenericSubheading" style="bold #7e9cd8" />
-  <entry type="GenericOutput" style="#dcd7ba" />
-  <entry type="GenericPrompt" style="#dcd7ba" />
-  <entry type="GenericError" style="#e82424" />
-  <entry type="GenericTraceback" style="#e82424" />
-</style>

internal/theme/themes/kanagawa.json

@@ -0,0 +1,153 @@
+{
+  "name": "kanagawa",
+  "line": {
+    "fg": "#dcd7ba",
+    "bg": "#1f1f28"
+  },
+  "background": {
+    "bg": "#1f1f28"
+  },
+  "visual_highlight": {
+    "bg": "#223249"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#1f1f28",
+      "bg": "#dcd7ba"
+    },
+    "insert": {
+      "fg": "#1f1f28",
+      "bg": "#dcd7ba"
+    },
+    "command": {
+      "fg": "#1f1f28",
+      "bg": "#dcd7ba"
+    },
+    "replace": {
+      "fg": "#1f1f28",
+      "bg": "#dcd7ba"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#727169",
+      "bg": "#2a2a37"
+    },
+    "current_line": {
+      "fg": "#e6c384",
+      "bg": "#2a2a37"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#c8c093",
+      "bg": "#2a2a37"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#e82424",
+      "bg": "#1f1f28"
+    },
+    "output_border": {
+      "fg": "#dcd7ba",
+      "bg": "#16161d"
+    },
+    "continue_message": {
+      "fg": "#7e9cd8",
+      "bg": "#1f1f28"
+    }
+  },
+  "syntax": {
+    "group": {
+      "attribute": "#e6c384",
+      "boolean": "#d27e99",
+      "character": "#98bb6c",
+      "charset": "#7aa89f",
+      "comment": "#727169",
+      "conceal": "#727169",
+      "constant": "#ffa066",
+      "constructor": "#e6c384",
+      "error": "#e82424",
+      "function": "#7e9cd8",
+      "import": "#957fb8",
+      "interface": "#7aa89f",
+      "keyframes": "#e46876",
+      "keyword": "#957fb8",
+      "label": "#e46876",
+      "media": "#e46876",
+      "module": "#7fb4ca",
+      "namespace": "#7fb4ca",
+      "none": "#dcd7ba",
+      "nospell": "#dcd7ba",
+      "number": "#d27e99",
+      "operator": "#c0a36e",
+      "property": "#e6c384",
+      "spell": "#dcd7ba",
+      "string": "#98bb6c",
+      "supports": "#e46876",
+      "tag": "#7fb4ca",
+      "type": "#7aa89f",
+      "variable": "#dcd7ba"
+    },
+    "exact": {
+      "attribute.builtin": "#e6c384",
+      "character.special": "#c0a36e",
+      "comment.documentation": "#c8c093",
+      "constant.builtin": "#ffa066",
+      "constant.macro": "#e46876",
+      "function.builtin": "#7fb4ca",
+      "function.call": "#7e9cd8",
+      "function.macro": "#e46876",
+      "function.method": "#7e9cd8",
+      "function.method.call": "#7e9cd8",
+      "keyword.conditional": "#957fb8",
+      "keyword.conditional.ternary": "#957fb8",
+      "keyword.coroutine": "#957fb8",
+      "keyword.debug": "#957fb8",
+      "keyword.directive": "#e46876",
+      "keyword.directive.define": "#e46876",
+      "keyword.exception": "#957fb8",
+      "keyword.function": "#957fb8",
+      "keyword.import": "#957fb8",
+      "keyword.modifier": "#957fb8",
+      "keyword.operator": "#c0a36e",
+      "keyword.repeat": "#957fb8",
+      "keyword.return": "#957fb8",
+      "keyword.type": "#7aa89f",
+      "markup.heading": "#e6c384",
+      "markup.heading.1": "#e6c384",
+      "markup.heading.2": "#dca561",
+      "markup.heading.3": "#c0a36e",
+      "markup.heading.4": "#b6927b",
+      "markup.heading.5": "#957fb8",
+      "markup.heading.6": "#7e9cd8",
+      "markup.italic": "#b8b4d0",
+      "markup.link.label": "#7e9cd8",
+      "markup.raw": "#98bb6c",
+      "markup.strikethrough": "#727169",
+      "markup.strong": "#c8c093",
+      "markup.underline": "#7fb4ca",
+      "module.builtin": "#7fb4ca",
+      "number.float": "#d27e99",
+      "punctuation.bracket": "#9cabca",
+      "punctuation.delimiter": "#9cabca",
+      "punctuation.special": "#c0a36e",
+      "string.documentation": "#c8c093",
+      "string.escape": "#c0a36e",
+      "string.regexp": "#c0a36e",
+      "string.special.path": "#98bb6c",
+      "string.special.symbol": "#ffa066",
+      "string.special.url": "#7e9cd8",
+      "tag.attribute": "#e6c384",
+      "tag.attribute.url": "#7e9cd8",
+      "tag.builtin": "#7fb4ca",
+      "tag.delimiter": "#9cabca",
+      "type.builtin": "#7aa89f",
+      "type.definition": "#7aa89f",
+      "variable.builtin": "#ffa066",
+      "variable.member": "#e6c384",
+      "variable.parameter": "#b8b4d0"
+    }
+  }
+}

internal/theme/themes/material-deep-ocean.json

@@ -0,0 +1,79 @@
+{
+  "name": "material-deep-ocean",
+  "line": {
+    "fg": "#a6accd",
+    "bg": "#0f111a"
+  },
+  "background": {
+    "bg": "#0f111a"
+  },
+  "visual_highlight": {
+    "bg": "#1f2233"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#0f111a",
+      "bg": "#80cbc4"
+    },
+    "insert": {
+      "fg": "#0f111a",
+      "bg": "#c3e88d"
+    },
+    "command": {
+      "fg": "#0f111a",
+      "bg": "#82aaff"
+    },
+    "replace": {
+      "fg": "#0f111a",
+      "bg": "#ff5370"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#464b5d",
+      "bg": "#0f111a"
+    },
+    "current_line": {
+      "fg": "#a6accd",
+      "bg": "#090b10"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#a6accd",
+      "bg": "#090b10"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#ff5370",
+      "bg": "#0f111a"
+    },
+    "output_border": {
+      "fg": "#1f2233",
+      "bg": "#090b10"
+    },
+    "continue_message": {
+      "fg": "#82aaff",
+      "bg": "#0f111a"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#464b5d",
+      "function": "#82aaff",
+      "keyword": "#c792ea",
+      "number": "#f78c6c",
+      "string": "#c3e88d",
+      "type": "#ffcb6b",
+      "variable": "#a6accd"
+    },
+    "exact": {
+      "comment.documentation": "#546e7a",
+      "function.call": "#82aaff",
+      "keyword.return": "#ff5370",
+      "string.escape": "#89ddff",
+      "variable.parameter": "#7986cb"
+    }
+  }
+}

internal/theme/themes/material-palenight.json

@@ -0,0 +1,79 @@
+{
+  "name": "material-palenight",
+  "line": {
+    "fg": "#a6accd",
+    "bg": "#292d3e"
+  },
+  "background": {
+    "bg": "#292d3e"
+  },
+  "visual_highlight": {
+    "bg": "#3c435e"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#292d3e",
+      "bg": "#ffcb6b"
+    },
+    "insert": {
+      "fg": "#292d3e",
+      "bg": "#c3e88d"
+    },
+    "command": {
+      "fg": "#292d3e",
+      "bg": "#c792ea"
+    },
+    "replace": {
+      "fg": "#292d3e",
+      "bg": "#f07178"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#676e95",
+      "bg": "#292d3e"
+    },
+    "current_line": {
+      "fg": "#a6accd",
+      "bg": "#1b1e2b"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#a6accd",
+      "bg": "#1b1e2b"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#f07178",
+      "bg": "#292d3e"
+    },
+    "output_border": {
+      "fg": "#3c435e",
+      "bg": "#1b1e2b"
+    },
+    "continue_message": {
+      "fg": "#82aaff",
+      "bg": "#292d3e"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#676e95",
+      "function": "#82aaff",
+      "keyword": "#c792ea",
+      "number": "#f78c6c",
+      "string": "#c3e88d",
+      "type": "#ffcb6b",
+      "variable": "#a6accd"
+    },
+    "exact": {
+      "comment.documentation": "#a6accd",
+      "function.call": "#82aaff",
+      "keyword.return": "#f07178",
+      "string.escape": "#89ddff",
+      "variable.parameter": "#ff5370"
+    }
+  }
+}

internal/theme/themes/monokai.json

@@ -0,0 +1,79 @@
+{
+  "name": "monokai",
+  "line": {
+    "fg": "#f8f8f2",
+    "bg": "#272822"
+  },
+  "background": {
+    "bg": "#272822"
+  },
+  "visual_highlight": {
+    "bg": "#49483e"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#272822",
+      "bg": "#f8f8f2"
+    },
+    "insert": {
+      "fg": "#272822",
+      "bg": "#a6e22e"
+    },
+    "command": {
+      "fg": "#272822",
+      "bg": "#66d9ef"
+    },
+    "replace": {
+      "fg": "#272822",
+      "bg": "#f92672"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#75715e",
+      "bg": "#272822"
+    },
+    "current_line": {
+      "fg": "#f8f8f2",
+      "bg": "#3e3d32"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#f8f8f2",
+      "bg": "#191919"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#f92672",
+      "bg": "#272822"
+    },
+    "output_border": {
+      "fg": "#49483e",
+      "bg": "#191919"
+    },
+    "continue_message": {
+      "fg": "#66d9ef",
+      "bg": "#272822"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#75715e",
+      "function": "#a6e22e",
+      "keyword": "#f92672",
+      "number": "#ae81ff",
+      "string": "#e6db74",
+      "type": "#66d9ef",
+      "variable": "#fd971f"
+    },
+    "exact": {
+      "comment.documentation": "#75715e",
+      "function.call": "#a6e22e",
+      "keyword.return": "#f92672",
+      "string.escape": "#ae81ff",
+      "variable.parameter": "#fd971f"
+    }
+  }
+}

internal/theme/themes/nord.json

@@ -0,0 +1,79 @@
+{
+  "name": "nord",
+  "line": {
+    "fg": "#d8dee9",
+    "bg": "#2e3440"
+  },
+  "background": {
+    "bg": "#2e3440"
+  },
+  "visual_highlight": {
+    "bg": "#434c5e"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#2e3440",
+      "bg": "#d8dee9"
+    },
+    "insert": {
+      "fg": "#2e3440",
+      "bg": "#a3be8c"
+    },
+    "command": {
+      "fg": "#2e3440",
+      "bg": "#81a1c1"
+    },
+    "replace": {
+      "fg": "#2e3440",
+      "bg": "#bf616a"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#4c566a",
+      "bg": "#2e3440"
+    },
+    "current_line": {
+      "fg": "#d8dee9",
+      "bg": "#3b4252"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#d8dee9",
+      "bg": "#242933"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#bf616a",
+      "bg": "#2e3440"
+    },
+    "output_border": {
+      "fg": "#3b4252",
+      "bg": "#242933"
+    },
+    "continue_message": {
+      "fg": "#88c0d0",
+      "bg": "#2e3440"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#4c566a",
+      "function": "#88c0d0",
+      "keyword": "#81a1c1",
+      "number": "#b48ead",
+      "string": "#a3be8c",
+      "type": "#8fbcbb",
+      "variable": "#d8dee9"
+    },
+    "exact": {
+      "comment.documentation": "#616e88",
+      "function.call": "#88c0d0",
+      "keyword.return": "#81a1c1",
+      "string.escape": "#ebcb8b",
+      "variable.parameter": "#eceff4"
+    }
+  }
+}

internal/theme/themes/onedark.json

@@ -0,0 +1,79 @@
+{
+  "name": "onedark",
+  "line": {
+    "fg": "#abb2bf",
+    "bg": "#282c34"
+  },
+  "background": {
+    "bg": "#282c34"
+  },
+  "visual_highlight": {
+    "bg": "#3e4452"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#282c34",
+      "bg": "#61afef"
+    },
+    "insert": {
+      "fg": "#282c34",
+      "bg": "#98c379"
+    },
+    "command": {
+      "fg": "#282c34",
+      "bg": "#c678dd"
+    },
+    "replace": {
+      "fg": "#282c34",
+      "bg": "#e06c75"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#4b5263",
+      "bg": "#282c34"
+    },
+    "current_line": {
+      "fg": "#abb2bf",
+      "bg": "#2c323c"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#abb2bf",
+      "bg": "#21252b"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#e06c75",
+      "bg": "#282c34"
+    },
+    "output_border": {
+      "fg": "#181a1f",
+      "bg": "#21252b"
+    },
+    "continue_message": {
+      "fg": "#61afef",
+      "bg": "#282c34"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#5c6370",
+      "function": "#61afef",
+      "keyword": "#c678dd",
+      "number": "#d19a66",
+      "string": "#98c379",
+      "type": "#e5c07b",
+      "variable": "#e06c75"
+    },
+    "exact": {
+      "comment.documentation": "#5c6370",
+      "function.call": "#61afef",
+      "keyword.return": "#c678dd",
+      "string.escape": "#56b6c2",
+      "variable.parameter": "#d19a66"
+    }
+  }
+}

internal/theme/themes/oxocarbon.json

@@ -0,0 +1,79 @@
+{
+  "name": "oxocarbon",
+  "line": {
+    "fg": "#ffffff",
+    "bg": "#161616"
+  },
+  "background": {
+    "bg": "#161616"
+  },
+  "visual_highlight": {
+    "bg": "#393939"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#161616",
+      "bg": "#ffffff"
+    },
+    "insert": {
+      "fg": "#161616",
+      "bg": "#42be65"
+    },
+    "command": {
+      "fg": "#161616",
+      "bg": "#be95ff"
+    },
+    "replace": {
+      "fg": "#161616",
+      "bg": "#fa4d56"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#525252",
+      "bg": "#161616"
+    },
+    "current_line": {
+      "fg": "#ffffff",
+      "bg": "#262626"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#dde1e6",
+      "bg": "#000000"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#fa4d56",
+      "bg": "#161616"
+    },
+    "output_border": {
+      "fg": "#393939",
+      "bg": "#000000"
+    },
+    "continue_message": {
+      "fg": "#78a9ff",
+      "bg": "#161616"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#525252",
+      "function": "#ff7eb6",
+      "keyword": "#ee5396",
+      "number": "#3ddbd9",
+      "string": "#42be65",
+      "type": "#82cfff",
+      "variable": "#ffffff"
+    },
+    "exact": {
+      "comment.documentation": "#525252",
+      "function.call": "#ff7eb6",
+      "keyword.return": "#ee5396",
+      "string.escape": "#33b1ff",
+      "variable.parameter": "#ffffff"
+    }
+  }
+}

internal/theme/themes/rose-pine-dawn.json

@@ -0,0 +1,79 @@
+{
+  "name": "rose-pine-dawn",
+  "line": {
+    "fg": "#575279",
+    "bg": "#faf4ed"
+  },
+  "background": {
+    "bg": "#faf4ed"
+  },
+  "visual_highlight": {
+    "bg": "#dfdad9"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#faf4ed",
+      "bg": "#575279"
+    },
+    "insert": {
+      "fg": "#faf4ed",
+      "bg": "#ea9d34"
+    },
+    "command": {
+      "fg": "#faf4ed",
+      "bg": "#907aa9"
+    },
+    "replace": {
+      "fg": "#faf4ed",
+      "bg": "#b4637a"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#9893a5",
+      "bg": "#fffaf3"
+    },
+    "current_line": {
+      "fg": "#575279",
+      "bg": "#fffaf3"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#797593",
+      "bg": "#fffaf3"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#b4637a",
+      "bg": "#faf4ed"
+    },
+    "output_border": {
+      "fg": "#f2e9e1",
+      "bg": "#fffaf3"
+    },
+    "continue_message": {
+      "fg": "#286983",
+      "bg": "#faf4ed"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#9893a5",
+      "function": "#56949f",
+      "keyword": "#286983",
+      "number": "#ea9d34",
+      "string": "#d7827e",
+      "type": "#907aa9",
+      "variable": "#575279"
+    },
+    "exact": {
+      "comment.documentation": "#797593",
+      "function.call": "#56949f",
+      "keyword.return": "#b4637a",
+      "string.escape": "#286983",
+      "variable.parameter": "#575279"
+    }
+  }
+}

internal/theme/themes/rose-pine-moon.json

@@ -0,0 +1,79 @@
+{
+  "name": "rose-pine-moon",
+  "line": {
+    "fg": "#e0def4",
+    "bg": "#232136"
+  },
+  "background": {
+    "bg": "#232136"
+  },
+  "visual_highlight": {
+    "bg": "#44415a"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#232136",
+      "bg": "#e0def4"
+    },
+    "insert": {
+      "fg": "#232136",
+      "bg": "#f6c177"
+    },
+    "command": {
+      "fg": "#232136",
+      "bg": "#c4a7e7"
+    },
+    "replace": {
+      "fg": "#232136",
+      "bg": "#eb6f92"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#6e6a86",
+      "bg": "#2a273f"
+    },
+    "current_line": {
+      "fg": "#e0def4",
+      "bg": "#2a273f"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#908caa",
+      "bg": "#2a273f"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#eb6f92",
+      "bg": "#232136"
+    },
+    "output_border": {
+      "fg": "#393552",
+      "bg": "#2a273f"
+    },
+    "continue_message": {
+      "fg": "#3e8fb0",
+      "bg": "#232136"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#6e6a86",
+      "function": "#9ccfd8",
+      "keyword": "#3e8fb0",
+      "number": "#f6c177",
+      "string": "#ea9a97",
+      "type": "#c4a7e7",
+      "variable": "#e0def4"
+    },
+    "exact": {
+      "comment.documentation": "#908caa",
+      "function.call": "#9ccfd8",
+      "keyword.return": "#eb6f92",
+      "string.escape": "#3e8fb0",
+      "variable.parameter": "#e0def4"
+    }
+  }
+}

internal/theme/themes/rose-pine.json

@@ -0,0 +1,79 @@
+{
+  "name": "rose-pine",
+  "line": {
+    "fg": "#e0def4",
+    "bg": "#191724"
+  },
+  "background": {
+    "bg": "#191724"
+  },
+  "visual_highlight": {
+    "bg": "#403d52"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#191724",
+      "bg": "#e0def4"
+    },
+    "insert": {
+      "fg": "#191724",
+      "bg": "#f6c177"
+    },
+    "command": {
+      "fg": "#191724",
+      "bg": "#c4a7e7"
+    },
+    "replace": {
+      "fg": "#191724",
+      "bg": "#eb6f92"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#6e6a86",
+      "bg": "#1f1d2e"
+    },
+    "current_line": {
+      "fg": "#e0def4",
+      "bg": "#1f1d2e"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#908caa",
+      "bg": "#1f1d2e"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#eb6f92",
+      "bg": "#191724"
+    },
+    "output_border": {
+      "fg": "#26233a",
+      "bg": "#1f1d2e"
+    },
+    "continue_message": {
+      "fg": "#31748f",
+      "bg": "#191724"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#6e6a86",
+      "function": "#9ccfd8",
+      "keyword": "#31748f",
+      "number": "#f6c177",
+      "string": "#ebbcba",
+      "type": "#c4a7e7",
+      "variable": "#e0def4"
+    },
+    "exact": {
+      "comment.documentation": "#908caa",
+      "function.call": "#9ccfd8",
+      "keyword.return": "#eb6f92",
+      "string.escape": "#31748f",
+      "variable.parameter": "#e0def4"
+    }
+  }
+}

internal/theme/themes/solarized-dark.json

@@ -0,0 +1,79 @@
+{
+  "name": "solarized-dark",
+  "line": {
+    "fg": "#839496",
+    "bg": "#002b36"
+  },
+  "background": {
+    "bg": "#002b36"
+  },
+  "visual_highlight": {
+    "bg": "#073642"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#002b36",
+      "bg": "#839496"
+    },
+    "insert": {
+      "fg": "#002b36",
+      "bg": "#859900"
+    },
+    "command": {
+      "fg": "#002b36",
+      "bg": "#268bd2"
+    },
+    "replace": {
+      "fg": "#002b36",
+      "bg": "#dc322f"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#586e75",
+      "bg": "#002b36"
+    },
+    "current_line": {
+      "fg": "#93a1a1",
+      "bg": "#073642"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#839496",
+      "bg": "#00212b"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#dc322f",
+      "bg": "#002b36"
+    },
+    "output_border": {
+      "fg": "#073642",
+      "bg": "#00212b"
+    },
+    "continue_message": {
+      "fg": "#2aa198",
+      "bg": "#002b36"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#586e75",
+      "function": "#268bd2",
+      "keyword": "#859900",
+      "number": "#d33682",
+      "string": "#2aa198",
+      "type": "#b58900",
+      "variable": "#839496"
+    },
+    "exact": {
+      "comment.documentation": "#586e75",
+      "function.call": "#268bd2",
+      "keyword.return": "#dc322f",
+      "string.escape": "#cb4b16",
+      "variable.parameter": "#839496"
+    }
+  }
+}

internal/theme/themes/solarized-light.json

@@ -0,0 +1,79 @@
+{
+  "name": "solarized-light",
+  "line": {
+    "fg": "#657b83",
+    "bg": "#fdf6e3"
+  },
+  "background": {
+    "bg": "#fdf6e3"
+  },
+  "visual_highlight": {
+    "bg": "#eee8d5"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#fdf6e3",
+      "bg": "#657b83"
+    },
+    "insert": {
+      "fg": "#fdf6e3",
+      "bg": "#859900"
+    },
+    "command": {
+      "fg": "#fdf6e3",
+      "bg": "#268bd2"
+    },
+    "replace": {
+      "fg": "#fdf6e3",
+      "bg": "#dc322f"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#93a1a1",
+      "bg": "#fdf6e3"
+    },
+    "current_line": {
+      "fg": "#657b83",
+      "bg": "#eee8d5"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#657b83",
+      "bg": "#eee8d5"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#dc322f",
+      "bg": "#fdf6e3"
+    },
+    "output_border": {
+      "fg": "#eee8d5",
+      "bg": "#eee8d5"
+    },
+    "continue_message": {
+      "fg": "#2aa198",
+      "bg": "#fdf6e3"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#93a1a1",
+      "function": "#268bd2",
+      "keyword": "#859900",
+      "number": "#d33682",
+      "string": "#2aa198",
+      "type": "#b58900",
+      "variable": "#657b83"
+    },
+    "exact": {
+      "comment.documentation": "#93a1a1",
+      "function.call": "#268bd2",
+      "keyword.return": "#dc322f",
+      "string.escape": "#cb4b16",
+      "variable.parameter": "#657b83"
+    }
+  }
+}

internal/theme/themes/tokyo-dark.json

@@ -0,0 +1,79 @@
+{
+  "name": "tokyo-dark",
+  "line": {
+    "fg": "#a9b1d6",
+    "bg": "#11121d"
+  },
+  "background": {
+    "bg": "#11121d"
+  },
+  "visual_highlight": {
+    "bg": "#2d2f44"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#11121d",
+      "bg": "#a9b1d6"
+    },
+    "insert": {
+      "fg": "#11121d",
+      "bg": "#95c561"
+    },
+    "command": {
+      "fg": "#11121d",
+      "bg": "#7199ee"
+    },
+    "replace": {
+      "fg": "#11121d",
+      "bg": "#ee6d85"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#4a5064",
+      "bg": "#11121d"
+    },
+    "current_line": {
+      "fg": "#a9b1d6",
+      "bg": "#1a1b2a"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#a9b1d6",
+      "bg": "#06080a"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#ee6d85",
+      "bg": "#11121d"
+    },
+    "output_border": {
+      "fg": "#4a5064",
+      "bg": "#06080a"
+    },
+    "continue_message": {
+      "fg": "#7199ee",
+      "bg": "#11121d"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#4a5064",
+      "function": "#7199ee",
+      "keyword": "#a485dd",
+      "number": "#f6955b",
+      "string": "#95c561",
+      "type": "#d7a65f",
+      "variable": "#a9b1d6"
+    },
+    "exact": {
+      "comment.documentation": "#4a5064",
+      "function.call": "#7199ee",
+      "keyword.return": "#ee6d85",
+      "string.escape": "#77bdc7",
+      "variable.parameter": "#a9b1d6"
+    }
+  }
+}

internal/theme/themes/vscode.json

@@ -0,0 +1,79 @@
+{
+  "name": "vscode",
+  "line": {
+    "fg": "#d4d4d4",
+    "bg": "#1e1e1e"
+  },
+  "background": {
+    "bg": "#1e1e1e"
+  },
+  "visual_highlight": {
+    "bg": "#264f78"
+  },
+  "cursors": {
+    "normal": {
+      "fg": "#1e1e1e",
+      "bg": "#aeafad"
+    },
+    "insert": {
+      "fg": "#1e1e1e",
+      "bg": "#ffffff"
+    },
+    "command": {
+      "fg": "#1e1e1e",
+      "bg": "#007acc"
+    },
+    "replace": {
+      "fg": "#1e1e1e",
+      "bg": "#f44747"
+    }
+  },
+  "gutter": {
+    "default": {
+      "fg": "#858585",
+      "bg": "#1e1e1e"
+    },
+    "current_line": {
+      "fg": "#c6c6c6",
+      "bg": "#1e1e1e"
+    }
+  },
+  "status_bar": {
+    "default": {
+      "fg": "#ffffff",
+      "bg": "#007acc"
+    }
+  },
+  "command_line": {
+    "error": {
+      "fg": "#f44747",
+      "bg": "#1e1e1e"
+    },
+    "output_border": {
+      "fg": "#3e3e3e",
+      "bg": "#252526"
+    },
+    "continue_message": {
+      "fg": "#569cd6",
+      "bg": "#1e1e1e"
+    }
+  },
+  "syntax": {
+    "group": {
+      "comment": "#6a9955",
+      "function": "#dcdcaa",
+      "keyword": "#569cd6",
+      "number": "#b5cea8",
+      "string": "#ce9178",
+      "type": "#4ec9b0",
+      "variable": "#9cdcfe"
+    },
+    "exact": {
+      "comment.documentation": "#6a9955",
+      "function.call": "#dcdcaa",
+      "keyword.control": "#c586c0",
+      "string.escape": "#d7ba7d",
+      "variable.parameter": "#9cdcfe"
+    }
+  }
+}