Apply format validation even when caching is disabled

README.md

@@ -99,6 +99,13 @@ If any other (or no) value is provided, the selected file will be random.
 
 Note: These patterns require sequentially-numbered files matching the following pattern: `filename###.extension`.
 
+## Themes
+The `--code` handler provides syntax highlighting via [alecthomas/chroma](https://github.com/alecthomas/chroma).
+
+Any [supported theme](https://pkg.go.dev/github.com/alecthomas/chroma/v2@v2.9.1/styles#pkg-variables) can be passed via the `--theme` flag.
+
+By default, [`solarized-dark256`](https://xyproto.github.io/splash/docs/solarized-dark256.html) is used.
+
 ## Usage output
 ```
 Serves random media from the specified directories.
@@ -112,6 +119,7 @@ Flags:
   -b, --bind string            address to bind to (default "0.0.0.0")
   -c, --cache                  generate directory cache at startup
       --cache-file string      path to optional persistent cache file
+      --code                   enable support for source code files
   -f, --filter                 enable filtering
       --flash                  enable support for shockwave flash files (via ruffle.rs)
       --handlers               display registered handlers (for debugging)
@@ -120,7 +128,7 @@ Flags:
   -i, --info                   expose informational endpoints
       --maximum-files uint32   skip directories with file counts above this value (default 4294967295)
       --minimum-files uint32   skip directories with file counts below this value (default 1)
-      --page-length uint32     pagination length for statistics and debug pages
+      --page-length uint32     pagination length for info pages
   -p, --port uint16            port to listen on (default 8080)
       --prefix string          root path for http handlers (for reverse proxying) (default "/")
       --profile                register net/http/pprof handlers
@@ -129,6 +137,7 @@ Flags:
       --russian                remove selected images after serving
   -s, --sort                   enable sorting
       --text                   enable support for text files
+      --theme string           theme for source code syntax highlighting (default "solarized-dark256")
   -v, --verbose                log accessed files and other information to stdout
   -V, --version                display version and exit
       --video                  enable support for video files

cmd/files.go

@@ -99,28 +99,19 @@ func preparePath(path string) string {
 	return mediaPrefix + path
 }
 
-func appendPath(directory, path string, files *files, stats *scanStats, formats *types.Types, shouldCache bool) error {
-	if shouldCache {
-		registered, _, _, err := formats.FileType(path)
-		if err != nil {
-			return err
-		}
+func appendPath(directory, path string, files *files, stats *scanStats, formats *types.Types) {
+	if !formats.Validate(path) {
+		stats.filesSkipped.Add(1)
 
-		if !registered {
-			return nil
-		}
+		return
 	}
 
 	files.append(directory, path)
 
 	stats.filesMatched.Add(1)
-
-	return nil
 }
 
 func appendPaths(path string, files *files, filters *filters, stats *scanStats, formats *types.Types) error {
-	shouldCache := Cache && filters.isEmpty()
-
 	absolutePath, err := filepath.Abs(path)
 	if err != nil {
 		return err
@@ -149,10 +140,7 @@ func appendPaths(path string, files *files, filters *filters, stats *scanStats,
 				filename,
 				filters.included[i],
 			) {
-				err := appendPath(directory, path, files, stats, formats, shouldCache)
-				if err != nil {
-					return err
-				}
+				appendPath(directory, path, files, stats, formats)
 
 				return nil
 			}
@@ -163,10 +151,7 @@ func appendPaths(path string, files *files, filters *filters, stats *scanStats,
 		return nil
 	}
 
-	err = appendPath(directory, path, files, stats, formats, shouldCache)
-	if err != nil {
-		return err
-	}
+	appendPath(directory, path, files, stats, formats)
 
 	return nil
 }
@@ -326,17 +311,11 @@ func pathHasSupportedFiles(path string, formats *types.Types) (bool, error) {
 		switch {
 		case !Recursive && info.IsDir() && p != path:
 			return filepath.SkipDir
-		case !info.IsDir():
-			registered, _, _, err := formats.FileType(p)
-			if err != nil {
-				return err
-			}
-
-			if registered {
+		case !info.IsDir() && formats.Validate(p):
 			hasRegisteredFiles <- true
+
 			return filepath.SkipAll
 		}
-		}
 
 		return err
 	})
@@ -552,21 +531,15 @@ func pickFile(args []string, filters *filters, sort string, cache *fileCache, fo
 
 		path := fileList[val]
 
-		if !fromCache {
-			registered, _, _, err := formats.FileType(path)
-			if err != nil {
-				return "", err
-			}
-
-			if registered {
+		switch {
+		case !fromCache && formats.Validate(path):
 			return path, nil
-			}
-
+		case !fromCache:
 			continue
-		}
-
+		default:
 			return path, nil
 		}
+	}
 
 	return "", ErrNoMediaFound
 }

cmd/root.go

@@ -11,7 +11,7 @@ import (
 )
 
 const (
-	ReleaseVersion string = "0.83.0"
+	ReleaseVersion string = "0.85.1"
 )
 
 var (
@@ -20,6 +20,7 @@ var (
 	Bind             string
 	Cache            bool
 	CacheFile        string
+	Code             bool
 	Filtering        bool
 	Flash            bool
 	Handlers         bool
@@ -36,6 +37,7 @@ var (
 	Russian          bool
 	Sorting          bool
 	Text             bool
+	Theme            string
 	Verbose          bool
 	Version          bool
 	Videos           bool
@@ -68,6 +70,7 @@ func init() {
 	rootCmd.Flags().StringVarP(&Bind, "bind", "b", "0.0.0.0", "address to bind to")
 	rootCmd.Flags().BoolVarP(&Cache, "cache", "c", false, "generate directory cache at startup")
 	rootCmd.Flags().StringVar(&CacheFile, "cache-file", "", "path to optional persistent cache file")
+	rootCmd.Flags().BoolVar(&Code, "code", false, "enable support for source code files")
 	rootCmd.Flags().BoolVarP(&Filtering, "filter", "f", false, "enable filtering")
 	rootCmd.Flags().BoolVar(&Flash, "flash", false, "enable support for shockwave flash files (via ruffle.rs)")
 	rootCmd.Flags().BoolVar(&Handlers, "handlers", false, "display registered handlers (for debugging)")
@@ -75,7 +78,7 @@ func init() {
 	rootCmd.Flags().BoolVarP(&Info, "info", "i", false, "expose informational endpoints")
 	rootCmd.Flags().Uint32Var(&MaximumFileCount, "maximum-files", 1<<32-1, "skip directories with file counts above this value")
 	rootCmd.Flags().Uint32Var(&MinimumFileCount, "minimum-files", 1, "skip directories with file counts below this value")
-	rootCmd.Flags().Uint32Var(&PageLength, "page-length", 0, "pagination length for statistics and debug pages")
+	rootCmd.Flags().Uint32Var(&PageLength, "page-length", 0, "pagination length for info pages")
 	rootCmd.Flags().Uint16VarP(&Port, "port", "p", 8080, "port to listen on")
 	rootCmd.Flags().StringVar(&Prefix, "prefix", "/", "root path for http handlers (for reverse proxying)")
 	rootCmd.Flags().BoolVar(&Profile, "profile", false, "register net/http/pprof handlers")
@@ -84,6 +87,7 @@ func init() {
 	rootCmd.Flags().BoolVar(&Russian, "russian", false, "remove selected images after serving")
 	rootCmd.Flags().BoolVarP(&Sorting, "sort", "s", false, "enable sorting")
 	rootCmd.Flags().BoolVar(&Text, "text", false, "enable support for text files")
+	rootCmd.Flags().StringVar(&Theme, "theme", "solarized-dark256", "theme for source code syntax highlighting")
 	rootCmd.Flags().BoolVarP(&Verbose, "verbose", "v", false, "log accessed files and other information to stdout")
 	rootCmd.Flags().BoolVarP(&Version, "version", "V", false, "display version and exit")
 	rootCmd.Flags().BoolVar(&Videos, "video", false, "enable support for video files")

cmd/web.go

@@ -24,6 +24,7 @@ import (
 	"github.com/yosssi/gohtml"
 	"seedno.de/seednode/roulette/types"
 	"seedno.de/seednode/roulette/types/audio"
+	"seedno.de/seednode/roulette/types/code"
 	"seedno.de/seednode/roulette/types/flash"
 	"seedno.de/seednode/roulette/types/images"
 	"seedno.de/seednode/roulette/types/text"
@@ -70,8 +71,6 @@ func serveStaticFile(paths []string, cache *fileCache) httprouter.Handle {
 
 		exists, err := fileExists(filePath)
 		if err != nil {
-			fmt.Println(err)
-
 			serverError(w, r, nil)
 
 			return
@@ -87,8 +86,6 @@ func serveStaticFile(paths []string, cache *fileCache) httprouter.Handle {
 
 		buf, err := os.ReadFile(filePath)
 		if err != nil {
-			fmt.Println(err)
-
 			serverError(w, r, nil)
 
 			return
@@ -101,8 +98,6 @@ func serveStaticFile(paths []string, cache *fileCache) httprouter.Handle {
 		if Russian {
 			err = os.Remove(filePath)
 			if err != nil {
-				fmt.Println(err)
-
 				serverError(w, r, nil)
 
 				return
@@ -228,21 +223,21 @@ func serveMedia(paths []string, regexes *regexes, formats *types.Types) httprout
 			return
 		}
 
-		registered, fileType, mimeType, err := formats.FileType(path)
-		if err != nil {
-			fmt.Println(err)
-
+		format := formats.FileType(path)
+		if format == nil {
 			serverError(w, r, nil)
 
 			return
 		}
 
-		if !registered {
+		if !format.Validate(path) {
 			notFound(w, r, path)
 
 			return
 		}
 
+		mimeType := format.MimeType(path)
+
 		fileUri := Prefix + generateFileUri(path)
 
 		fileName := filepath.Base(path)
@@ -254,17 +249,17 @@ func serveMedia(paths []string, regexes *regexes, formats *types.Types) httprout
 		rootUrl := Prefix + "/" + generateQueryParams(filters, sortOrder, refreshInterval)
 
 		var htmlBody strings.Builder
-		htmlBody.WriteString(`<!DOCTYPE html><html lang="en"><head>`)
+		htmlBody.WriteString(`<!DOCTYPE html><html class="bg" lang="en"><head>`)
 		htmlBody.WriteString(faviconHtml)
-		htmlBody.WriteString(fmt.Sprintf(`<style>%s</style>`, fileType.Css()))
-		htmlBody.WriteString((fileType.Title(rootUrl, fileUri, path, fileName, Prefix, mimeType)))
+		htmlBody.WriteString(fmt.Sprintf(`<style>%s</style>`, format.Css()))
+		htmlBody.WriteString((format.Title(rootUrl, fileUri, path, fileName, Prefix, mimeType)))
 		htmlBody.WriteString(`</head><body>`)
 		if refreshInterval != "0ms" {
 			htmlBody.WriteString(fmt.Sprintf("<script>window.onload = function(){setInterval(function(){window.location.href = '%s';}, %d);};</script>",
 				rootUrl,
 				refreshTimer))
 		}
-		htmlBody.WriteString((fileType.Body(rootUrl, fileUri, path, fileName, Prefix, mimeType)))
+		htmlBody.WriteString((format.Body(rootUrl, fileUri, path, fileName, Prefix, mimeType)))
 		htmlBody.WriteString(`</body></html>`)
 
 		_, err = io.WriteString(w, gohtml.Format(htmlBody.String()))
@@ -328,14 +323,17 @@ func ServePage(args []string) error {
 	}
 
 	formats := &types.Types{
-		Extensions: make(map[string]string),
-		MimeTypes:  make(map[string]types.Type),
+		Extensions: make(map[string]types.Type),
 	}
 
 	if Audio || All {
 		formats.Add(audio.New())
 	}
 
+	if Code || All {
+		formats.Add(code.New(Theme))
+	}
+
 	if Flash || All {
 		formats.Add(flash.New())
 	}

go.mod

@@ -3,6 +3,7 @@ module seedno.de/seednode/roulette
 go 1.21
 
 require (
+	github.com/alecthomas/chroma/v2 v2.9.1
 	github.com/julienschmidt/httprouter v1.3.0
 	github.com/klauspost/compress v1.16.7
 	github.com/spf13/cobra v1.7.0
@@ -11,6 +12,7 @@ require (
 )
 
 require (
+	github.com/dlclark/regexp2 v1.10.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	golang.org/x/net v0.15.0 // indirect

go.sum

@@ -1,4 +1,14 @@
+github.com/alecthomas/assert/v2 v2.2.1 h1:XivOgYcduV98QCahG8T5XTezV5bylXe+lBxLG2K2ink=
+github.com/alecthomas/assert/v2 v2.2.1/go.mod h1:pXcQ2Asjp247dahGEmsZ6ru0UVwnkhktn7S0bBDLxvQ=
+github.com/alecthomas/chroma/v2 v2.9.1 h1:0O3lTQh9FxazJ4BYE/MOi/vDGuHn7B+6Bu902N2UZvU=
+github.com/alecthomas/chroma/v2 v2.9.1/go.mod h1:4TQu7gdfuPjSh76j78ietmqh9LiurGF0EpseFXdKMBw=
+github.com/alecthomas/repr v0.2.0 h1:HAzS41CIzNW5syS8Mf9UwXhNH1J9aix/BvDRf1Ml2Yk=
+github.com/alecthomas/repr v0.2.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
+github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=

licenses/github.com/alecthomas/chroma/v2/COPYING

@@ -0,0 +1,19 @@
+Copyright (C) 2017 Alec Thomas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

licenses/github.com/dlclark/regexp2/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Doug Clark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

types/audio/audio.go

@@ -42,15 +42,15 @@ func (t Format) Extensions() map[string]string {
 	}
 }
 
-func (t Format) MimeTypes() []string {
-	return []string{
-		`application/ogg`,
-		`audio/mp3`,
-		`audio/mpeg`,
-		`audio/mpeg3`,
-		`audio/ogg`,
-		`audio/x-mpeg-3`,
+func (t Format) MimeType(extension string) string {
+	extensions := t.Extensions()
+
+	value, exists := extensions[extension]
+	if exists {
+		return value
 	}
+
+	return ""
 }
 
 func (t Format) Validate(filePath string) bool {

types/code/code.go

@@ -0,0 +1,232 @@
+/*
+Copyright © 2023 Seednode <seednode@seedno.de>
+*/
+
+package code
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/alecthomas/chroma/v2"
+	"github.com/alecthomas/chroma/v2/formatters/html"
+	"github.com/alecthomas/chroma/v2/lexers"
+	"github.com/alecthomas/chroma/v2/styles"
+	"seedno.de/seednode/roulette/types"
+)
+
+type Format struct {
+	Theme string
+}
+
+func (t Format) Css() string {
+	var css strings.Builder
+
+	formatter := html.New(
+		html.TabWidth(4),
+		html.WithClasses(true),
+		html.WrapLongLines(true))
+
+	style := styles.Get(t.Theme)
+	if style == nil {
+		style = styles.Fallback
+	}
+
+	var response bytes.Buffer
+	w := bufio.NewWriter(&response)
+	r := bufio.NewReader(&response)
+
+	err := formatter.WriteCSS(w, style)
+	if err != nil {
+		return ""
+	}
+
+	w.Flush()
+
+	b, err := io.ReadAll(r)
+	if err != nil {
+		return ""
+	}
+
+	css.Write(b)
+
+	css.WriteString("html{height:100%;width:100%;}\n")
+	css.WriteString("a{bottom:0;left:0;position:absolute;right:0;top:0;margin:1rem;padding:0;height:99%;width:99%;color:inherit;text-decoration:none;}\n")
+
+	return css.String()
+}
+
+func (t Format) Title(rootUrl, fileUri, filePath, fileName, prefix, mime string) string {
+	return fmt.Sprintf(`<title>%s</title>`, fileName)
+}
+
+func (t Format) Body(rootUrl, fileUri, filePath, fileName, prefix, mime string) string {
+	contents, err := os.ReadFile(filePath)
+	if err != nil {
+		return ""
+	}
+
+	contentString := string(contents)
+
+	lexer := lexers.Match(filePath)
+	if lexer == nil {
+		lexer = lexers.Analyse(contentString)
+	}
+	if lexer == nil {
+		lexer = lexers.Fallback
+	}
+	lexer = chroma.Coalesce(lexer)
+
+	var response bytes.Buffer
+	w := bufio.NewWriter(&response)
+	r := bufio.NewReader(&response)
+
+	style := styles.Get(t.Theme)
+	if style == nil {
+		style = styles.Fallback
+	}
+
+	formatter := html.New(
+		html.TabWidth(4),
+		html.WithClasses(true),
+		html.WrapLongLines(true))
+
+	iterator, err := lexer.Tokenise(nil, contentString)
+	if err != nil {
+		return ""
+	}
+
+	err = formatter.Format(w, style, iterator)
+	if err != nil {
+		return ""
+	}
+
+	w.Flush()
+
+	b, err := io.ReadAll(r)
+	if err != nil {
+		return ""
+	}
+
+	return fmt.Sprintf(`<a href="%s">%s</a>`,
+		rootUrl,
+		string(b))
+}
+
+func (t Format) Extensions() map[string]string {
+	return map[string]string{
+		`.4th`:     ``,
+		`.abap`:    ``,
+		`.ada`:     ``,
+		`.ahk`:     ``,
+		`.as`:      ``,
+		`.awk`:     ``,
+		`.bat`:     ``,
+		`.bib`:     ``,
+		`.bibtex`:  ``,
+		`.c`:       ``,
+		`.clj`:     ``,
+		`.cljc`:    ``,
+		`.cljs`:    ``,
+		`.coffee`:  ``,
+		`.conf`:    ``,
+		`.cpp`:     ``,
+		`.cr`:      ``,
+		`.cs`:      ``,
+		`.css`:     ``,
+		`.d`:       ``,
+		`.elm`:     ``,
+		`.erl`:     ``,
+		`.ex`:      ``,
+		`.exs`:     ``,
+		`.f03`:     ``,
+		`.f90`:     ``,
+		`.f95`:     ``,
+		`.fs`:      ``,
+		`.go`:      ``,
+		`.graphql`: ``,
+		`.groovy`:  ``,
+		`.gsh`:     ``,
+		`.gvy`:     ``,
+		`.gy`:      ``,
+		`.hc`:      ``,
+		`.hcl`:     ``,
+		`.hs`:      ``,
+		`.java`:    ``,
+		`.jinja`:   ``,
+		`.jl`:      ``,
+		`.js`:      ``,
+		`.json`:    ``,
+		`.kt`:      ``,
+		`.lisp`:    ``,
+		`.lsp`:     ``,
+		`.lua`:     ``,
+		`.m`:       ``,
+		`.md`:      ``,
+		`.ml`:      ``,
+		`.nb`:      ``,
+		`.nim`:     ``,
+		`.nix`:     ``,
+		`.php`:     ``,
+		`.pl`:      ``,
+		`.pp`:      ``,
+		`.proto`:   ``,
+		`.ps`:      ``,
+		`.ps1`:     ``,
+		`.psl`:     ``,
+		`.py`:      ``,
+		`.r`:       ``,
+		`.raku`:    ``,
+		`.rb`:      ``,
+		`.rs`:      ``,
+		`.sass`:    ``,
+		`.sc`:      ``,
+		`.scm`:     ``,
+		`.scss`:    ``,
+		`.scpt`:    ``,
+		`.sh`:      ``,
+		`.sql`:     ``,
+		`.swift`:   ``,
+		`.tcl`:     ``,
+		`.tex`:     ``,
+		`.tf`:      ``,
+		`.toml`:    ``,
+		`.ts`:      ``,
+		`.unit`:    ``,
+		`.v`:       ``,
+		`.vb`:      ``,
+		`.xml`:     ``,
+		`.yaml`:    ``,
+		`.yml`:     ``,
+		`.zig`:     ``,
+	}
+}
+
+func (t Format) MimeType(extension string) string {
+	extensions := t.Extensions()
+
+	value, exists := extensions[extension]
+	if exists {
+		return value
+	}
+
+	return ""
+}
+
+func (t Format) Validate(filePath string) bool {
+	return true
+}
+
+func New(theme string) Format {
+	return Format{
+		Theme: theme,
+	}
+}
+
+func init() {
+	types.SupportedFormats.Register(New(""))
+}

types/flash/flash.go

@@ -41,10 +41,15 @@ func (t Format) Extensions() map[string]string {
 	}
 }
 
-func (t Format) MimeTypes() []string {
-	return []string{
-		`application/x-shockwave-flash`,
+func (t Format) MimeType(extension string) string {
+	extensions := t.Extensions()
+
+	value, exists := extensions[extension]
+	if exists {
+		return value
 	}
+
+	return ""
 }
 
 func (t Format) Validate(filePath string) bool {

types/images/images.go

@@ -76,28 +76,25 @@ func (t Format) Extensions() map[string]string {
 		`.pjp`:   `image/jpeg`,
 		`.pjpeg`: `image/jpeg`,
 		`.png`:   `image/png`,
-		`.svg`:   `image/svg+xml`,
 		`.webp`:  `image/webp`,
 	}
 }
 
-func (t Format) MimeTypes() []string {
-	return []string{
-		`image/apng`,
-		`image/avif`,
-		`image/bmp`,
-		`image/gif`,
-		`image/jpeg`,
-		`image/png`,
-		`image/svg+xml`,
-		`image/webp`,
-	}
-}
-
 func (t Format) Validate(filePath string) bool {
 	return true
 }
 
+func (t Format) MimeType(extension string) string {
+	extensions := t.Extensions()
+
+	value, exists := extensions[extension]
+	if exists {
+		return value
+	}
+
+	return ""
+}
+
 func ImageDimensions(path string) (*dimensions, error) {
 	file, err := os.Open(path)
 	switch {

types/text/text.go

@@ -44,33 +44,20 @@ func (t Format) Body(rootUrl, fileUri, filePath, fileName, prefix, mime string)
 
 func (t Format) Extensions() map[string]string {
 	return map[string]string{
-		`.css`:  `text/css`,
 		`.csv`: `text/csv`,
-		`.js`:   `text/javascript`,
-		`.json`: `application/json`,
-		`.md`:   `text/markdown`,
-		`.ps1`:  `text/plain`,
-		`.sh`:   `application./x-sh`,
-		`.toml`: `application/toml`,
 		`.txt`: `text/plain`,
-		`.xml`:  `application/xml`,
-		`.yml`:  `application/yaml`,
-		`.yaml`: `application/yaml`,
 	}
 }
 
-func (t Format) MimeTypes() []string {
-	return []string{
-		`application/json`,
-		`application/toml`,
-		`application/xml`,
-		`application/yaml`,
-		`text/css`,
-		`text/csv`,
-		`text/javascript`,
-		`text/plain`,
-		`text/plain; charset=utf-8`,
+func (t Format) MimeType(extension string) string {
+	extensions := t.Extensions()
+
+	value, exists := extensions[extension]
+	if exists {
+		return value
 	}
+
+	return ""
 }
 
 func (t Format) Validate(filePath string) bool {

types/types.go

@@ -5,17 +5,13 @@ Copyright © 2023 Seednode <seednode@seedno.de>
 package types
 
 import (
-	"errors"
-	"net/http"
-	"os"
 	"path/filepath"
 	"slices"
 	"strings"
 )
 
 var SupportedFormats = &Types{
-	Extensions: make(map[string]string),
-	MimeTypes:  make(map[string]Type),
+	Extensions: make(map[string]Type),
 }
 
 type Type interface {
@@ -23,69 +19,45 @@ type Type interface {
 	Title(rootUrl, fileUri, filePath, fileName, prefix, mime string) string
 	Body(rootUrl, fileUri, filePath, fileName, prefix, mime string) string
 	Extensions() map[string]string
-	MimeTypes() []string
+	MimeType(string) string
 	Validate(filePath string) bool
 }
 
 type Types struct {
-	Extensions map[string]string
-	MimeTypes  map[string]Type
+	Extensions map[string]Type
 }
 
 func (t *Types) Add(format Type) {
-	for k, v := range format.Extensions() {
+	for k := range format.Extensions() {
 		_, exists := t.Extensions[k]
 		if !exists {
-			t.Extensions[k] = v
-		}
-	}
-
-	for _, v := range format.MimeTypes() {
-		_, exists := t.Extensions[v]
-		if !exists {
-			t.MimeTypes[v] = format
+			t.Extensions[k] = format
 		}
 	}
 }
 
-func (t *Types) FileType(path string) (bool, Type, string, error) {
-	file, err := os.Open(path)
-	switch {
-	case errors.Is(err, os.ErrNotExist):
-		return false, nil, "", nil
-	case err != nil:
-		return false, nil, "", err
-	}
-	defer file.Close()
-
-	head := make([]byte, 512)
-	file.Read(head)
-
-	mimeType := http.DetectContentType(head)
-
-	// try identifying files by mime types first
-	fileType, exists := t.MimeTypes[mimeType]
+func (t *Types) FileType(path string) Type {
+	fileType, exists := t.Extensions[filepath.Ext(path)]
 	if exists {
-		return fileType.Validate(path), fileType, mimeType, nil
+		return fileType
 	}
 
-	// if mime type detection fails, use the file extension
-	mimeType, exists = t.Extensions[filepath.Ext(path)]
-	if exists {
-		fileType, exists := t.MimeTypes[mimeType]
-
-		if exists {
-			return fileType.Validate(path), fileType, mimeType, nil
-		}
-	}
-
-	return false, nil, "", nil
+	return nil
 }
 
 func (t *Types) Register(format Type) {
 	t.Add(format)
 }
 
+func (t *Types) Validate(path string) bool {
+	format, exists := t.Extensions[filepath.Ext(path)]
+	if !exists {
+		return false
+	}
+
+	return format.Validate(path)
+}
+
 func (t *Types) GetExtensions() string {
 	var output strings.Builder
 
@@ -110,14 +82,16 @@ func (t *Types) GetExtensions() string {
 func (t *Types) GetMimeTypes() string {
 	var output strings.Builder
 
-	mimeTypes := make([]string, len(t.MimeTypes))
+	var mimeTypes []string
 
-	i := 0
-
-	for k := range t.MimeTypes {
-		mimeTypes[i] = k
-		i++
+	for _, j := range t.Extensions {
+		extensions := j.Extensions()
+		for _, v := range extensions {
+			mimeTypes = append(mimeTypes, v)
 		}
+	}
+
+	mimeTypes = removeDuplicateStr(mimeTypes)
 
 	slices.Sort(mimeTypes)
 
@@ -127,3 +101,15 @@ func (t *Types) GetMimeTypes() string {
 
 	return output.String()
 }
+
+func removeDuplicateStr(strSlice []string) []string {
+	allKeys := make(map[string]bool)
+	list := []string{}
+	for _, item := range strSlice {
+		if _, value := allKeys[item]; !value {
+			allKeys[item] = true
+			list = append(list, item)
+		}
+	}
+	return list
+}

types/video/video.go

@@ -6,6 +6,7 @@ package video
 
 import (
 	"fmt"
+	"path/filepath"
 	"strings"
 
 	"seedno.de/seednode/roulette/types"
@@ -45,12 +46,17 @@ func (t Format) Extensions() map[string]string {
 	}
 }
 
-func (t Format) MimeTypes() []string {
-	return []string{
-		`video/mp4`,
-		`video/ogg`,
-		`video/webm`,
+func (t Format) MimeType(path string) string {
+	extensions := t.Extensions()
+
+	extension := filepath.Ext(path)
+
+	value, exists := extensions[extension]
+	if exists {
+		return value
 	}
+
+	return ""
 }
 
 func (t Format) Validate(filePath string) bool {

vendor/github.com/alecthomas/chroma/v2/.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+indent_style = tab
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.xml]
+indent_style = space
+indent_size = 2
+insert_final_newline = false

vendor/github.com/alecthomas/chroma/v2/.gitignore

@@ -0,0 +1,25 @@
+# Binaries for programs and plugins
+.git
+.idea
+.vscode
+.hermit
+*.exe
+*.dll
+*.so
+*.dylib
+/cmd/chroma/chroma
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
+.glide/
+
+_models/
+
+_examples/
+*.min.*
+build/

vendor/github.com/alecthomas/chroma/v2/.golangci.yml

@@ -0,0 +1,90 @@
+run:
+  tests: true
+  skip-dirs:
+    - _examples
+
+output:
+  print-issued-lines: false
+
+linters:
+  enable-all: true
+  disable:
+    - maligned
+    - megacheck
+    - lll
+    - gocyclo
+    - dupl
+    - gochecknoglobals
+    - funlen
+    - godox
+    - wsl
+    - gomnd
+    - gocognit
+    - goerr113
+    - nolintlint
+    - testpackage
+    - godot
+    - nestif
+    - paralleltest
+    - nlreturn
+    - cyclop
+    - exhaustivestruct
+    - gci
+    - gofumpt
+    - errorlint
+    - exhaustive
+    - ifshort
+    - wrapcheck
+    - stylecheck
+    - thelper
+    - nonamedreturns
+    - revive
+    - dupword
+    - exhaustruct
+    - varnamelen
+    - forcetypeassert
+    - ireturn
+    - maintidx
+    - govet
+    - nosnakecase
+    - testableexamples
+    - musttag
+
+linters-settings:
+  govet:
+    check-shadowing: true
+  gocyclo:
+    min-complexity: 10
+  dupl:
+    threshold: 100
+  goconst:
+    min-len: 8
+    min-occurrences: 3
+  forbidigo:
+    #forbid:
+    #  - (Must)?NewLexer$
+    exclude_godoc_examples: false
+
+
+issues:
+  max-per-linter: 0
+  max-same: 0
+  exclude-use-default: false
+  exclude:
+    # Captured by errcheck.
+    - '^(G104|G204):'
+    # Very commonly not checked.
+    - 'Error return value of .(.*\.Help|.*\.MarkFlagRequired|(os\.)?std(out|err)\..*|.*Close|.*Flush|os\.Remove(All)?|.*printf?|os\.(Un)?Setenv). is not checked'
+    - 'exported method (.*\.MarshalJSON|.*\.UnmarshalJSON|.*\.EntityURN|.*\.GoString|.*\.Pos) should have comment or be unexported'
+    - 'composite literal uses unkeyed fields'
+    - 'declaration of "err" shadows declaration'
+    - 'should not use dot imports'
+    - 'Potential file inclusion via variable'
+    - 'should have comment or be unexported'
+    - 'comment on exported var .* should be of the form'
+    - 'at least one file in a package should have a package comment'
+    - 'string literal contains the Unicode'
+    - 'methods on the same type should have the same receiver name'
+    - '_TokenType_name should be _TokenTypeName'
+    - '`_TokenType_map` should be `_TokenTypeMap`'
+    - 'rewrite if-else to switch statement'

vendor/github.com/alecthomas/chroma/v2/.goreleaser.yml

@@ -0,0 +1,37 @@
+project_name: chroma
+release:
+  github:
+    owner: alecthomas
+    name: chroma
+brews:
+  -
+    install: bin.install "chroma"
+env:
+  - CGO_ENABLED=0
+builds:
+- goos:
+    - linux
+    - darwin
+    - windows
+  goarch:
+    - arm64
+    - amd64
+    - "386"
+  goarm:
+    - "6"
+  dir: ./cmd/chroma
+  main: .
+  ldflags: -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}
+  binary: chroma
+archives:
+  -
+    format: tar.gz
+    name_template: '{{ .Binary }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{
+    .Arm }}{{ end }}'
+    files:
+      - COPYING
+      - README*
+snapshot:
+  name_template: SNAPSHOT-{{ .Commit }}
+checksum:
+  name_template: '{{ .ProjectName }}-{{ .Version }}-checksums.txt'

vendor/github.com/alecthomas/chroma/v2/Bitfile

@@ -0,0 +1,24 @@
+VERSION = %(git describe --tags --dirty  --always)%
+export CGOENABLED = 0
+
+tokentype_enumer.go: types.go
+  build: go generate
+
+# Regenerate the list of lexers in the README
+README.md: lexers/*.go lexers/*/*.xml table.py
+  build: ./table.py
+  -clean
+
+implicit %{1}%{2}.min.%{3}: **/*.{css,js}
+  build: esbuild --bundle %{IN} --minify --outfile=%{OUT}
+
+implicit build/%{1}: cmd/*
+  cd cmd/%{1}
+  inputs: cmd/%{1}/**/* **/*.go
+  build: go build -ldflags="-X 'main.version=%{VERSION}'" -o ../../build/%{1} .
+
+#upload: chromad
+#  build:
+#    scp chromad root@swapoff.org:
+#    ssh root@swapoff.org 'install -m755 ./chromad /srv/http/swapoff.org/bin && service chromad restart'
+#    touch upload

vendor/github.com/alecthomas/chroma/v2/COPYING

@@ -0,0 +1,19 @@
+Copyright (C) 2017 Alec Thomas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/alecthomas/chroma/v2/Makefile

@@ -0,0 +1,23 @@
+.PHONY: chromad upload all
+
+VERSION ?= $(shell git describe --tags --dirty  --always)
+export GOOS ?= linux
+export GOARCH ?= amd64
+
+all: README.md tokentype_string.go
+
+README.md: lexers/*/*.go
+	./table.py
+
+tokentype_string.go: types.go
+	go generate
+
+chromad:
+	rm -rf build
+	esbuild --bundle cmd/chromad/static/index.js --minify --outfile=cmd/chromad/static/index.min.js
+	esbuild --bundle cmd/chromad/static/index.css --minify --outfile=cmd/chromad/static/index.min.css
+	(export CGOENABLED=0 ; cd ./cmd/chromad && go build -ldflags="-X 'main.version=$(VERSION)'" -o ../../build/chromad .)
+
+upload: build/chromad
+	scp build/chromad root@swapoff.org: && \
+		ssh root@swapoff.org 'install -m755 ./chromad /srv/http/swapoff.org/bin && service chromad restart'

vendor/github.com/alecthomas/chroma/v2/README.md

@@ -0,0 +1,322 @@
+# Chroma — A general purpose syntax highlighter in pure Go
+
+[![Golang Documentation](https://godoc.org/github.com/alecthomas/chroma?status.svg)](https://godoc.org/github.com/alecthomas/chroma) [![CI](https://github.com/alecthomas/chroma/actions/workflows/ci.yml/badge.svg)](https://github.com/alecthomas/chroma/actions/workflows/ci.yml) [![Slack chat](https://img.shields.io/static/v1?logo=slack&style=flat&label=slack&color=green&message=gophers)](https://invite.slack.golangbridge.org/)
+
+Chroma takes source code and other structured text and converts it into syntax
+highlighted HTML, ANSI-coloured text, etc.
+
+Chroma is based heavily on [Pygments](http://pygments.org/), and includes
+translators for Pygments lexers and styles.
+
+<a id="markdown-table-of-contents" name="table-of-contents"></a>
+
+## Table of Contents
+
+<!-- TOC -->
+
+1. [Table of Contents](#table-of-contents)
+2. [Supported languages](#supported-languages)
+3. [Try it](#try-it)
+4. [Using the library](#using-the-library)
+   1. [Quick start](#quick-start)
+   2. [Identifying the language](#identifying-the-language)
+   3. [Formatting the output](#formatting-the-output)
+   4. [The HTML formatter](#the-html-formatter)
+5. [More detail](#more-detail)
+   1. [Lexers](#lexers)
+   2. [Formatters](#formatters)
+   3. [Styles](#styles)
+6. [Command-line interface](#command-line-interface)
+7. [Testing lexers](#testing-lexers)
+8. [What's missing compared to Pygments?](#whats-missing-compared-to-pygments)
+
+<!-- /TOC -->
+
+<a id="markdown-supported-languages" name="supported-languages"></a>
+
+## Supported languages
+
+| Prefix | Language                                                                                                                                                                                                                             |
+| :----: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+|   A    | ABAP, ABNF, ActionScript, ActionScript 3, Ada, AL, Angular2, ANTLR, ApacheConf, APL, AppleScript, ArangoDB AQL, Arduino, ArmAsm, AutoHotkey, AutoIt, Awk                                                                             |
+|   B    | Ballerina, Bash, Bash Session, Batchfile, BibTeX, Bicep, BlitzBasic, BNF, BQN, Brainfuck                                                                                                                                             |
+|   C    | C, C#, C++, Caddyfile, Caddyfile Directives, Cap'n Proto, Cassandra CQL, Ceylon, CFEngine3, cfstatement, ChaiScript, Chapel, Cheetah, Clojure, CMake, COBOL, CoffeeScript, Common Lisp, Coq, Crystal, CSS, Cython                    |
+|   D    | D, Dart, Diff, Django/Jinja, dns, Docker, DTD, Dylan                                                                                                                                                                                 |
+|   E    | EBNF, Elixir, Elm, EmacsLisp, Erlang                                                                                                                                                                                                 |
+|   F    | Factor, Fennel, Fish, Forth, Fortran, FortranFixed, FSharp                                                                                                                                                                           |
+|   G    | GAS, GDScript, Genshi, Genshi HTML, Genshi Text, Gherkin, GLSL, Gnuplot, Go, Go HTML Template, Go Text Template, GraphQL, Groff, Groovy                                                                                              |
+|   H    | Handlebars, Haskell, Haxe, HCL, Hexdump, HLB, HLSL, HolyC, HTML, HTTP, Hy                                                                                                                                                            |
+|   I    | Idris, Igor, INI, Io, ISCdhcpd                                                                                                                                                                                                       |
+|   J    | J, Java, JavaScript, JSON, Julia, Jungle                                                                                                                                                                                             |
+|   K    | Kotlin                                                                                                                                                                                                                               |
+|   L    | Lighttpd configuration file, LLVM, Lua                                                                                                                                                                                               |
+|   M    | Makefile, Mako, markdown, Mason, Mathematica, Matlab, mcfunction, Meson, Metal, MiniZinc, MLIR, Modula-2, MonkeyC, MorrowindScript, Myghty, MySQL                                                                                    |
+|   N    | NASM, Natural, Newspeak, Nginx configuration file, Nim, Nix                                                                                                                                                                          |
+|   O    | Objective-C, OCaml, Octave, Odin, OnesEnterprise, OpenEdge ABL, OpenSCAD, Org Mode                                                                                                                                                   |
+|   P    | PacmanConf, Perl, PHP, PHTML, Pig, PkgConfig, PL/pgSQL, plaintext, Plutus Core, Pony, PostgreSQL SQL dialect, PostScript, POVRay, PowerQuery, PowerShell, Prolog, PromQL, properties, Protocol Buffer, PSL, Puppet, Python, Python 2 |
+|   Q    | QBasic, QML                                                                                                                                                                                                                          |
+|   R    | R, Racket, Ragel, Raku, react, ReasonML, reg, reStructuredText, Rexx, Ruby, Rust                                                                                                                                                     |
+|   S    | SAS, Sass, Scala, Scheme, Scilab, SCSS, Sed, Sieve, Smali, Smalltalk, Smarty, Snobol, Solidity, SourcePawn, SPARQL, SQL, SquidConf, Standard ML, stas, Stylus, Svelte, Swift, SYSTEMD, systemverilog                                 |
+|   T    | TableGen, Tal, TASM, Tcl, Tcsh, Termcap, Terminfo, Terraform, TeX, Thrift, TOML, TradingView, Transact-SQL, Turing, Turtle, Twig, TypeScript, TypoScript, TypoScriptCssData, TypoScriptHtmlData                                      |
+|   V    | V, V shell, Vala, VB.net, verilog, VHDL, VHS, VimL, vue                                                                                                                                                                              |
+|   W    | WDTE, WebGPU Shading Language, Whiley                                                                                                                                                                                                |
+|   X    | XML, Xorg                                                                                                                                                                                                                            |
+|   Y    | YAML, YANG                                                                                                                                                                                                                           |
+|   Z    | Z80 Assembly, Zed, Zig                                                                                                                                                                                                               |
+
+_I will attempt to keep this section up to date, but an authoritative list can be
+displayed with `chroma --list`._
+
+<a id="markdown-try-it" name="try-it"></a>
+
+## Try it
+
+Try out various languages and styles on the [Chroma Playground](https://swapoff.org/chroma/playground/).
+
+<a id="markdown-using-the-library" name="using-the-library"></a>
+
+## Using the library
+
+Chroma, like Pygments, has the concepts of
+[lexers](https://github.com/alecthomas/chroma/tree/master/lexers),
+[formatters](https://github.com/alecthomas/chroma/tree/master/formatters) and
+[styles](https://github.com/alecthomas/chroma/tree/master/styles).
+
+Lexers convert source text into a stream of tokens, styles specify how token
+types are mapped to colours, and formatters convert tokens and styles into
+formatted output.
+
+A package exists for each of these, containing a global `Registry` variable
+with all of the registered implementations. There are also helper functions
+for using the registry in each package, such as looking up lexers by name or
+matching filenames, etc.
+
+In all cases, if a lexer, formatter or style can not be determined, `nil` will
+be returned. In this situation you may want to default to the `Fallback`
+value in each respective package, which provides sane defaults.
+
+<a id="markdown-quick-start" name="quick-start"></a>
+
+### Quick start
+
+A convenience function exists that can be used to simply format some source
+text, without any effort:
+
+```go
+err := quick.Highlight(os.Stdout, someSourceCode, "go", "html", "monokai")
+```
+
+<a id="markdown-identifying-the-language" name="identifying-the-language"></a>
+
+### Identifying the language
+
+To highlight code, you'll first have to identify what language the code is
+written in. There are three primary ways to do that:
+
+1. Detect the language from its filename.
+
+   ```go
+   lexer := lexers.Match("foo.go")
+   ```
+
+2. Explicitly specify the language by its Chroma syntax ID (a full list is available from `lexers.Names()`).
+
+   ```go
+   lexer := lexers.Get("go")
+   ```
+
+3. Detect the language from its content.
+
+   ```go
+   lexer := lexers.Analyse("package main\n\nfunc main()\n{\n}\n")
+   ```
+
+In all cases, `nil` will be returned if the language can not be identified.
+
+```go
+if lexer == nil {
+  lexer = lexers.Fallback
+}
+```
+
+At this point, it should be noted that some lexers can be extremely chatty. To
+mitigate this, you can use the coalescing lexer to coalesce runs of identical
+token types into a single token:
+
+```go
+lexer = chroma.Coalesce(lexer)
+```
+
+<a id="markdown-formatting-the-output" name="formatting-the-output"></a>
+
+### Formatting the output
+
+Once a language is identified you will need to pick a formatter and a style (theme).
+
+```go
+style := styles.Get("swapoff")
+if style == nil {
+  style = styles.Fallback
+}
+formatter := formatters.Get("html")
+if formatter == nil {
+  formatter = formatters.Fallback
+}
+```
+
+Then obtain an iterator over the tokens:
+
+```go
+contents, err := ioutil.ReadAll(r)
+iterator, err := lexer.Tokenise(nil, string(contents))
+```
+
+And finally, format the tokens from the iterator:
+
+```go
+err := formatter.Format(w, style, iterator)
+```
+
+<a id="markdown-the-html-formatter" name="the-html-formatter"></a>
+
+### The HTML formatter
+
+By default the `html` registered formatter generates standalone HTML with
+embedded CSS. More flexibility is available through the `formatters/html` package.
+
+Firstly, the output generated by the formatter can be customised with the
+following constructor options:
+
+- `Standalone()` - generate standalone HTML with embedded CSS.
+- `WithClasses()` - use classes rather than inlined style attributes.
+- `ClassPrefix(prefix)` - prefix each generated CSS class.
+- `TabWidth(width)` - Set the rendered tab width, in characters.
+- `WithLineNumbers()` - Render line numbers (style with `LineNumbers`).
+- `WithLinkableLineNumbers()` - Make the line numbers linkable and be a link to themselves.
+- `HighlightLines(ranges)` - Highlight lines in these ranges (style with `LineHighlight`).
+- `LineNumbersInTable()` - Use a table for formatting line numbers and code, rather than spans.
+
+If `WithClasses()` is used, the corresponding CSS can be obtained from the formatter with:
+
+```go
+formatter := html.New(html.WithClasses(true))
+err := formatter.WriteCSS(w, style)
+```
+
+<a id="markdown-more-detail" name="more-detail"></a>
+
+## More detail
+
+<a id="markdown-lexers" name="lexers"></a>
+
+### Lexers
+
+See the [Pygments documentation](http://pygments.org/docs/lexerdevelopment/)
+for details on implementing lexers. Most concepts apply directly to Chroma,
+but see existing lexer implementations for real examples.
+
+In many cases lexers can be automatically converted directly from Pygments by
+using the included Python 3 script `pygments2chroma_xml.py`. I use something like
+the following:
+
+```sh
+python3 _tools/pygments2chroma_xml.py \
+  pygments.lexers.jvm.KotlinLexer \
+  > lexers/embedded/kotlin.xml
+```
+
+See notes in [pygments-lexers.txt](https://github.com/alecthomas/chroma/blob/master/pygments-lexers.txt)
+for a list of lexers, and notes on some of the issues importing them.
+
+<a id="markdown-formatters" name="formatters"></a>
+
+### Formatters
+
+Chroma supports HTML output, as well as terminal output in 8 colour, 256 colour, and true-colour.
+
+A `noop` formatter is included that outputs the token text only, and a `tokens`
+formatter outputs raw tokens. The latter is useful for debugging lexers.
+
+<a id="markdown-styles" name="styles"></a>
+
+### Styles
+
+Chroma styles are defined in XML. The style entries use the
+[same syntax](http://pygments.org/docs/styles/) as Pygments.
+
+All Pygments styles have been converted to Chroma using the `_tools/style.py`
+script.
+
+When you work with one of [Chroma's styles](https://github.com/alecthomas/chroma/tree/master/styles),
+know that the `Background` token type provides the default style for tokens. It does so
+by defining a foreground color and background color.
+
+For example, this gives each token name not defined in the style a default color
+of `#f8f8f8` and uses `#000000` for the highlighted code block's background:
+
+```xml
+<entry type="Background" style="#f8f8f2 bg:#000000"/>
+```
+
+Also, token types in a style file are hierarchical. For instance, when `CommentSpecial` is not defined, Chroma uses the token style from `Comment`. So when several comment tokens use the same color, you'll only need to define `Comment` and override the one that has a different color.
+
+For a quick overview of the available styles and how they look, check out the [Chroma Style Gallery](https://xyproto.github.io/splash/docs/).
+
+<a id="markdown-command-line-interface" name="command-line-interface"></a>
+
+## Command-line interface
+
+A command-line interface to Chroma is included.
+
+Binaries are available to install from [the releases page](https://github.com/alecthomas/chroma/releases).
+
+The CLI can be used as a preprocessor to colorise output of `less(1)`,
+see documentation for the `LESSOPEN` environment variable.
+
+The `--fail` flag can be used to suppress output and return with exit status
+1 to facilitate falling back to some other preprocessor in case chroma
+does not resolve a specific lexer to use for the given file. For example:
+
+```shell
+export LESSOPEN='| p() { chroma --fail "$1" || cat "$1"; }; p "%s"'
+```
+
+Replace `cat` with your favourite fallback preprocessor.
+
+When invoked as `.lessfilter`, the `--fail` flag is automatically turned
+on under the hood for easy integration with [lesspipe shipping with
+Debian and derivatives](https://manpages.debian.org/lesspipe#USER_DEFINED_FILTERS);
+for that setup the `chroma` executable can be just symlinked to `~/.lessfilter`.
+
+<a id="markdown-whats-missing-compared-to-pygments" name="whats-missing-compared-to-pygments"></a>
+
+<a id="markdown-testing-lexers" name="testing-lexers"></a>
+
+## Testing lexers
+
+If you edit some lexers and want to try it, open a shell in `cmd/chromad` and run:
+
+```shell
+go run .
+```
+
+A Link will be printed. Open it in your Browser. Now you can test on the Playground with your local changes.
+
+If you want to run the tests and the lexers, open a shell in the root directory and run:
+
+```shell
+go test ./lexers
+```
+
+When updating or adding a lexer, please add tests. See [lexers/README.md](lexers/README.md) for more.
+
+## What's missing compared to Pygments?
+
+- Quite a few lexers, for various reasons (pull-requests welcome):
+  - Pygments lexers for complex languages often include custom code to
+    handle certain aspects, such as Raku's ability to nest code inside
+    regular expressions. These require time and effort to convert.
+  - I mostly only converted languages I had heard of, to reduce the porting cost.
+- Some more esoteric features of Pygments are omitted for simplicity.
+- Though the Chroma API supports content detection, very few languages support them.
+  I have plans to implement a statistical analyser at some point, but not enough time.

vendor/github.com/alecthomas/chroma/v2/coalesce.go

@@ -0,0 +1,35 @@
+package chroma
+
+// Coalesce is a Lexer interceptor that collapses runs of common types into a single token.
+func Coalesce(lexer Lexer) Lexer { return &coalescer{lexer} }
+
+type coalescer struct{ Lexer }
+
+func (d *coalescer) Tokenise(options *TokeniseOptions, text string) (Iterator, error) {
+	var prev Token
+	it, err := d.Lexer.Tokenise(options, text)
+	if err != nil {
+		return nil, err
+	}
+	return func() Token {
+		for token := it(); token != (EOF); token = it() {
+			if len(token.Value) == 0 {
+				continue
+			}
+			if prev == EOF {
+				prev = token
+			} else {
+				if prev.Type == token.Type && len(prev.Value) < 8192 {
+					prev.Value += token.Value
+				} else {
+					out := prev
+					prev = token
+					return out
+				}
+			}
+		}
+		out := prev
+		prev = EOF
+		return out
+	}, nil
+}

vendor/github.com/alecthomas/chroma/v2/colour.go

@@ -0,0 +1,192 @@
+package chroma
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+// ANSI2RGB maps ANSI colour names, as supported by Chroma, to hex RGB values.
+var ANSI2RGB = map[string]string{
+	"#ansiblack":     "000000",
+	"#ansidarkred":   "7f0000",
+	"#ansidarkgreen": "007f00",
+	"#ansibrown":     "7f7fe0",
+	"#ansidarkblue":  "00007f",
+	"#ansipurple":    "7f007f",
+	"#ansiteal":      "007f7f",
+	"#ansilightgray": "e5e5e5",
+	// Normal
+	"#ansidarkgray":  "555555",
+	"#ansired":       "ff0000",
+	"#ansigreen":     "00ff00",
+	"#ansiyellow":    "ffff00",
+	"#ansiblue":      "0000ff",
+	"#ansifuchsia":   "ff00ff",
+	"#ansiturquoise": "00ffff",
+	"#ansiwhite":     "ffffff",
+
+	// Aliases without the "ansi" prefix, because...why?
+	"#black":     "000000",
+	"#darkred":   "7f0000",
+	"#darkgreen": "007f00",
+	"#brown":     "7f7fe0",
+	"#darkblue":  "00007f",
+	"#purple":    "7f007f",
+	"#teal":      "007f7f",
+	"#lightgray": "e5e5e5",
+	// Normal
+	"#darkgray":  "555555",
+	"#red":       "ff0000",
+	"#green":     "00ff00",
+	"#yellow":    "ffff00",
+	"#blue":      "0000ff",
+	"#fuchsia":   "ff00ff",
+	"#turquoise": "00ffff",
+	"#white":     "ffffff",
+}
+
+// Colour represents an RGB colour.
+type Colour int32
+
+// NewColour creates a Colour directly from RGB values.
+func NewColour(r, g, b uint8) Colour {
+	return ParseColour(fmt.Sprintf("%02x%02x%02x", r, g, b))
+}
+
+// Distance between this colour and another.
+//
+// This uses the approach described here (https://www.compuphase.com/cmetric.htm).
+// This is not as accurate as LAB, et. al. but is *vastly* simpler and sufficient for our needs.
+func (c Colour) Distance(e2 Colour) float64 {
+	ar, ag, ab := int64(c.Red()), int64(c.Green()), int64(c.Blue())
+	br, bg, bb := int64(e2.Red()), int64(e2.Green()), int64(e2.Blue())
+	rmean := (ar + br) / 2
+	r := ar - br
+	g := ag - bg
+	b := ab - bb
+	return math.Sqrt(float64((((512 + rmean) * r * r) >> 8) + 4*g*g + (((767 - rmean) * b * b) >> 8)))
+}
+
+// Brighten returns a copy of this colour with its brightness adjusted.
+//
+// If factor is negative, the colour is darkened.
+//
+// Uses approach described here (http://www.pvladov.com/2012/09/make-color-lighter-or-darker.html).
+func (c Colour) Brighten(factor float64) Colour {
+	r := float64(c.Red())
+	g := float64(c.Green())
+	b := float64(c.Blue())
+
+	if factor < 0 {
+		factor++
+		r *= factor
+		g *= factor
+		b *= factor
+	} else {
+		r = (255-r)*factor + r
+		g = (255-g)*factor + g
+		b = (255-b)*factor + b
+	}
+	return NewColour(uint8(r), uint8(g), uint8(b))
+}
+
+// BrightenOrDarken brightens a colour if it is < 0.5 brightness or darkens if > 0.5 brightness.
+func (c Colour) BrightenOrDarken(factor float64) Colour {
+	if c.Brightness() < 0.5 {
+		return c.Brighten(factor)
+	}
+	return c.Brighten(-factor)
+}
+
+// ClampBrightness returns a copy of this colour with its brightness adjusted such that
+// it falls within the range [min, max] (or very close to it due to rounding errors).
+// The supplied values use the same [0.0, 1.0] range as Brightness.
+func (c Colour) ClampBrightness(min, max float64) Colour {
+	if !c.IsSet() {
+		return c
+	}
+
+	min = math.Max(min, 0)
+	max = math.Min(max, 1)
+	current := c.Brightness()
+	target := math.Min(math.Max(current, min), max)
+	if current == target {
+		return c
+	}
+
+	r := float64(c.Red())
+	g := float64(c.Green())
+	b := float64(c.Blue())
+	rgb := r + g + b
+	if target > current {
+		// Solve for x: target == ((255-r)*x + r + (255-g)*x + g + (255-b)*x + b) / 255 / 3
+		return c.Brighten((target*255*3 - rgb) / (255*3 - rgb))
+	}
+	// Solve for x: target == (r*(x+1) + g*(x+1) + b*(x+1)) / 255 / 3
+	return c.Brighten((target*255*3)/rgb - 1)
+}
+
+// Brightness of the colour (roughly) in the range 0.0 to 1.0.
+func (c Colour) Brightness() float64 {
+	return (float64(c.Red()) + float64(c.Green()) + float64(c.Blue())) / 255.0 / 3.0
+}
+
+// ParseColour in the forms #rgb, #rrggbb, #ansi<colour>, or #<colour>.
+// Will return an "unset" colour if invalid.
+func ParseColour(colour string) Colour {
+	colour = normaliseColour(colour)
+	n, err := strconv.ParseUint(colour, 16, 32)
+	if err != nil {
+		return 0
+	}
+	return Colour(n + 1)
+}
+
+// MustParseColour is like ParseColour except it panics if the colour is invalid.
+//
+// Will panic if colour is in an invalid format.
+func MustParseColour(colour string) Colour {
+	parsed := ParseColour(colour)
+	if !parsed.IsSet() {
+		panic(fmt.Errorf("invalid colour %q", colour))
+	}
+	return parsed
+}
+
+// IsSet returns true if the colour is set.
+func (c Colour) IsSet() bool { return c != 0 }
+
+func (c Colour) String() string   { return fmt.Sprintf("#%06x", int(c-1)) }
+func (c Colour) GoString() string { return fmt.Sprintf("Colour(0x%06x)", int(c-1)) }
+
+// Red component of colour.
+func (c Colour) Red() uint8 { return uint8(((c - 1) >> 16) & 0xff) }
+
+// Green component of colour.
+func (c Colour) Green() uint8 { return uint8(((c - 1) >> 8) & 0xff) }
+
+// Blue component of colour.
+func (c Colour) Blue() uint8 { return uint8((c - 1) & 0xff) }
+
+// Colours is an orderable set of colours.
+type Colours []Colour
+
+func (c Colours) Len() int           { return len(c) }
+func (c Colours) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
+func (c Colours) Less(i, j int) bool { return c[i] < c[j] }
+
+// Convert colours to #rrggbb.
+func normaliseColour(colour string) string {
+	if ansi, ok := ANSI2RGB[colour]; ok {
+		return ansi
+	}
+	if strings.HasPrefix(colour, "#") {
+		colour = colour[1:]
+		if len(colour) == 3 {
+			return colour[0:1] + colour[0:1] + colour[1:2] + colour[1:2] + colour[2:3] + colour[2:3]
+		}
+	}
+	return colour
+}

vendor/github.com/alecthomas/chroma/v2/delegate.go

@@ -0,0 +1,152 @@
+package chroma
+
+import (
+	"bytes"
+)
+
+type delegatingLexer struct {
+	root     Lexer
+	language Lexer
+}
+
+// DelegatingLexer combines two lexers to handle the common case of a language embedded inside another, such as PHP
+// inside HTML or PHP inside plain text.
+//
+// It takes two lexer as arguments: a root lexer and a language lexer.  First everything is scanned using the language
+// lexer, which must return "Other" for unrecognised tokens. Then all "Other" tokens are lexed using the root lexer.
+// Finally, these two sets of tokens are merged.
+//
+// The lexers from the template lexer package use this base lexer.
+func DelegatingLexer(root Lexer, language Lexer) Lexer {
+	return &delegatingLexer{
+		root:     root,
+		language: language,
+	}
+}
+
+func (d *delegatingLexer) AnalyseText(text string) float32 {
+	return d.root.AnalyseText(text)
+}
+
+func (d *delegatingLexer) SetAnalyser(analyser func(text string) float32) Lexer {
+	d.root.SetAnalyser(analyser)
+	return d
+}
+
+func (d *delegatingLexer) SetRegistry(r *LexerRegistry) Lexer {
+	d.root.SetRegistry(r)
+	d.language.SetRegistry(r)
+	return d
+}
+
+func (d *delegatingLexer) Config() *Config {
+	return d.language.Config()
+}
+
+// An insertion is the character range where language tokens should be inserted.
+type insertion struct {
+	start, end int
+	tokens     []Token
+}
+
+func (d *delegatingLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error) { // nolint: gocognit
+	tokens, err := Tokenise(Coalesce(d.language), options, text)
+	if err != nil {
+		return nil, err
+	}
+	// Compute insertions and gather "Other" tokens.
+	others := &bytes.Buffer{}
+	insertions := []*insertion{}
+	var insert *insertion
+	offset := 0
+	var last Token
+	for _, t := range tokens {
+		if t.Type == Other {
+			if last != EOF && insert != nil && last.Type != Other {
+				insert.end = offset
+			}
+			others.WriteString(t.Value)
+		} else {
+			if last == EOF || last.Type == Other {
+				insert = &insertion{start: offset}
+				insertions = append(insertions, insert)
+			}
+			insert.tokens = append(insert.tokens, t)
+		}
+		last = t
+		offset += len(t.Value)
+	}
+
+	if len(insertions) == 0 {
+		return d.root.Tokenise(options, text)
+	}
+
+	// Lex the other tokens.
+	rootTokens, err := Tokenise(Coalesce(d.root), options, others.String())
+	if err != nil {
+		return nil, err
+	}
+
+	// Interleave the two sets of tokens.
+	var out []Token
+	offset = 0 // Offset into text.
+	tokenIndex := 0
+	nextToken := func() Token {
+		if tokenIndex >= len(rootTokens) {
+			return EOF
+		}
+		t := rootTokens[tokenIndex]
+		tokenIndex++
+		return t
+	}
+	insertionIndex := 0
+	nextInsertion := func() *insertion {
+		if insertionIndex >= len(insertions) {
+			return nil
+		}
+		i := insertions[insertionIndex]
+		insertionIndex++
+		return i
+	}
+	t := nextToken()
+	i := nextInsertion()
+	for t != EOF || i != nil {
+		// fmt.Printf("%d->%d:%q   %d->%d:%q\n", offset, offset+len(t.Value), t.Value, i.start, i.end, Stringify(i.tokens...))
+		if t == EOF || (i != nil && i.start < offset+len(t.Value)) {
+			var l Token
+			l, t = splitToken(t, i.start-offset)
+			if l != EOF {
+				out = append(out, l)
+				offset += len(l.Value)
+			}
+			out = append(out, i.tokens...)
+			offset += i.end - i.start
+			if t == EOF {
+				t = nextToken()
+			}
+			i = nextInsertion()
+		} else {
+			out = append(out, t)
+			offset += len(t.Value)
+			t = nextToken()
+		}
+	}
+	return Literator(out...), nil
+}
+
+func splitToken(t Token, offset int) (l Token, r Token) {
+	if t == EOF {
+		return EOF, EOF
+	}
+	if offset == 0 {
+		return EOF, t
+	}
+	if offset == len(t.Value) {
+		return t, EOF
+	}
+	l = t.Clone()
+	r = t.Clone()
+	l.Value = l.Value[:offset]
+	r.Value = r.Value[offset:]
+	return
+}

vendor/github.com/alecthomas/chroma/v2/doc.go

@@ -0,0 +1,7 @@
+// Package chroma takes source code and other structured text and converts it into syntax highlighted HTML, ANSI-
+// coloured text, etc.
+//
+// Chroma is based heavily on Pygments, and includes translators for Pygments lexers and styles.
+//
+// For more information, go here: https://github.com/alecthomas/chroma
+package chroma

vendor/github.com/alecthomas/chroma/v2/emitters.go

@@ -0,0 +1,218 @@
+package chroma
+
+import (
+	"fmt"
+)
+
+// An Emitter takes group matches and returns tokens.
+type Emitter interface {
+	// Emit tokens for the given regex groups.
+	Emit(groups []string, state *LexerState) Iterator
+}
+
+// SerialisableEmitter is an Emitter that can be serialised and deserialised to/from JSON.
+type SerialisableEmitter interface {
+	Emitter
+	EmitterKind() string
+}
+
+// EmitterFunc is a function that is an Emitter.
+type EmitterFunc func(groups []string, state *LexerState) Iterator
+
+// Emit tokens for groups.
+func (e EmitterFunc) Emit(groups []string, state *LexerState) Iterator {
+	return e(groups, state)
+}
+
+type Emitters []Emitter
+
+type byGroupsEmitter struct {
+	Emitters
+}
+
+// ByGroups emits a token for each matching group in the rule's regex.
+func ByGroups(emitters ...Emitter) Emitter {
+	return &byGroupsEmitter{Emitters: emitters}
+}
+
+func (b *byGroupsEmitter) EmitterKind() string { return "bygroups" }
+
+func (b *byGroupsEmitter) Emit(groups []string, state *LexerState) Iterator {
+	iterators := make([]Iterator, 0, len(groups)-1)
+	if len(b.Emitters) != len(groups)-1 {
+		iterators = append(iterators, Error.Emit(groups, state))
+		// panic(errors.Errorf("number of groups %q does not match number of emitters %v", groups, emitters))
+	} else {
+		for i, group := range groups[1:] {
+			if b.Emitters[i] != nil {
+				iterators = append(iterators, b.Emitters[i].Emit([]string{group}, state))
+			}
+		}
+	}
+	return Concaterator(iterators...)
+}
+
+// ByGroupNames emits a token for each named matching group in the rule's regex.
+func ByGroupNames(emitters map[string]Emitter) Emitter {
+	return EmitterFunc(func(groups []string, state *LexerState) Iterator {
+		iterators := make([]Iterator, 0, len(state.NamedGroups)-1)
+		if len(state.NamedGroups)-1 == 0 {
+			if emitter, ok := emitters[`0`]; ok {
+				iterators = append(iterators, emitter.Emit(groups, state))
+			} else {
+				iterators = append(iterators, Error.Emit(groups, state))
+			}
+		} else {
+			ruleRegex := state.Rules[state.State][state.Rule].Regexp
+			for i := 1; i < len(state.NamedGroups); i++ {
+				groupName := ruleRegex.GroupNameFromNumber(i)
+				group := state.NamedGroups[groupName]
+				if emitter, ok := emitters[groupName]; ok {
+					if emitter != nil {
+						iterators = append(iterators, emitter.Emit([]string{group}, state))
+					}
+				} else {
+					iterators = append(iterators, Error.Emit([]string{group}, state))
+				}
+			}
+		}
+		return Concaterator(iterators...)
+	})
+}
+
+// UsingByGroup emits tokens for the matched groups in the regex using a
+// sublexer. Used when lexing code blocks where the name of a sublexer is
+// contained within the block, for example on a Markdown text block or SQL
+// language block.
+//
+// An attempt to load the sublexer will be made using the captured value from
+// the text of the matched sublexerNameGroup. If a sublexer matching the
+// sublexerNameGroup is available, then tokens for the matched codeGroup will
+// be emitted using the sublexer. Otherwise, if no sublexer is available, then
+// tokens will be emitted from the passed emitter.
+//
+// Example:
+//
+//	var Markdown = internal.Register(MustNewLexer(
+//		&Config{
+//			Name:      "markdown",
+//			Aliases:   []string{"md", "mkd"},
+//			Filenames: []string{"*.md", "*.mkd", "*.markdown"},
+//			MimeTypes: []string{"text/x-markdown"},
+//		},
+//		Rules{
+//			"root": {
+//				{"^(```)(\\w+)(\\n)([\\w\\W]*?)(^```$)",
+//					UsingByGroup(
+//						2, 4,
+//						String, String, String, Text, String,
+//					),
+//					nil,
+//				},
+//			},
+//		},
+//	))
+//
+// See the lexers/markdown.go for the complete example.
+//
+// Note: panic's if the number of emitters does not equal the number of matched
+// groups in the regex.
+func UsingByGroup(sublexerNameGroup, codeGroup int, emitters ...Emitter) Emitter {
+	return &usingByGroup{
+		SublexerNameGroup: sublexerNameGroup,
+		CodeGroup:         codeGroup,
+		Emitters:          emitters,
+	}
+}
+
+type usingByGroup struct {
+	SublexerNameGroup int      `xml:"sublexer_name_group"`
+	CodeGroup         int      `xml:"code_group"`
+	Emitters          Emitters `xml:"emitters"`
+}
+
+func (u *usingByGroup) EmitterKind() string { return "usingbygroup" }
+func (u *usingByGroup) Emit(groups []string, state *LexerState) Iterator {
+	// bounds check
+	if len(u.Emitters) != len(groups)-1 {
+		panic("UsingByGroup expects number of emitters to be the same as len(groups)-1")
+	}
+
+	// grab sublexer
+	sublexer := state.Registry.Get(groups[u.SublexerNameGroup])
+
+	// build iterators
+	iterators := make([]Iterator, len(groups)-1)
+	for i, group := range groups[1:] {
+		if i == u.CodeGroup-1 && sublexer != nil {
+			var err error
+			iterators[i], err = sublexer.Tokenise(nil, groups[u.CodeGroup])
+			if err != nil {
+				panic(err)
+			}
+		} else if u.Emitters[i] != nil {
+			iterators[i] = u.Emitters[i].Emit([]string{group}, state)
+		}
+	}
+	return Concaterator(iterators...)
+}
+
+// UsingLexer returns an Emitter that uses a given Lexer for parsing and emitting.
+//
+// This Emitter is not serialisable.
+func UsingLexer(lexer Lexer) Emitter {
+	return EmitterFunc(func(groups []string, _ *LexerState) Iterator {
+		it, err := lexer.Tokenise(&TokeniseOptions{State: "root", Nested: true}, groups[0])
+		if err != nil {
+			panic(err)
+		}
+		return it
+	})
+}
+
+type usingEmitter struct {
+	Lexer string `xml:"lexer,attr"`
+}
+
+func (u *usingEmitter) EmitterKind() string { return "using" }
+
+func (u *usingEmitter) Emit(groups []string, state *LexerState) Iterator {
+	if state.Registry == nil {
+		panic(fmt.Sprintf("no LexerRegistry available for Using(%q)", u.Lexer))
+	}
+	lexer := state.Registry.Get(u.Lexer)
+	if lexer == nil {
+		panic(fmt.Sprintf("no such lexer %q", u.Lexer))
+	}
+	it, err := lexer.Tokenise(&TokeniseOptions{State: "root", Nested: true}, groups[0])
+	if err != nil {
+		panic(err)
+	}
+	return it
+}
+
+// Using returns an Emitter that uses a given Lexer reference for parsing and emitting.
+//
+// The referenced lexer must be stored in the same LexerRegistry.
+func Using(lexer string) Emitter {
+	return &usingEmitter{Lexer: lexer}
+}
+
+type usingSelfEmitter struct {
+	State string `xml:"state,attr"`
+}
+
+func (u *usingSelfEmitter) EmitterKind() string { return "usingself" }
+
+func (u *usingSelfEmitter) Emit(groups []string, state *LexerState) Iterator {
+	it, err := state.Lexer.Tokenise(&TokeniseOptions{State: u.State, Nested: true}, groups[0])
+	if err != nil {
+		panic(err)
+	}
+	return it
+}
+
+// UsingSelf is like Using, but uses the current Lexer.
+func UsingSelf(stateName string) Emitter {
+	return &usingSelfEmitter{stateName}
+}

vendor/github.com/alecthomas/chroma/v2/formatter.go

@@ -0,0 +1,43 @@
+package chroma
+
+import (
+	"io"
+)
+
+// A Formatter for Chroma lexers.
+type Formatter interface {
+	// Format returns a formatting function for tokens.
+	//
+	// If the iterator panics, the Formatter should recover.
+	Format(w io.Writer, style *Style, iterator Iterator) error
+}
+
+// A FormatterFunc is a Formatter implemented as a function.
+//
+// Guards against iterator panics.
+type FormatterFunc func(w io.Writer, style *Style, iterator Iterator) error
+
+func (f FormatterFunc) Format(w io.Writer, s *Style, it Iterator) (err error) { // nolint
+	defer func() {
+		if perr := recover(); perr != nil {
+			err = perr.(error)
+		}
+	}()
+	return f(w, s, it)
+}
+
+type recoveringFormatter struct {
+	Formatter
+}
+
+func (r recoveringFormatter) Format(w io.Writer, s *Style, it Iterator) (err error) {
+	defer func() {
+		if perr := recover(); perr != nil {
+			err = perr.(error)
+		}
+	}()
+	return r.Formatter.Format(w, s, it)
+}
+
+// RecoveringFormatter wraps a formatter with panic recovery.
+func RecoveringFormatter(formatter Formatter) Formatter { return recoveringFormatter{formatter} }

vendor/github.com/alecthomas/chroma/v2/formatters/html/html.go

@@ -0,0 +1,564 @@
+package html
+
+import (
+	"fmt"
+	"html"
+	"io"
+	"sort"
+	"strings"
+
+	"github.com/alecthomas/chroma/v2"
+)
+
+// Option sets an option of the HTML formatter.
+type Option func(f *Formatter)
+
+// Standalone configures the HTML formatter for generating a standalone HTML document.
+func Standalone(b bool) Option { return func(f *Formatter) { f.standalone = b } }
+
+// ClassPrefix sets the CSS class prefix.
+func ClassPrefix(prefix string) Option { return func(f *Formatter) { f.prefix = prefix } }
+
+// WithClasses emits HTML using CSS classes, rather than inline styles.
+func WithClasses(b bool) Option { return func(f *Formatter) { f.Classes = b } }
+
+// WithAllClasses disables an optimisation that omits redundant CSS classes.
+func WithAllClasses(b bool) Option { return func(f *Formatter) { f.allClasses = b } }
+
+// WithCustomCSS sets user's custom CSS styles.
+func WithCustomCSS(css map[chroma.TokenType]string) Option {
+	return func(f *Formatter) {
+		f.customCSS = css
+	}
+}
+
+// TabWidth sets the number of characters for a tab. Defaults to 8.
+func TabWidth(width int) Option { return func(f *Formatter) { f.tabWidth = width } }
+
+// PreventSurroundingPre prevents the surrounding pre tags around the generated code.
+func PreventSurroundingPre(b bool) Option {
+	return func(f *Formatter) {
+		f.preventSurroundingPre = b
+
+		if b {
+			f.preWrapper = nopPreWrapper
+		} else {
+			f.preWrapper = defaultPreWrapper
+		}
+	}
+}
+
+// InlineCode creates inline code wrapped in a code tag.
+func InlineCode(b bool) Option {
+	return func(f *Formatter) {
+		f.inlineCode = b
+		f.preWrapper = preWrapper{
+			start: func(code bool, styleAttr string) string {
+				if code {
+					return fmt.Sprintf(`<code%s>`, styleAttr)
+				}
+
+				return ``
+			},
+			end: func(code bool) string {
+				if code {
+					return `</code>`
+				}
+
+				return ``
+			},
+		}
+	}
+}
+
+// WithPreWrapper allows control of the surrounding pre tags.
+func WithPreWrapper(wrapper PreWrapper) Option {
+	return func(f *Formatter) {
+		f.preWrapper = wrapper
+	}
+}
+
+// WrapLongLines wraps long lines.
+func WrapLongLines(b bool) Option {
+	return func(f *Formatter) {
+		f.wrapLongLines = b
+	}
+}
+
+// WithLineNumbers formats output with line numbers.
+func WithLineNumbers(b bool) Option {
+	return func(f *Formatter) {
+		f.lineNumbers = b
+	}
+}
+
+// LineNumbersInTable will, when combined with WithLineNumbers, separate the line numbers
+// and code in table td's, which make them copy-and-paste friendly.
+func LineNumbersInTable(b bool) Option {
+	return func(f *Formatter) {
+		f.lineNumbersInTable = b
+	}
+}
+
+// WithLinkableLineNumbers decorates the line numbers HTML elements with an "id"
+// attribute so they can be linked.
+func WithLinkableLineNumbers(b bool, prefix string) Option {
+	return func(f *Formatter) {
+		f.linkableLineNumbers = b
+		f.lineNumbersIDPrefix = prefix
+	}
+}
+
+// HighlightLines higlights the given line ranges with the Highlight style.
+//
+// A range is the beginning and ending of a range as 1-based line numbers, inclusive.
+func HighlightLines(ranges [][2]int) Option {
+	return func(f *Formatter) {
+		f.highlightRanges = ranges
+		sort.Sort(f.highlightRanges)
+	}
+}
+
+// BaseLineNumber sets the initial number to start line numbering at. Defaults to 1.
+func BaseLineNumber(n int) Option {
+	return func(f *Formatter) {
+		f.baseLineNumber = n
+	}
+}
+
+// New HTML formatter.
+func New(options ...Option) *Formatter {
+	f := &Formatter{
+		baseLineNumber: 1,
+		preWrapper:     defaultPreWrapper,
+	}
+	for _, option := range options {
+		option(f)
+	}
+	return f
+}
+
+// PreWrapper defines the operations supported in WithPreWrapper.
+type PreWrapper interface {
+	// Start is called to write a start <pre> element.
+	// The code flag tells whether this block surrounds
+	// highlighted code. This will be false when surrounding
+	// line numbers.
+	Start(code bool, styleAttr string) string
+
+	// End is called to write the end </pre> element.
+	End(code bool) string
+}
+
+type preWrapper struct {
+	start func(code bool, styleAttr string) string
+	end   func(code bool) string
+}
+
+func (p preWrapper) Start(code bool, styleAttr string) string {
+	return p.start(code, styleAttr)
+}
+
+func (p preWrapper) End(code bool) string {
+	return p.end(code)
+}
+
+var (
+	nopPreWrapper = preWrapper{
+		start: func(code bool, styleAttr string) string { return "" },
+		end:   func(code bool) string { return "" },
+	}
+	defaultPreWrapper = preWrapper{
+		start: func(code bool, styleAttr string) string {
+			if code {
+				return fmt.Sprintf(`<pre%s><code>`, styleAttr)
+			}
+
+			return fmt.Sprintf(`<pre%s>`, styleAttr)
+		},
+		end: func(code bool) string {
+			if code {
+				return `</code></pre>`
+			}
+
+			return `</pre>`
+		},
+	}
+)
+
+// Formatter that generates HTML.
+type Formatter struct {
+	standalone            bool
+	prefix                string
+	Classes               bool // Exported field to detect when classes are being used
+	allClasses            bool
+	customCSS             map[chroma.TokenType]string
+	preWrapper            PreWrapper
+	inlineCode            bool
+	preventSurroundingPre bool
+	tabWidth              int
+	wrapLongLines         bool
+	lineNumbers           bool
+	lineNumbersInTable    bool
+	linkableLineNumbers   bool
+	lineNumbersIDPrefix   string
+	highlightRanges       highlightRanges
+	baseLineNumber        int
+}
+
+type highlightRanges [][2]int
+
+func (h highlightRanges) Len() int           { return len(h) }
+func (h highlightRanges) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h highlightRanges) Less(i, j int) bool { return h[i][0] < h[j][0] }
+
+func (f *Formatter) Format(w io.Writer, style *chroma.Style, iterator chroma.Iterator) (err error) {
+	return f.writeHTML(w, style, iterator.Tokens())
+}
+
+// We deliberately don't use html/template here because it is two orders of magnitude slower (benchmarked).
+//
+// OTOH we need to be super careful about correct escaping...
+func (f *Formatter) writeHTML(w io.Writer, style *chroma.Style, tokens []chroma.Token) (err error) { // nolint: gocyclo
+	css := f.styleToCSS(style)
+	if !f.Classes {
+		for t, style := range css {
+			css[t] = compressStyle(style)
+		}
+	}
+	if f.standalone {
+		fmt.Fprint(w, "<html>\n")
+		if f.Classes {
+			fmt.Fprint(w, "<style type=\"text/css\">\n")
+			err = f.WriteCSS(w, style)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(w, "body { %s; }\n", css[chroma.Background])
+			fmt.Fprint(w, "</style>")
+		}
+		fmt.Fprintf(w, "<body%s>\n", f.styleAttr(css, chroma.Background))
+	}
+
+	wrapInTable := f.lineNumbers && f.lineNumbersInTable
+
+	lines := chroma.SplitTokensIntoLines(tokens)
+	lineDigits := len(fmt.Sprintf("%d", f.baseLineNumber+len(lines)-1))
+	highlightIndex := 0
+
+	if wrapInTable {
+		// List line numbers in its own <td>
+		fmt.Fprintf(w, "<div%s>\n", f.styleAttr(css, chroma.PreWrapper))
+		fmt.Fprintf(w, "<table%s><tr>", f.styleAttr(css, chroma.LineTable))
+		fmt.Fprintf(w, "<td%s>\n", f.styleAttr(css, chroma.LineTableTD))
+		fmt.Fprintf(w, f.preWrapper.Start(false, f.styleAttr(css, chroma.PreWrapper)))
+		for index := range lines {
+			line := f.baseLineNumber + index
+			highlight, next := f.shouldHighlight(highlightIndex, line)
+			if next {
+				highlightIndex++
+			}
+			if highlight {
+				fmt.Fprintf(w, "<span%s>", f.styleAttr(css, chroma.LineHighlight))
+			}
+
+			fmt.Fprintf(w, "<span%s%s>%s\n</span>", f.styleAttr(css, chroma.LineNumbersTable), f.lineIDAttribute(line), f.lineTitleWithLinkIfNeeded(css, lineDigits, line))
+
+			if highlight {
+				fmt.Fprintf(w, "</span>")
+			}
+		}
+		fmt.Fprint(w, f.preWrapper.End(false))
+		fmt.Fprint(w, "</td>\n")
+		fmt.Fprintf(w, "<td%s>\n", f.styleAttr(css, chroma.LineTableTD, "width:100%"))
+	}
+
+	fmt.Fprintf(w, f.preWrapper.Start(true, f.styleAttr(css, chroma.PreWrapper)))
+
+	highlightIndex = 0
+	for index, tokens := range lines {
+		// 1-based line number.
+		line := f.baseLineNumber + index
+		highlight, next := f.shouldHighlight(highlightIndex, line)
+		if next {
+			highlightIndex++
+		}
+
+		if !(f.preventSurroundingPre || f.inlineCode) {
+			// Start of Line
+			fmt.Fprint(w, `<span`)
+
+			if highlight {
+				// Line + LineHighlight
+				if f.Classes {
+					fmt.Fprintf(w, ` class="%s %s"`, f.class(chroma.Line), f.class(chroma.LineHighlight))
+				} else {
+					fmt.Fprintf(w, ` style="%s %s"`, css[chroma.Line], css[chroma.LineHighlight])
+				}
+				fmt.Fprint(w, `>`)
+			} else {
+				fmt.Fprintf(w, "%s>", f.styleAttr(css, chroma.Line))
+			}
+
+			// Line number
+			if f.lineNumbers && !wrapInTable {
+				fmt.Fprintf(w, "<span%s%s>%s</span>", f.styleAttr(css, chroma.LineNumbers), f.lineIDAttribute(line), f.lineTitleWithLinkIfNeeded(css, lineDigits, line))
+			}
+
+			fmt.Fprintf(w, `<span%s>`, f.styleAttr(css, chroma.CodeLine))
+		}
+
+		for _, token := range tokens {
+			html := html.EscapeString(token.String())
+			attr := f.styleAttr(css, token.Type)
+			if attr != "" {
+				html = fmt.Sprintf("<span%s>%s</span>", attr, html)
+			}
+			fmt.Fprint(w, html)
+		}
+
+		if !(f.preventSurroundingPre || f.inlineCode) {
+			fmt.Fprint(w, `</span>`) // End of CodeLine
+
+			fmt.Fprint(w, `</span>`) // End of Line
+		}
+	}
+	fmt.Fprintf(w, f.preWrapper.End(true))
+
+	if wrapInTable {
+		fmt.Fprint(w, "</td></tr></table>\n")
+		fmt.Fprint(w, "</div>\n")
+	}
+
+	if f.standalone {
+		fmt.Fprint(w, "\n</body>\n")
+		fmt.Fprint(w, "</html>\n")
+	}
+
+	return nil
+}
+
+func (f *Formatter) lineIDAttribute(line int) string {
+	if !f.linkableLineNumbers {
+		return ""
+	}
+	return fmt.Sprintf(" id=\"%s\"", f.lineID(line))
+}
+
+func (f *Formatter) lineTitleWithLinkIfNeeded(css map[chroma.TokenType]string, lineDigits, line int) string {
+	title := fmt.Sprintf("%*d", lineDigits, line)
+	if !f.linkableLineNumbers {
+		return title
+	}
+	return fmt.Sprintf("<a%s href=\"#%s\">%s</a>", f.styleAttr(css, chroma.LineLink), f.lineID(line), title)
+}
+
+func (f *Formatter) lineID(line int) string {
+	return fmt.Sprintf("%s%d", f.lineNumbersIDPrefix, line)
+}
+
+func (f *Formatter) shouldHighlight(highlightIndex, line int) (bool, bool) {
+	next := false
+	for highlightIndex < len(f.highlightRanges) && line > f.highlightRanges[highlightIndex][1] {
+		highlightIndex++
+		next = true
+	}
+	if highlightIndex < len(f.highlightRanges) {
+		hrange := f.highlightRanges[highlightIndex]
+		if line >= hrange[0] && line <= hrange[1] {
+			return true, next
+		}
+	}
+	return false, next
+}
+
+func (f *Formatter) class(t chroma.TokenType) string {
+	for t != 0 {
+		if cls, ok := chroma.StandardTypes[t]; ok {
+			if cls != "" {
+				return f.prefix + cls
+			}
+			return ""
+		}
+		t = t.Parent()
+	}
+	if cls := chroma.StandardTypes[t]; cls != "" {
+		return f.prefix + cls
+	}
+	return ""
+}
+
+func (f *Formatter) styleAttr(styles map[chroma.TokenType]string, tt chroma.TokenType, extraCSS ...string) string {
+	if f.Classes {
+		cls := f.class(tt)
+		if cls == "" {
+			return ""
+		}
+		return fmt.Sprintf(` class="%s"`, cls)
+	}
+	if _, ok := styles[tt]; !ok {
+		tt = tt.SubCategory()
+		if _, ok := styles[tt]; !ok {
+			tt = tt.Category()
+			if _, ok := styles[tt]; !ok {
+				return ""
+			}
+		}
+	}
+	css := []string{styles[tt]}
+	css = append(css, extraCSS...)
+	return fmt.Sprintf(` style="%s"`, strings.Join(css, ";"))
+}
+
+func (f *Formatter) tabWidthStyle() string {
+	if f.tabWidth != 0 && f.tabWidth != 8 {
+		return fmt.Sprintf("-moz-tab-size: %[1]d; -o-tab-size: %[1]d; tab-size: %[1]d;", f.tabWidth)
+	}
+	return ""
+}
+
+// WriteCSS writes CSS style definitions (without any surrounding HTML).
+func (f *Formatter) WriteCSS(w io.Writer, style *chroma.Style) error {
+	css := f.styleToCSS(style)
+	// Special-case background as it is mapped to the outer ".chroma" class.
+	if _, err := fmt.Fprintf(w, "/* %s */ .%sbg { %s }\n", chroma.Background, f.prefix, css[chroma.Background]); err != nil {
+		return err
+	}
+	// Special-case PreWrapper as it is the ".chroma" class.
+	if _, err := fmt.Fprintf(w, "/* %s */ .%schroma { %s }\n", chroma.PreWrapper, f.prefix, css[chroma.PreWrapper]); err != nil {
+		return err
+	}
+	// Special-case code column of table to expand width.
+	if f.lineNumbers && f.lineNumbersInTable {
+		if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s:last-child { width: 100%%; }",
+			chroma.LineTableTD, f.prefix, f.class(chroma.LineTableTD)); err != nil {
+			return err
+		}
+	}
+	// Special-case line number highlighting when targeted.
+	if f.lineNumbers || f.lineNumbersInTable {
+		targetedLineCSS := StyleEntryToCSS(style.Get(chroma.LineHighlight))
+		for _, tt := range []chroma.TokenType{chroma.LineNumbers, chroma.LineNumbersTable} {
+			fmt.Fprintf(w, "/* %s targeted by URL anchor */ .%schroma .%s:target { %s }\n", tt, f.prefix, f.class(tt), targetedLineCSS)
+		}
+	}
+	tts := []int{}
+	for tt := range css {
+		tts = append(tts, int(tt))
+	}
+	sort.Ints(tts)
+	for _, ti := range tts {
+		tt := chroma.TokenType(ti)
+		switch tt {
+		case chroma.Background, chroma.PreWrapper:
+			continue
+		}
+		class := f.class(tt)
+		if class == "" {
+			continue
+		}
+		styles := css[tt]
+		if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s { %s }\n", tt, f.prefix, class, styles); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (f *Formatter) styleToCSS(style *chroma.Style) map[chroma.TokenType]string {
+	classes := map[chroma.TokenType]string{}
+	bg := style.Get(chroma.Background)
+	// Convert the style.
+	for t := range chroma.StandardTypes {
+		entry := style.Get(t)
+		if t != chroma.Background {
+			entry = entry.Sub(bg)
+		}
+
+		// Inherit from custom CSS provided by user
+		tokenCategory := t.Category()
+		tokenSubCategory := t.SubCategory()
+		if t != tokenCategory {
+			if css, ok := f.customCSS[tokenCategory]; ok {
+				classes[t] = css
+			}
+		}
+		if tokenCategory != tokenSubCategory {
+			if css, ok := f.customCSS[tokenSubCategory]; ok {
+				classes[t] += css
+			}
+		}
+		// Add custom CSS provided by user
+		if css, ok := f.customCSS[t]; ok {
+			classes[t] += css
+		}
+
+		if !f.allClasses && entry.IsZero() && classes[t] == `` {
+			continue
+		}
+
+		styleEntryCSS := StyleEntryToCSS(entry)
+		if styleEntryCSS != `` && classes[t] != `` {
+			styleEntryCSS += `;`
+		}
+		classes[t] = styleEntryCSS + classes[t]
+	}
+	classes[chroma.Background] += `;` + f.tabWidthStyle()
+	classes[chroma.PreWrapper] += classes[chroma.Background]
+	// Make PreWrapper a grid to show highlight style with full width.
+	if len(f.highlightRanges) > 0 && f.customCSS[chroma.PreWrapper] == `` {
+		classes[chroma.PreWrapper] += `display: grid;`
+	}
+	// Make PreWrapper wrap long lines.
+	if f.wrapLongLines {
+		classes[chroma.PreWrapper] += `white-space: pre-wrap; word-break: break-word;`
+	}
+	lineNumbersStyle := `white-space: pre; -webkit-user-select: none; user-select: none; margin-right: 0.4em; padding: 0 0.4em 0 0.4em;`
+	// All rules begin with default rules followed by user provided rules
+	classes[chroma.Line] = `display: flex;` + classes[chroma.Line]
+	classes[chroma.LineNumbers] = lineNumbersStyle + classes[chroma.LineNumbers]
+	classes[chroma.LineNumbersTable] = lineNumbersStyle + classes[chroma.LineNumbersTable]
+	classes[chroma.LineTable] = "border-spacing: 0; padding: 0; margin: 0; border: 0;" + classes[chroma.LineTable]
+	classes[chroma.LineTableTD] = "vertical-align: top; padding: 0; margin: 0; border: 0;" + classes[chroma.LineTableTD]
+	classes[chroma.LineLink] = "outline: none; text-decoration: none; color: inherit" + classes[chroma.LineLink]
+	return classes
+}
+
+// StyleEntryToCSS converts a chroma.StyleEntry to CSS attributes.
+func StyleEntryToCSS(e chroma.StyleEntry) string {
+	styles := []string{}
+	if e.Colour.IsSet() {
+		styles = append(styles, "color: "+e.Colour.String())
+	}
+	if e.Background.IsSet() {
+		styles = append(styles, "background-color: "+e.Background.String())
+	}
+	if e.Bold == chroma.Yes {
+		styles = append(styles, "font-weight: bold")
+	}
+	if e.Italic == chroma.Yes {
+		styles = append(styles, "font-style: italic")
+	}
+	if e.Underline == chroma.Yes {
+		styles = append(styles, "text-decoration: underline")
+	}
+	return strings.Join(styles, "; ")
+}
+
+// Compress CSS attributes - remove spaces, transform 6-digit colours to 3.
+func compressStyle(s string) string {
+	parts := strings.Split(s, ";")
+	out := []string{}
+	for _, p := range parts {
+		p = strings.Join(strings.Fields(p), " ")
+		p = strings.Replace(p, ": ", ":", 1)
+		if strings.Contains(p, "#") {
+			c := p[len(p)-6:]
+			if c[0] == c[1] && c[2] == c[3] && c[4] == c[5] {
+				p = p[:len(p)-6] + c[0:1] + c[2:3] + c[4:5]
+			}
+		}
+		out = append(out, p)
+	}
+	return strings.Join(out, ";")
+}

vendor/github.com/alecthomas/chroma/v2/iterator.go

@@ -0,0 +1,76 @@
+package chroma
+
+import "strings"
+
+// An Iterator across tokens.
+//
+// EOF will be returned at the end of the Token stream.
+//
+// If an error occurs within an Iterator, it may propagate this in a panic. Formatters should recover.
+type Iterator func() Token
+
+// Tokens consumes all tokens from the iterator and returns them as a slice.
+func (i Iterator) Tokens() []Token {
+	var out []Token
+	for t := i(); t != EOF; t = i() {
+		out = append(out, t)
+	}
+	return out
+}
+
+// Concaterator concatenates tokens from a series of iterators.
+func Concaterator(iterators ...Iterator) Iterator {
+	return func() Token {
+		for len(iterators) > 0 {
+			t := iterators[0]()
+			if t != EOF {
+				return t
+			}
+			iterators = iterators[1:]
+		}
+		return EOF
+	}
+}
+
+// Literator converts a sequence of literal Tokens into an Iterator.
+func Literator(tokens ...Token) Iterator {
+	return func() Token {
+		if len(tokens) == 0 {
+			return EOF
+		}
+		token := tokens[0]
+		tokens = tokens[1:]
+		return token
+	}
+}
+
+// SplitTokensIntoLines splits tokens containing newlines in two.
+func SplitTokensIntoLines(tokens []Token) (out [][]Token) {
+	var line []Token // nolint: prealloc
+	for _, token := range tokens {
+		for strings.Contains(token.Value, "\n") {
+			parts := strings.SplitAfterN(token.Value, "\n", 2)
+			// Token becomes the tail.
+			token.Value = parts[1]
+
+			// Append the head to the line and flush the line.
+			clone := token.Clone()
+			clone.Value = parts[0]
+			line = append(line, clone)
+			out = append(out, line)
+			line = nil
+		}
+		line = append(line, token)
+	}
+	if len(line) > 0 {
+		out = append(out, line)
+	}
+	// Strip empty trailing token line.
+	if len(out) > 0 {
+		last := out[len(out)-1]
+		if len(last) == 1 && last[0].Value == "" {
+			out = out[:len(out)-1]
+		}
+	}
+	return
+}

vendor/github.com/alecthomas/chroma/v2/lexer.go

@@ -0,0 +1,162 @@
+package chroma
+
+import (
+	"fmt"
+	"strings"
+)
+
+var (
+	defaultOptions = &TokeniseOptions{
+		State:    "root",
+		EnsureLF: true,
+	}
+)
+
+// Config for a lexer.
+type Config struct {
+	// Name of the lexer.
+	Name string `xml:"name,omitempty"`
+
+	// Shortcuts for the lexer
+	Aliases []string `xml:"alias,omitempty"`
+
+	// File name globs
+	Filenames []string `xml:"filename,omitempty"`
+
+	// Secondary file name globs
+	AliasFilenames []string `xml:"alias_filename,omitempty"`
+
+	// MIME types
+	MimeTypes []string `xml:"mime_type,omitempty"`
+
+	// Regex matching is case-insensitive.
+	CaseInsensitive bool `xml:"case_insensitive,omitempty"`
+
+	// Regex matches all characters.
+	DotAll bool `xml:"dot_all,omitempty"`
+
+	// Regex does not match across lines ($ matches EOL).
+	//
+	// Defaults to multiline.
+	NotMultiline bool `xml:"not_multiline,omitempty"`
+
+	// Don't strip leading and trailing newlines from the input.
+	// DontStripNL bool
+
+	// Strip all leading and trailing whitespace from the input
+	// StripAll bool
+
+	// Make sure that the input ends with a newline. This
+	// is required for some lexers that consume input linewise.
+	EnsureNL bool `xml:"ensure_nl,omitempty"`
+
+	// If given and greater than 0, expand tabs in the input.
+	// TabSize int
+
+	// Priority of lexer.
+	//
+	// If this is 0 it will be treated as a default of 1.
+	Priority float32 `xml:"priority,omitempty"`
+
+	// Analyse is a list of regexes to match against the input.
+	//
+	// If a match is found, the score is returned if single attribute is set to true,
+	// otherwise the sum of all the score of matching patterns will be
+	// used as the final score.
+	Analyse *AnalyseConfig `xml:"analyse,omitempty"`
+}
+
+// AnalyseConfig defines the list of regexes analysers.
+type AnalyseConfig struct {
+	Regexes []RegexConfig `xml:"regex,omitempty"`
+	// If true, the first matching score is returned.
+	First bool `xml:"first,attr"`
+}
+
+// RegexConfig defines a single regex pattern and its score in case of match.
+type RegexConfig struct {
+	Pattern string  `xml:"pattern,attr"`
+	Score   float32 `xml:"score,attr"`
+}
+
+// Token output to formatter.
+type Token struct {
+	Type  TokenType `json:"type"`
+	Value string    `json:"value"`
+}
+
+func (t *Token) String() string   { return t.Value }
+func (t *Token) GoString() string { return fmt.Sprintf("&Token{%s, %q}", t.Type, t.Value) }
+
+// Clone returns a clone of the Token.
+func (t *Token) Clone() Token {
+	return *t
+}
+
+// EOF is returned by lexers at the end of input.
+var EOF Token
+
+// TokeniseOptions contains options for tokenisers.
+type TokeniseOptions struct {
+	// State to start tokenisation in. Defaults to "root".
+	State string
+	// Nested tokenisation.
+	Nested bool
+
+	// If true, all EOLs are converted into LF
+	// by replacing CRLF and CR
+	EnsureLF bool
+}
+
+// A Lexer for tokenising source code.
+type Lexer interface {
+	// Config describing the features of the Lexer.
+	Config() *Config
+	// Tokenise returns an Iterator over tokens in text.
+	Tokenise(options *TokeniseOptions, text string) (Iterator, error)
+	// SetRegistry sets the registry this Lexer is associated with.
+	//
+	// The registry should be used by the Lexer if it needs to look up other
+	// lexers.
+	SetRegistry(registry *LexerRegistry) Lexer
+	// SetAnalyser sets a function the Lexer should use for scoring how
+	// likely a fragment of text is to match this lexer, between 0.0 and 1.0.
+	// A value of 1 indicates high confidence.
+	//
+	// Lexers may ignore this if they implement their own analysers.
+	SetAnalyser(analyser func(text string) float32) Lexer
+	// AnalyseText scores how likely a fragment of text is to match
+	// this lexer, between 0.0 and 1.0. A value of 1 indicates high confidence.
+	AnalyseText(text string) float32
+}
+
+// Lexers is a slice of lexers sortable by name.
+type Lexers []Lexer
+
+func (l Lexers) Len() int      { return len(l) }
+func (l Lexers) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+func (l Lexers) Less(i, j int) bool {
+	return strings.ToLower(l[i].Config().Name) < strings.ToLower(l[j].Config().Name)
+}
+
+// PrioritisedLexers is a slice of lexers sortable by priority.
+type PrioritisedLexers []Lexer
+
+func (l PrioritisedLexers) Len() int      { return len(l) }
+func (l PrioritisedLexers) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+func (l PrioritisedLexers) Less(i, j int) bool {
+	ip := l[i].Config().Priority
+	if ip == 0 {
+		ip = 1
+	}
+	jp := l[j].Config().Priority
+	if jp == 0 {
+		jp = 1
+	}
+	return ip > jp
+}
+
+// Analyser determines how appropriate this lexer is for the given text.
+type Analyser interface {
+	AnalyseText(text string) float32
+}

vendor/github.com/alecthomas/chroma/v2/lexers/README.md

@@ -0,0 +1,46 @@
+# Chroma lexers
+
+All lexers in Chroma should now be defined in XML unless they require custom code.
+
+## Lexer tests
+
+The tests in this directory feed a known input `testdata/<name>.actual` into the parser for `<name>` and check
+that its output matches `<name>.expected`.
+
+It is also possible to perform several tests on a same parser `<name>`, by placing know inputs `*.actual` into a
+directory `testdata/<name>/`.
+
+### Running the tests
+
+Run the tests as normal:
+```go
+go test ./lexers
+```
+
+### Update existing tests
+
+When you add a new test data file (`*.actual`), you need to regenerate all tests. That's how Chroma creates the `*.expected` test file based on the corresponding lexer.
+
+To regenerate all tests, type in your terminal:
+
+```go
+RECORD=true go test ./lexers
+```
+
+This first sets the `RECORD` environment variable to `true`. Then it runs `go test` on the `./lexers` directory of the Chroma project.
+
+(That environment variable tells Chroma it needs to output test data. After running `go test ./lexers` you can remove or reset that variable.)
+
+#### Windows users
+
+Windows users will find that the `RECORD=true go test ./lexers` command fails in both the standard command prompt terminal and in PowerShell.
+
+Instead we have to perform both steps separately:
+
+- Set the `RECORD` environment variable to `true`.
+	+ In the regular command prompt window, the `set` command sets an environment variable for the current session: `set RECORD=true`. See [this page](https://superuser.com/questions/212150/how-to-set-env-variable-in-windows-cmd-line) for more.
+	+ In PowerShell, you can use the `$env:RECORD = 'true'` command for that. See [this article](https://mcpmag.com/articles/2019/03/28/environment-variables-in-powershell.aspx) for more.
+	+ You can also make a persistent environment variable by hand in the Windows computer settings. See [this article](https://www.computerhope.com/issues/ch000549.htm) for how.
+- When the environment variable is set, run `go test ./lexers`.
+
+Chroma will now regenerate the test files and print its results to the console window.

vendor/github.com/alecthomas/chroma/v2/lexers/caddyfile.go

@@ -0,0 +1,215 @@
+package lexers
+
+import (
+	. "github.com/alecthomas/chroma/v2" // nolint
+)
+
+// caddyfileCommon are the rules common to both of the lexer variants
+func caddyfileCommonRules() Rules {
+	return Rules{
+		"site_block_common": {
+			// Import keyword
+			{`(import)(\s+)([^\s]+)`, ByGroups(Keyword, Text, NameVariableMagic), nil},
+			// Matcher definition
+			{`@[^\s]+(?=\s)`, NameDecorator, Push("matcher")},
+			// Matcher token stub for docs
+			{`\[\<matcher\>\]`, NameDecorator, Push("matcher")},
+			// These cannot have matchers but may have things that look like
+			// matchers in their arguments, so we just parse as a subdirective.
+			{`try_files`, Keyword, Push("subdirective")},
+			// These are special, they can nest more directives
+			{`handle_errors|handle|route|handle_path|not`, Keyword, Push("nested_directive")},
+			// Any other directive
+			{`[^\s#]+`, Keyword, Push("directive")},
+			Include("base"),
+		},
+		"matcher": {
+			{`\{`, Punctuation, Push("block")},
+			// Not can be one-liner
+			{`not`, Keyword, Push("deep_not_matcher")},
+			// Any other same-line matcher
+			{`[^\s#]+`, Keyword, Push("arguments")},
+			// Terminators
+			{`\n`, Text, Pop(1)},
+			{`\}`, Punctuation, Pop(1)},
+			Include("base"),
+		},
+		"block": {
+			{`\}`, Punctuation, Pop(2)},
+			// Not can be one-liner
+			{`not`, Keyword, Push("not_matcher")},
+			// Any other subdirective
+			{`[^\s#]+`, Keyword, Push("subdirective")},
+			Include("base"),
+		},
+		"nested_block": {
+			{`\}`, Punctuation, Pop(2)},
+			// Matcher definition
+			{`@[^\s]+(?=\s)`, NameDecorator, Push("matcher")},
+			// Something that starts with literally < is probably a docs stub
+			{`\<[^#]+\>`, Keyword, Push("nested_directive")},
+			// Any other directive
+			{`[^\s#]+`, Keyword, Push("nested_directive")},
+			Include("base"),
+		},
+		"not_matcher": {
+			{`\}`, Punctuation, Pop(2)},
+			{`\{(?=\s)`, Punctuation, Push("block")},
+			{`[^\s#]+`, Keyword, Push("arguments")},
+			{`\s+`, Text, nil},
+		},
+		"deep_not_matcher": {
+			{`\}`, Punctuation, Pop(2)},
+			{`\{(?=\s)`, Punctuation, Push("block")},
+			{`[^\s#]+`, Keyword, Push("deep_subdirective")},
+			{`\s+`, Text, nil},
+		},
+		"directive": {
+			{`\{(?=\s)`, Punctuation, Push("block")},
+			Include("matcher_token"),
+			Include("comments_pop_1"),
+			{`\n`, Text, Pop(1)},
+			Include("base"),
+		},
+		"nested_directive": {
+			{`\{(?=\s)`, Punctuation, Push("nested_block")},
+			Include("matcher_token"),
+			Include("comments_pop_1"),
+			{`\n`, Text, Pop(1)},
+			Include("base"),
+		},
+		"subdirective": {
+			{`\{(?=\s)`, Punctuation, Push("block")},
+			Include("comments_pop_1"),
+			{`\n`, Text, Pop(1)},
+			Include("base"),
+		},
+		"arguments": {
+			{`\{(?=\s)`, Punctuation, Push("block")},
+			Include("comments_pop_2"),
+			{`\\\n`, Text, nil}, // Skip escaped newlines
+			{`\n`, Text, Pop(2)},
+			Include("base"),
+		},
+		"deep_subdirective": {
+			{`\{(?=\s)`, Punctuation, Push("block")},
+			Include("comments_pop_3"),
+			{`\n`, Text, Pop(3)},
+			Include("base"),
+		},
+		"matcher_token": {
+			{`@[^\s]+`, NameDecorator, Push("arguments")},         // Named matcher
+			{`/[^\s]+`, NameDecorator, Push("arguments")},         // Path matcher
+			{`\*`, NameDecorator, Push("arguments")},              // Wildcard path matcher
+			{`\[\<matcher\>\]`, NameDecorator, Push("arguments")}, // Matcher token stub for docs
+		},
+		"comments": {
+			{`^#.*\n`, CommentSingle, nil},   // Comment at start of line
+			{`\s+#.*\n`, CommentSingle, nil}, // Comment preceded by whitespace
+		},
+		"comments_pop_1": {
+			{`^#.*\n`, CommentSingle, Pop(1)},   // Comment at start of line
+			{`\s+#.*\n`, CommentSingle, Pop(1)}, // Comment preceded by whitespace
+		},
+		"comments_pop_2": {
+			{`^#.*\n`, CommentSingle, Pop(2)},   // Comment at start of line
+			{`\s+#.*\n`, CommentSingle, Pop(2)}, // Comment preceded by whitespace
+		},
+		"comments_pop_3": {
+			{`^#.*\n`, CommentSingle, Pop(3)},   // Comment at start of line
+			{`\s+#.*\n`, CommentSingle, Pop(3)}, // Comment preceded by whitespace
+		},
+		"base": {
+			Include("comments"),
+			{`(on|off|first|last|before|after|internal|strip_prefix|strip_suffix|replace)\b`, NameConstant, nil},
+			{`(https?://)?([a-z0-9.-]+)(:)([0-9]+)`, ByGroups(Name, Name, Punctuation, LiteralNumberInteger), nil},
+			{`[a-z-]+/[a-z-+]+`, LiteralString, nil},
+			{`[0-9]+[km]?\b`, LiteralNumberInteger, nil},
+			{`\{[\w+.\$-]+\}`, LiteralStringEscape, nil}, // Placeholder
+			{`\[(?=[^#{}$]+\])`, Punctuation, nil},
+			{`\]|\|`, Punctuation, nil},
+			{`[^\s#{}$\]]+`, LiteralString, nil},
+			{`/[^\s#]*`, Name, nil},
+			{`\s+`, Text, nil},
+		},
+	}
+}
+
+// Caddyfile lexer.
+var Caddyfile = Register(MustNewLexer(
+	&Config{
+		Name:      "Caddyfile",
+		Aliases:   []string{"caddyfile", "caddy"},
+		Filenames: []string{"Caddyfile*"},
+		MimeTypes: []string{},
+	},
+	caddyfileRules,
+))
+
+func caddyfileRules() Rules {
+	return Rules{
+		"root": {
+			Include("comments"),
+			// Global options block
+			{`^\s*(\{)\s*$`, ByGroups(Punctuation), Push("globals")},
+			// Snippets
+			{`(\([^\s#]+\))(\s*)(\{)`, ByGroups(NameVariableAnonymous, Text, Punctuation), Push("snippet")},
+			// Site label
+			{`[^#{(\s,]+`, GenericHeading, Push("label")},
+			// Site label with placeholder
+			{`\{[\w+.\$-]+\}`, LiteralStringEscape, Push("label")},
+			{`\s+`, Text, nil},
+		},
+		"globals": {
+			{`\}`, Punctuation, Pop(1)},
+			{`[^\s#]+`, Keyword, Push("directive")},
+			Include("base"),
+		},
+		"snippet": {
+			{`\}`, Punctuation, Pop(1)},
+			// Matcher definition
+			{`@[^\s]+(?=\s)`, NameDecorator, Push("matcher")},
+			// Any directive
+			{`[^\s#]+`, Keyword, Push("directive")},
+			Include("base"),
+		},
+		"label": {
+			// Allow multiple labels, comma separated, newlines after
+			// a comma means another label is coming
+			{`,\s*\n?`, Text, nil},
+			{` `, Text, nil},
+			// Site label with placeholder
+			{`\{[\w+.\$-]+\}`, LiteralStringEscape, nil},
+			// Site label
+			{`[^#{(\s,]+`, GenericHeading, nil},
+			// Comment after non-block label (hack because comments end in \n)
+			{`#.*\n`, CommentSingle, Push("site_block")},
+			// Note: if \n, we'll never pop out of the site_block, it's valid
+			{`\{(?=\s)|\n`, Punctuation, Push("site_block")},
+		},
+		"site_block": {
+			{`\}`, Punctuation, Pop(2)},
+			Include("site_block_common"),
+		},
+	}.Merge(caddyfileCommonRules())
+}
+
+// Caddyfile directive-only lexer.
+var CaddyfileDirectives = Register(MustNewLexer(
+	&Config{
+		Name:      "Caddyfile Directives",
+		Aliases:   []string{"caddyfile-directives", "caddyfile-d", "caddy-d"},
+		Filenames: []string{},
+		MimeTypes: []string{},
+	},
+	caddyfileDirectivesRules,
+))
+
+func caddyfileDirectivesRules() Rules {
+	return Rules{
+		// Same as "site_block" in Caddyfile
+		"root": {
+			Include("site_block_common"),
+		},
+	}.Merge(caddyfileCommonRules())
+}

vendor/github.com/alecthomas/chroma/v2/lexers/cl.go

@@ -0,0 +1,243 @@
+package lexers
+
+import (
+	. "github.com/alecthomas/chroma/v2" // nolint
+)
+
+var (
+	clBuiltinFunctions = []string{
+		"<", "<=", "=", ">", ">=", "-", "/", "/=", "*", "+", "1-", "1+",
+		"abort", "abs", "acons", "acos", "acosh", "add-method", "adjoin",
+		"adjustable-array-p", "adjust-array", "allocate-instance",
+		"alpha-char-p", "alphanumericp", "append", "apply", "apropos",
+		"apropos-list", "aref", "arithmetic-error-operands",
+		"arithmetic-error-operation", "array-dimension", "array-dimensions",
+		"array-displacement", "array-element-type", "array-has-fill-pointer-p",
+		"array-in-bounds-p", "arrayp", "array-rank", "array-row-major-index",
+		"array-total-size", "ash", "asin", "asinh", "assoc", "assoc-if",
+		"assoc-if-not", "atan", "atanh", "atom", "bit", "bit-and", "bit-andc1",
+		"bit-andc2", "bit-eqv", "bit-ior", "bit-nand", "bit-nor", "bit-not",
+		"bit-orc1", "bit-orc2", "bit-vector-p", "bit-xor", "boole",
+		"both-case-p", "boundp", "break", "broadcast-stream-streams",
+		"butlast", "byte", "byte-position", "byte-size", "caaaar", "caaadr",
+		"caaar", "caadar", "caaddr", "caadr", "caar", "cadaar", "cadadr",
+		"cadar", "caddar", "cadddr", "caddr", "cadr", "call-next-method", "car",
+		"cdaaar", "cdaadr", "cdaar", "cdadar", "cdaddr", "cdadr", "cdar",
+		"cddaar", "cddadr", "cddar", "cdddar", "cddddr", "cdddr", "cddr", "cdr",
+		"ceiling", "cell-error-name", "cerror", "change-class", "char", "char<",
+		"char<=", "char=", "char>", "char>=", "char/=", "character",
+		"characterp", "char-code", "char-downcase", "char-equal",
+		"char-greaterp", "char-int", "char-lessp", "char-name",
+		"char-not-equal", "char-not-greaterp", "char-not-lessp", "char-upcase",
+		"cis", "class-name", "class-of", "clear-input", "clear-output",
+		"close", "clrhash", "code-char", "coerce", "compile",
+		"compiled-function-p", "compile-file", "compile-file-pathname",
+		"compiler-macro-function", "complement", "complex", "complexp",
+		"compute-applicable-methods", "compute-restarts", "concatenate",
+		"concatenated-stream-streams", "conjugate", "cons", "consp",
+		"constantly", "constantp", "continue", "copy-alist", "copy-list",
+		"copy-pprint-dispatch", "copy-readtable", "copy-seq", "copy-structure",
+		"copy-symbol", "copy-tree", "cos", "cosh", "count", "count-if",
+		"count-if-not", "decode-float", "decode-universal-time", "delete",
+		"delete-duplicates", "delete-file", "delete-if", "delete-if-not",
+		"delete-package", "denominator", "deposit-field", "describe",
+		"describe-object", "digit-char", "digit-char-p", "directory",
+		"directory-namestring", "disassemble", "documentation", "dpb",
+		"dribble", "echo-stream-input-stream", "echo-stream-output-stream",
+		"ed", "eighth", "elt", "encode-universal-time", "endp",
+		"enough-namestring", "ensure-directories-exist",
+		"ensure-generic-function", "eq", "eql", "equal", "equalp", "error",
+		"eval", "evenp", "every", "exp", "export", "expt", "fboundp",
+		"fceiling", "fdefinition", "ffloor", "fifth", "file-author",
+		"file-error-pathname", "file-length", "file-namestring",
+		"file-position", "file-string-length", "file-write-date",
+		"fill", "fill-pointer", "find", "find-all-symbols", "find-class",
+		"find-if", "find-if-not", "find-method", "find-package", "find-restart",
+		"find-symbol", "finish-output", "first", "float", "float-digits",
+		"floatp", "float-precision", "float-radix", "float-sign", "floor",
+		"fmakunbound", "force-output", "format", "fourth", "fresh-line",
+		"fround", "ftruncate", "funcall", "function-keywords",
+		"function-lambda-expression", "functionp", "gcd", "gensym", "gentemp",
+		"get", "get-decoded-time", "get-dispatch-macro-character", "getf",
+		"gethash", "get-internal-real-time", "get-internal-run-time",
+		"get-macro-character", "get-output-stream-string", "get-properties",
+		"get-setf-expansion", "get-universal-time", "graphic-char-p",
+		"hash-table-count", "hash-table-p", "hash-table-rehash-size",
+		"hash-table-rehash-threshold", "hash-table-size", "hash-table-test",
+		"host-namestring", "identity", "imagpart", "import",
+		"initialize-instance", "input-stream-p", "inspect",
+		"integer-decode-float", "integer-length", "integerp",
+		"interactive-stream-p", "intern", "intersection",
+		"invalid-method-error", "invoke-debugger", "invoke-restart",
+		"invoke-restart-interactively", "isqrt", "keywordp", "last", "lcm",
+		"ldb", "ldb-test", "ldiff", "length", "lisp-implementation-type",
+		"lisp-implementation-version", "list", "list*", "list-all-packages",
+		"listen", "list-length", "listp", "load",
+		"load-logical-pathname-translations", "log", "logand", "logandc1",
+		"logandc2", "logbitp", "logcount", "logeqv", "logical-pathname",
+		"logical-pathname-translations", "logior", "lognand", "lognor",
+		"lognot", "logorc1", "logorc2", "logtest", "logxor", "long-site-name",
+		"lower-case-p", "machine-instance", "machine-type", "machine-version",
+		"macroexpand", "macroexpand-1", "macro-function", "make-array",
+		"make-broadcast-stream", "make-concatenated-stream", "make-condition",
+		"make-dispatch-macro-character", "make-echo-stream", "make-hash-table",
+		"make-instance", "make-instances-obsolete", "make-list",
+		"make-load-form", "make-load-form-saving-slots", "make-package",
+		"make-pathname", "make-random-state", "make-sequence", "make-string",
+		"make-string-input-stream", "make-string-output-stream", "make-symbol",
+		"make-synonym-stream", "make-two-way-stream", "makunbound", "map",
+		"mapc", "mapcan", "mapcar", "mapcon", "maphash", "map-into", "mapl",
+		"maplist", "mask-field", "max", "member", "member-if", "member-if-not",
+		"merge", "merge-pathnames", "method-combination-error",
+		"method-qualifiers", "min", "minusp", "mismatch", "mod",
+		"muffle-warning", "name-char", "namestring", "nbutlast", "nconc",
+		"next-method-p", "nintersection", "ninth", "no-applicable-method",
+		"no-next-method", "not", "notany", "notevery", "nreconc", "nreverse",
+		"nset-difference", "nset-exclusive-or", "nstring-capitalize",
+		"nstring-downcase", "nstring-upcase", "nsublis", "nsubst", "nsubst-if",
+		"nsubst-if-not", "nsubstitute", "nsubstitute-if", "nsubstitute-if-not",
+		"nth", "nthcdr", "null", "numberp", "numerator", "nunion", "oddp",
+		"open", "open-stream-p", "output-stream-p", "package-error-package",
+		"package-name", "package-nicknames", "packagep",
+		"package-shadowing-symbols", "package-used-by-list", "package-use-list",
+		"pairlis", "parse-integer", "parse-namestring", "pathname",
+		"pathname-device", "pathname-directory", "pathname-host",
+		"pathname-match-p", "pathname-name", "pathnamep", "pathname-type",
+		"pathname-version", "peek-char", "phase", "plusp", "position",
+		"position-if", "position-if-not", "pprint", "pprint-dispatch",
+		"pprint-fill", "pprint-indent", "pprint-linear", "pprint-newline",
+		"pprint-tab", "pprint-tabular", "prin1", "prin1-to-string", "princ",
+		"princ-to-string", "print", "print-object", "probe-file", "proclaim",
+		"provide", "random", "random-state-p", "rassoc", "rassoc-if",
+		"rassoc-if-not", "rational", "rationalize", "rationalp", "read",
+		"read-byte", "read-char", "read-char-no-hang", "read-delimited-list",
+		"read-from-string", "read-line", "read-preserving-whitespace",
+		"read-sequence", "readtable-case", "readtablep", "realp", "realpart",
+		"reduce", "reinitialize-instance", "rem", "remhash", "remove",
+		"remove-duplicates", "remove-if", "remove-if-not", "remove-method",
+		"remprop", "rename-file", "rename-package", "replace", "require",
+		"rest", "restart-name", "revappend", "reverse", "room", "round",
+		"row-major-aref", "rplaca", "rplacd", "sbit", "scale-float", "schar",
+		"search", "second", "set", "set-difference",
+		"set-dispatch-macro-character", "set-exclusive-or",
+		"set-macro-character", "set-pprint-dispatch", "set-syntax-from-char",
+		"seventh", "shadow", "shadowing-import", "shared-initialize",
+		"short-site-name", "signal", "signum", "simple-bit-vector-p",
+		"simple-condition-format-arguments", "simple-condition-format-control",
+		"simple-string-p", "simple-vector-p", "sin", "sinh", "sixth", "sleep",
+		"slot-boundp", "slot-exists-p", "slot-makunbound", "slot-missing",
+		"slot-unbound", "slot-value", "software-type", "software-version",
+		"some", "sort", "special-operator-p", "sqrt", "stable-sort",
+		"standard-char-p", "store-value", "stream-element-type",
+		"stream-error-stream", "stream-external-format", "streamp", "string",
+		"string<", "string<=", "string=", "string>", "string>=", "string/=",
+		"string-capitalize", "string-downcase", "string-equal",
+		"string-greaterp", "string-left-trim", "string-lessp",
+		"string-not-equal", "string-not-greaterp", "string-not-lessp",
+		"stringp", "string-right-trim", "string-trim", "string-upcase",
+		"sublis", "subseq", "subsetp", "subst", "subst-if", "subst-if-not",
+		"substitute", "substitute-if", "substitute-if-not", "subtypep", "svref",
+		"sxhash", "symbol-function", "symbol-name", "symbolp", "symbol-package",
+		"symbol-plist", "symbol-value", "synonym-stream-symbol", "syntax:",
+		"tailp", "tan", "tanh", "tenth", "terpri", "third",
+		"translate-logical-pathname", "translate-pathname", "tree-equal",
+		"truename", "truncate", "two-way-stream-input-stream",
+		"two-way-stream-output-stream", "type-error-datum",
+		"type-error-expected-type", "type-of", "typep", "unbound-slot-instance",
+		"unexport", "unintern", "union", "unread-char", "unuse-package",
+		"update-instance-for-different-class",
+		"update-instance-for-redefined-class", "upgraded-array-element-type",
+		"upgraded-complex-part-type", "upper-case-p", "use-package",
+		"user-homedir-pathname", "use-value", "values", "values-list", "vector",
+		"vectorp", "vector-pop", "vector-push", "vector-push-extend", "warn",
+		"wild-pathname-p", "write", "write-byte", "write-char", "write-line",
+		"write-sequence", "write-string", "write-to-string", "yes-or-no-p",
+		"y-or-n-p", "zerop",
+	}
+
+	clSpecialForms = []string{
+		"block", "catch", "declare", "eval-when", "flet", "function", "go", "if",
+		"labels", "lambda", "let", "let*", "load-time-value", "locally", "macrolet",
+		"multiple-value-call", "multiple-value-prog1", "progn", "progv", "quote",
+		"return-from", "setq", "symbol-macrolet", "tagbody", "the", "throw",
+		"unwind-protect",
+	}
+
+	clMacros = []string{
+		"and", "assert", "call-method", "case", "ccase", "check-type", "cond",
+		"ctypecase", "decf", "declaim", "defclass", "defconstant", "defgeneric",
+		"define-compiler-macro", "define-condition", "define-method-combination",
+		"define-modify-macro", "define-setf-expander", "define-symbol-macro",
+		"defmacro", "defmethod", "defpackage", "defparameter", "defsetf",
+		"defstruct", "deftype", "defun", "defvar", "destructuring-bind", "do",
+		"do*", "do-all-symbols", "do-external-symbols", "dolist", "do-symbols",
+		"dotimes", "ecase", "etypecase", "formatter", "handler-bind",
+		"handler-case", "ignore-errors", "incf", "in-package", "lambda", "loop",
+		"loop-finish", "make-method", "multiple-value-bind", "multiple-value-list",
+		"multiple-value-setq", "nth-value", "or", "pop",
+		"pprint-exit-if-list-exhausted", "pprint-logical-block", "pprint-pop",
+		"print-unreadable-object", "prog", "prog*", "prog1", "prog2", "psetf",
+		"psetq", "push", "pushnew", "remf", "restart-bind", "restart-case",
+		"return", "rotatef", "setf", "shiftf", "step", "time", "trace", "typecase",
+		"unless", "untrace", "when", "with-accessors", "with-compilation-unit",
+		"with-condition-restarts", "with-hash-table-iterator",
+		"with-input-from-string", "with-open-file", "with-open-stream",
+		"with-output-to-string", "with-package-iterator", "with-simple-restart",
+		"with-slots", "with-standard-io-syntax",
+	}
+
+	clLambdaListKeywords = []string{
+		"&allow-other-keys", "&aux", "&body", "&environment", "&key", "&optional",
+		"&rest", "&whole",
+	}
+
+	clDeclarations = []string{
+		"dynamic-extent", "ignore", "optimize", "ftype", "inline", "special",
+		"ignorable", "notinline", "type",
+	}
+
+	clBuiltinTypes = []string{
+		"atom", "boolean", "base-char", "base-string", "bignum", "bit",
+		"compiled-function", "extended-char", "fixnum", "keyword", "nil",
+		"signed-byte", "short-float", "single-float", "double-float", "long-float",
+		"simple-array", "simple-base-string", "simple-bit-vector", "simple-string",
+		"simple-vector", "standard-char", "unsigned-byte",
+
+		// Condition Types
+		"arithmetic-error", "cell-error", "condition", "control-error",
+		"division-by-zero", "end-of-file", "error", "file-error",
+		"floating-point-inexact", "floating-point-overflow",
+		"floating-point-underflow", "floating-point-invalid-operation",
+		"parse-error", "package-error", "print-not-readable", "program-error",
+		"reader-error", "serious-condition", "simple-condition", "simple-error",
+		"simple-type-error", "simple-warning", "stream-error", "storage-condition",
+		"style-warning", "type-error", "unbound-variable", "unbound-slot",
+		"undefined-function", "warning",
+	}
+
+	clBuiltinClasses = []string{
+		"array", "broadcast-stream", "bit-vector", "built-in-class", "character",
+		"class", "complex", "concatenated-stream", "cons", "echo-stream",
+		"file-stream", "float", "function", "generic-function", "hash-table",
+		"integer", "list", "logical-pathname", "method-combination", "method",
+		"null", "number", "package", "pathname", "ratio", "rational", "readtable",
+		"real", "random-state", "restart", "sequence", "standard-class",
+		"standard-generic-function", "standard-method", "standard-object",
+		"string-stream", "stream", "string", "structure-class", "structure-object",
+		"symbol", "synonym-stream", "t", "two-way-stream", "vector",
+	}
+)
+
+// Common Lisp lexer.
+var CommonLisp = Register(TypeRemappingLexer(MustNewXMLLexer(
+	embedded,
+	"embedded/common_lisp.xml",
+), TypeMapping{
+	{NameVariable, NameFunction, clBuiltinFunctions},
+	{NameVariable, Keyword, clSpecialForms},
+	{NameVariable, NameBuiltin, clMacros},
+	{NameVariable, Keyword, clLambdaListKeywords},
+	{NameVariable, Keyword, clDeclarations},
+	{NameVariable, KeywordType, clBuiltinTypes},
+	{NameVariable, NameClass, clBuiltinClasses},
+}))

vendor/github.com/alecthomas/chroma/v2/lexers/dns.go

@@ -0,0 +1,17 @@
+package lexers
+
+import (
+	"regexp"
+)
+
+// TODO(moorereason): can this be factored away?
+var zoneAnalyserRe = regexp.MustCompile(`(?m)^@\s+IN\s+SOA\s+`)
+
+func init() { // nolint: gochecknoinits
+	Get("dns").SetAnalyser(func(text string) float32 {
+		if zoneAnalyserRe.FindString(text) != "" {
+			return 1.0
+		}
+		return 0.0
+	})
+}

vendor/github.com/alecthomas/chroma/v2/lexers/emacs.go

@@ -0,0 +1,533 @@
+package lexers
+
+import (
+	. "github.com/alecthomas/chroma/v2" // nolint
+)
+
+var (
+	emacsMacros = []string{
+		"atomic-change-group", "case", "block", "cl-block", "cl-callf", "cl-callf2",
+		"cl-case", "cl-decf", "cl-declaim", "cl-declare",
+		"cl-define-compiler-macro", "cl-defmacro", "cl-defstruct",
+		"cl-defsubst", "cl-deftype", "cl-defun", "cl-destructuring-bind",
+		"cl-do", "cl-do*", "cl-do-all-symbols", "cl-do-symbols", "cl-dolist",
+		"cl-dotimes", "cl-ecase", "cl-etypecase", "eval-when", "cl-eval-when", "cl-flet",
+		"cl-flet*", "cl-function", "cl-incf", "cl-labels", "cl-letf",
+		"cl-letf*", "cl-load-time-value", "cl-locally", "cl-loop",
+		"cl-macrolet", "cl-multiple-value-bind", "cl-multiple-value-setq",
+		"cl-progv", "cl-psetf", "cl-psetq", "cl-pushnew", "cl-remf",
+		"cl-return", "cl-return-from", "cl-rotatef", "cl-shiftf",
+		"cl-symbol-macrolet", "cl-tagbody", "cl-the", "cl-typecase",
+		"combine-after-change-calls", "condition-case-unless-debug", "decf",
+		"declaim", "declare", "declare-function", "def-edebug-spec",
+		"defadvice", "defclass", "defcustom", "defface", "defgeneric",
+		"defgroup", "define-advice", "define-alternatives",
+		"define-compiler-macro", "define-derived-mode", "define-generic-mode",
+		"define-global-minor-mode", "define-globalized-minor-mode",
+		"define-minor-mode", "define-modify-macro",
+		"define-obsolete-face-alias", "define-obsolete-function-alias",
+		"define-obsolete-variable-alias", "define-setf-expander",
+		"define-skeleton", "defmacro", "defmethod", "defsetf", "defstruct",
+		"defsubst", "deftheme", "deftype", "defun", "defvar-local",
+		"delay-mode-hooks", "destructuring-bind", "do", "do*",
+		"do-all-symbols", "do-symbols", "dolist", "dont-compile", "dotimes",
+		"dotimes-with-progress-reporter", "ecase", "ert-deftest", "etypecase",
+		"eval-and-compile", "eval-when-compile", "flet", "ignore-errors",
+		"incf", "labels", "lambda", "letrec", "lexical-let", "lexical-let*",
+		"loop", "multiple-value-bind", "multiple-value-setq", "noreturn",
+		"oref", "oref-default", "oset", "oset-default", "pcase",
+		"pcase-defmacro", "pcase-dolist", "pcase-exhaustive", "pcase-let",
+		"pcase-let*", "pop", "psetf", "psetq", "push", "pushnew", "remf",
+		"return", "rotatef", "rx", "save-match-data", "save-selected-window",
+		"save-window-excursion", "setf", "setq-local", "shiftf",
+		"track-mouse", "typecase", "unless", "use-package", "when",
+		"while-no-input", "with-case-table", "with-category-table",
+		"with-coding-priority", "with-current-buffer", "with-demoted-errors",
+		"with-eval-after-load", "with-file-modes", "with-local-quit",
+		"with-output-to-string", "with-output-to-temp-buffer",
+		"with-parsed-tramp-file-name", "with-selected-frame",
+		"with-selected-window", "with-silent-modifications", "with-slots",
+		"with-syntax-table", "with-temp-buffer", "with-temp-file",
+		"with-temp-message", "with-timeout", "with-tramp-connection-property",
+		"with-tramp-file-property", "with-tramp-progress-reporter",
+		"with-wrapper-hook", "load-time-value", "locally", "macrolet", "progv",
+		"return-from",
+	}
+
+	emacsSpecialForms = []string{
+		"and", "catch", "cond", "condition-case", "defconst", "defvar",
+		"function", "if", "interactive", "let", "let*", "or", "prog1",
+		"prog2", "progn", "quote", "save-current-buffer", "save-excursion",
+		"save-restriction", "setq", "setq-default", "subr-arity",
+		"unwind-protect", "while",
+	}
+
+	emacsBuiltinFunction = []string{
+		"%", "*", "+", "-", "/", "/=", "1+", "1-", "<", "<=", "=", ">", ">=",
+		"Snarf-documentation", "abort-recursive-edit", "abs",
+		"accept-process-output", "access-file", "accessible-keymaps", "acos",
+		"active-minibuffer-window", "add-face-text-property",
+		"add-name-to-file", "add-text-properties", "all-completions",
+		"append", "apply", "apropos-internal", "aref", "arrayp", "aset",
+		"ash", "asin", "assoc", "assoc-string", "assq", "atan", "atom",
+		"autoload", "autoload-do-load", "backtrace", "backtrace--locals",
+		"backtrace-debug", "backtrace-eval", "backtrace-frame",
+		"backward-char", "backward-prefix-chars", "barf-if-buffer-read-only",
+		"base64-decode-region", "base64-decode-string",
+		"base64-encode-region", "base64-encode-string", "beginning-of-line",
+		"bidi-find-overridden-directionality", "bidi-resolved-levels",
+		"bitmap-spec-p", "bobp", "bolp", "bool-vector",
+		"bool-vector-count-consecutive", "bool-vector-count-population",
+		"bool-vector-exclusive-or", "bool-vector-intersection",
+		"bool-vector-not", "bool-vector-p", "bool-vector-set-difference",
+		"bool-vector-subsetp", "bool-vector-union", "boundp",
+		"buffer-base-buffer", "buffer-chars-modified-tick",
+		"buffer-enable-undo", "buffer-file-name", "buffer-has-markers-at",
+		"buffer-list", "buffer-live-p", "buffer-local-value",
+		"buffer-local-variables", "buffer-modified-p", "buffer-modified-tick",
+		"buffer-name", "buffer-size", "buffer-string", "buffer-substring",
+		"buffer-substring-no-properties", "buffer-swap-text", "bufferp",
+		"bury-buffer-internal", "byte-code", "byte-code-function-p",
+		"byte-to-position", "byte-to-string", "byteorder",
+		"call-interactively", "call-last-kbd-macro", "call-process",
+		"call-process-region", "cancel-kbd-macro-events", "capitalize",
+		"capitalize-region", "capitalize-word", "car", "car-less-than-car",
+		"car-safe", "case-table-p", "category-docstring",
+		"category-set-mnemonics", "category-table", "category-table-p",
+		"ccl-execute", "ccl-execute-on-string", "ccl-program-p", "cdr",
+		"cdr-safe", "ceiling", "char-after", "char-before",
+		"char-category-set", "char-charset", "char-equal", "char-or-string-p",
+		"char-resolve-modifiers", "char-syntax", "char-table-extra-slot",
+		"char-table-p", "char-table-parent", "char-table-range",
+		"char-table-subtype", "char-to-string", "char-width", "characterp",
+		"charset-after", "charset-id-internal", "charset-plist",
+		"charset-priority-list", "charsetp", "check-coding-system",
+		"check-coding-systems-region", "clear-buffer-auto-save-failure",
+		"clear-charset-maps", "clear-face-cache", "clear-font-cache",
+		"clear-image-cache", "clear-string", "clear-this-command-keys",
+		"close-font", "clrhash", "coding-system-aliases",
+		"coding-system-base", "coding-system-eol-type", "coding-system-p",
+		"coding-system-plist", "coding-system-priority-list",
+		"coding-system-put", "color-distance", "color-gray-p",
+		"color-supported-p", "combine-after-change-execute",
+		"command-error-default-function", "command-remapping", "commandp",
+		"compare-buffer-substrings", "compare-strings",
+		"compare-window-configurations", "completing-read",
+		"compose-region-internal", "compose-string-internal",
+		"composition-get-gstring", "compute-motion", "concat", "cons",
+		"consp", "constrain-to-field", "continue-process",
+		"controlling-tty-p", "coordinates-in-window-p", "copy-alist",
+		"copy-category-table", "copy-file", "copy-hash-table", "copy-keymap",
+		"copy-marker", "copy-sequence", "copy-syntax-table", "copysign",
+		"cos", "current-active-maps", "current-bidi-paragraph-direction",
+		"current-buffer", "current-case-table", "current-column",
+		"current-global-map", "current-idle-time", "current-indentation",
+		"current-input-mode", "current-local-map", "current-message",
+		"current-minor-mode-maps", "current-time", "current-time-string",
+		"current-time-zone", "current-window-configuration",
+		"cygwin-convert-file-name-from-windows",
+		"cygwin-convert-file-name-to-windows", "daemon-initialized",
+		"daemonp", "dbus--init-bus", "dbus-get-unique-name",
+		"dbus-message-internal", "debug-timer-check", "declare-equiv-charset",
+		"decode-big5-char", "decode-char", "decode-coding-region",
+		"decode-coding-string", "decode-sjis-char", "decode-time",
+		"default-boundp", "default-file-modes", "default-printer-name",
+		"default-toplevel-value", "default-value", "define-category",
+		"define-charset-alias", "define-charset-internal",
+		"define-coding-system-alias", "define-coding-system-internal",
+		"define-fringe-bitmap", "define-hash-table-test", "define-key",
+		"define-prefix-command", "delete",
+		"delete-all-overlays", "delete-and-extract-region", "delete-char",
+		"delete-directory-internal", "delete-field", "delete-file",
+		"delete-frame", "delete-other-windows-internal", "delete-overlay",
+		"delete-process", "delete-region", "delete-terminal",
+		"delete-window-internal", "delq", "describe-buffer-bindings",
+		"describe-vector", "destroy-fringe-bitmap", "detect-coding-region",
+		"detect-coding-string", "ding", "directory-file-name",
+		"directory-files", "directory-files-and-attributes", "discard-input",
+		"display-supports-face-attributes-p", "do-auto-save", "documentation",
+		"documentation-property", "downcase", "downcase-region",
+		"downcase-word", "draw-string", "dump-colors", "dump-emacs",
+		"dump-face", "dump-frame-glyph-matrix", "dump-glyph-matrix",
+		"dump-glyph-row", "dump-redisplay-history", "dump-tool-bar-row",
+		"elt", "emacs-pid", "encode-big5-char", "encode-char",
+		"encode-coding-region", "encode-coding-string", "encode-sjis-char",
+		"encode-time", "end-kbd-macro", "end-of-line", "eobp", "eolp", "eq",
+		"eql", "equal", "equal-including-properties", "erase-buffer",
+		"error-message-string", "eval", "eval-buffer", "eval-region",
+		"event-convert-list", "execute-kbd-macro", "exit-recursive-edit",
+		"exp", "expand-file-name", "expt", "external-debugging-output",
+		"face-attribute-relative-p", "face-attributes-as-vector", "face-font",
+		"fboundp", "fceiling", "fetch-bytecode", "ffloor",
+		"field-beginning", "field-end", "field-string",
+		"field-string-no-properties", "file-accessible-directory-p",
+		"file-acl", "file-attributes", "file-attributes-lessp",
+		"file-directory-p", "file-executable-p", "file-exists-p",
+		"file-locked-p", "file-modes", "file-name-absolute-p",
+		"file-name-all-completions", "file-name-as-directory",
+		"file-name-completion", "file-name-directory",
+		"file-name-nondirectory", "file-newer-than-file-p", "file-readable-p",
+		"file-regular-p", "file-selinux-context", "file-symlink-p",
+		"file-system-info", "file-system-info", "file-writable-p",
+		"fillarray", "find-charset-region", "find-charset-string",
+		"find-coding-systems-region-internal", "find-composition-internal",
+		"find-file-name-handler", "find-font", "find-operation-coding-system",
+		"float", "float-time", "floatp", "floor", "fmakunbound",
+		"following-char", "font-at", "font-drive-otf", "font-face-attributes",
+		"font-family-list", "font-get", "font-get-glyphs",
+		"font-get-system-font", "font-get-system-normal-font", "font-info",
+		"font-match-p", "font-otf-alternates", "font-put",
+		"font-shape-gstring", "font-spec", "font-variation-glyphs",
+		"font-xlfd-name", "fontp", "fontset-font", "fontset-info",
+		"fontset-list", "fontset-list-all", "force-mode-line-update",
+		"force-window-update", "format", "format-mode-line",
+		"format-network-address", "format-time-string", "forward-char",
+		"forward-comment", "forward-line", "forward-word",
+		"frame-border-width", "frame-bottom-divider-width",
+		"frame-can-run-window-configuration-change-hook", "frame-char-height",
+		"frame-char-width", "frame-face-alist", "frame-first-window",
+		"frame-focus", "frame-font-cache", "frame-fringe-width", "frame-list",
+		"frame-live-p", "frame-or-buffer-changed-p", "frame-parameter",
+		"frame-parameters", "frame-pixel-height", "frame-pixel-width",
+		"frame-pointer-visible-p", "frame-right-divider-width",
+		"frame-root-window", "frame-scroll-bar-height",
+		"frame-scroll-bar-width", "frame-selected-window", "frame-terminal",
+		"frame-text-cols", "frame-text-height", "frame-text-lines",
+		"frame-text-width", "frame-total-cols", "frame-total-lines",
+		"frame-visible-p", "framep", "frexp", "fringe-bitmaps-at-pos",
+		"fround", "fset", "ftruncate", "funcall", "funcall-interactively",
+		"function-equal", "functionp", "gap-position", "gap-size",
+		"garbage-collect", "gc-status", "generate-new-buffer-name", "get",
+		"get-buffer", "get-buffer-create", "get-buffer-process",
+		"get-buffer-window", "get-byte", "get-char-property",
+		"get-char-property-and-overlay", "get-file-buffer", "get-file-char",
+		"get-internal-run-time", "get-load-suffixes", "get-pos-property",
+		"get-process", "get-screen-color", "get-text-property",
+		"get-unicode-property-internal", "get-unused-category",
+		"get-unused-iso-final-char", "getenv-internal", "gethash",
+		"gfile-add-watch", "gfile-rm-watch", "global-key-binding",
+		"gnutls-available-p", "gnutls-boot", "gnutls-bye", "gnutls-deinit",
+		"gnutls-error-fatalp", "gnutls-error-string", "gnutls-errorp",
+		"gnutls-get-initstage", "gnutls-peer-status",
+		"gnutls-peer-status-warning-describe", "goto-char", "gpm-mouse-start",
+		"gpm-mouse-stop", "group-gid", "group-real-gid",
+		"handle-save-session", "handle-switch-frame", "hash-table-count",
+		"hash-table-p", "hash-table-rehash-size",
+		"hash-table-rehash-threshold", "hash-table-size", "hash-table-test",
+		"hash-table-weakness", "iconify-frame", "identity", "image-flush",
+		"image-mask-p", "image-metadata", "image-size", "imagemagick-types",
+		"imagep", "indent-to", "indirect-function", "indirect-variable",
+		"init-image-library", "inotify-add-watch", "inotify-rm-watch",
+		"input-pending-p", "insert", "insert-and-inherit",
+		"insert-before-markers", "insert-before-markers-and-inherit",
+		"insert-buffer-substring", "insert-byte", "insert-char",
+		"insert-file-contents", "insert-startup-screen", "int86",
+		"integer-or-marker-p", "integerp", "interactive-form", "intern",
+		"intern-soft", "internal--track-mouse", "internal-char-font",
+		"internal-complete-buffer", "internal-copy-lisp-face",
+		"internal-default-process-filter",
+		"internal-default-process-sentinel", "internal-describe-syntax-value",
+		"internal-event-symbol-parse-modifiers",
+		"internal-face-x-get-resource", "internal-get-lisp-face-attribute",
+		"internal-lisp-face-attribute-values", "internal-lisp-face-empty-p",
+		"internal-lisp-face-equal-p", "internal-lisp-face-p",
+		"internal-make-lisp-face", "internal-make-var-non-special",
+		"internal-merge-in-global-face",
+		"internal-set-alternative-font-family-alist",
+		"internal-set-alternative-font-registry-alist",
+		"internal-set-font-selection-order",
+		"internal-set-lisp-face-attribute",
+		"internal-set-lisp-face-attribute-from-resource",
+		"internal-show-cursor", "internal-show-cursor-p", "interrupt-process",
+		"invisible-p", "invocation-directory", "invocation-name", "isnan",
+		"iso-charset", "key-binding", "key-description",
+		"keyboard-coding-system", "keymap-parent", "keymap-prompt", "keymapp",
+		"keywordp", "kill-all-local-variables", "kill-buffer", "kill-emacs",
+		"kill-local-variable", "kill-process", "last-nonminibuffer-frame",
+		"lax-plist-get", "lax-plist-put", "ldexp", "length",
+		"libxml-parse-html-region", "libxml-parse-xml-region",
+		"line-beginning-position", "line-end-position", "line-pixel-height",
+		"list", "list-fonts", "list-system-processes", "listp", "load",
+		"load-average", "local-key-binding", "local-variable-if-set-p",
+		"local-variable-p", "locale-info", "locate-file-internal",
+		"lock-buffer", "log", "logand", "logb", "logior", "lognot", "logxor",
+		"looking-at", "lookup-image", "lookup-image-map", "lookup-key",
+		"lower-frame", "lsh", "macroexpand", "make-bool-vector",
+		"make-byte-code", "make-category-set", "make-category-table",
+		"make-char", "make-char-table", "make-directory-internal",
+		"make-frame-invisible", "make-frame-visible", "make-hash-table",
+		"make-indirect-buffer", "make-keymap", "make-list",
+		"make-local-variable", "make-marker", "make-network-process",
+		"make-overlay", "make-serial-process", "make-sparse-keymap",
+		"make-string", "make-symbol", "make-symbolic-link", "make-temp-name",
+		"make-terminal-frame", "make-variable-buffer-local",
+		"make-variable-frame-local", "make-vector", "makunbound",
+		"map-char-table", "map-charset-chars", "map-keymap",
+		"map-keymap-internal", "mapatoms", "mapc", "mapcar", "mapconcat",
+		"maphash", "mark-marker", "marker-buffer", "marker-insertion-type",
+		"marker-position", "markerp", "match-beginning", "match-data",
+		"match-end", "matching-paren", "max", "max-char", "md5", "member",
+		"memory-info", "memory-limit", "memory-use-counts", "memq", "memql",
+		"menu-bar-menu-at-x-y", "menu-or-popup-active-p",
+		"menu-or-popup-active-p", "merge-face-attribute", "message",
+		"message-box", "message-or-box", "min",
+		"minibuffer-completion-contents", "minibuffer-contents",
+		"minibuffer-contents-no-properties", "minibuffer-depth",
+		"minibuffer-prompt", "minibuffer-prompt-end",
+		"minibuffer-selected-window", "minibuffer-window", "minibufferp",
+		"minor-mode-key-binding", "mod", "modify-category-entry",
+		"modify-frame-parameters", "modify-syntax-entry",
+		"mouse-pixel-position", "mouse-position", "move-overlay",
+		"move-point-visually", "move-to-column", "move-to-window-line",
+		"msdos-downcase-filename", "msdos-long-file-names", "msdos-memget",
+		"msdos-memput", "msdos-mouse-disable", "msdos-mouse-enable",
+		"msdos-mouse-init", "msdos-mouse-p", "msdos-remember-default-colors",
+		"msdos-set-keyboard", "msdos-set-mouse-buttons",
+		"multibyte-char-to-unibyte", "multibyte-string-p", "narrow-to-region",
+		"natnump", "nconc", "network-interface-info",
+		"network-interface-list", "new-fontset", "newline-cache-check",
+		"next-char-property-change", "next-frame", "next-overlay-change",
+		"next-property-change", "next-read-file-uses-dialog-p",
+		"next-single-char-property-change", "next-single-property-change",
+		"next-window", "nlistp", "nreverse", "nth", "nthcdr", "null",
+		"number-or-marker-p", "number-to-string", "numberp",
+		"open-dribble-file", "open-font", "open-termscript",
+		"optimize-char-table", "other-buffer", "other-window-for-scrolling",
+		"overlay-buffer", "overlay-end", "overlay-get", "overlay-lists",
+		"overlay-properties", "overlay-put", "overlay-recenter",
+		"overlay-start", "overlayp", "overlays-at", "overlays-in",
+		"parse-partial-sexp", "play-sound-internal", "plist-get",
+		"plist-member", "plist-put", "point", "point-marker", "point-max",
+		"point-max-marker", "point-min", "point-min-marker",
+		"pos-visible-in-window-p", "position-bytes", "posix-looking-at",
+		"posix-search-backward", "posix-search-forward", "posix-string-match",
+		"posn-at-point", "posn-at-x-y", "preceding-char",
+		"prefix-numeric-value", "previous-char-property-change",
+		"previous-frame", "previous-overlay-change",
+		"previous-property-change", "previous-single-char-property-change",
+		"previous-single-property-change", "previous-window", "prin1",
+		"prin1-to-string", "princ", "print", "process-attributes",
+		"process-buffer", "process-coding-system", "process-command",
+		"process-connection", "process-contact", "process-datagram-address",
+		"process-exit-status", "process-filter", "process-filter-multibyte-p",
+		"process-id", "process-inherit-coding-system-flag", "process-list",
+		"process-mark", "process-name", "process-plist",
+		"process-query-on-exit-flag", "process-running-child-p",
+		"process-send-eof", "process-send-region", "process-send-string",
+		"process-sentinel", "process-status", "process-tty-name",
+		"process-type", "processp", "profiler-cpu-log",
+		"profiler-cpu-running-p", "profiler-cpu-start", "profiler-cpu-stop",
+		"profiler-memory-log", "profiler-memory-running-p",
+		"profiler-memory-start", "profiler-memory-stop", "propertize",
+		"purecopy", "put", "put-text-property",
+		"put-unicode-property-internal", "puthash", "query-font",
+		"query-fontset", "quit-process", "raise-frame", "random", "rassoc",
+		"rassq", "re-search-backward", "re-search-forward", "read",
+		"read-buffer", "read-char", "read-char-exclusive",
+		"read-coding-system", "read-command", "read-event",
+		"read-from-minibuffer", "read-from-string", "read-function",
+		"read-key-sequence", "read-key-sequence-vector",
+		"read-no-blanks-input", "read-non-nil-coding-system", "read-string",
+		"read-variable", "recent-auto-save-p", "recent-doskeys",
+		"recent-keys", "recenter", "recursion-depth", "recursive-edit",
+		"redirect-debugging-output", "redirect-frame-focus", "redisplay",
+		"redraw-display", "redraw-frame", "regexp-quote", "region-beginning",
+		"region-end", "register-ccl-program", "register-code-conversion-map",
+		"remhash", "remove-list-of-text-properties", "remove-text-properties",
+		"rename-buffer", "rename-file", "replace-match",
+		"reset-this-command-lengths", "resize-mini-window-internal",
+		"restore-buffer-modified-p", "resume-tty", "reverse", "round",
+		"run-hook-with-args", "run-hook-with-args-until-failure",
+		"run-hook-with-args-until-success", "run-hook-wrapped", "run-hooks",
+		"run-window-configuration-change-hook", "run-window-scroll-functions",
+		"safe-length", "scan-lists", "scan-sexps", "scroll-down",
+		"scroll-left", "scroll-other-window", "scroll-right", "scroll-up",
+		"search-backward", "search-forward", "secure-hash", "select-frame",
+		"select-window", "selected-frame", "selected-window",
+		"self-insert-command", "send-string-to-terminal", "sequencep",
+		"serial-process-configure", "set", "set-buffer",
+		"set-buffer-auto-saved", "set-buffer-major-mode",
+		"set-buffer-modified-p", "set-buffer-multibyte", "set-case-table",
+		"set-category-table", "set-char-table-extra-slot",
+		"set-char-table-parent", "set-char-table-range", "set-charset-plist",
+		"set-charset-priority", "set-coding-system-priority",
+		"set-cursor-size", "set-default", "set-default-file-modes",
+		"set-default-toplevel-value", "set-file-acl", "set-file-modes",
+		"set-file-selinux-context", "set-file-times", "set-fontset-font",
+		"set-frame-height", "set-frame-position", "set-frame-selected-window",
+		"set-frame-size", "set-frame-width", "set-fringe-bitmap-face",
+		"set-input-interrupt-mode", "set-input-meta-mode", "set-input-mode",
+		"set-keyboard-coding-system-internal", "set-keymap-parent",
+		"set-marker", "set-marker-insertion-type", "set-match-data",
+		"set-message-beep", "set-minibuffer-window",
+		"set-mouse-pixel-position", "set-mouse-position",
+		"set-network-process-option", "set-output-flow-control",
+		"set-process-buffer", "set-process-coding-system",
+		"set-process-datagram-address", "set-process-filter",
+		"set-process-filter-multibyte",
+		"set-process-inherit-coding-system-flag", "set-process-plist",
+		"set-process-query-on-exit-flag", "set-process-sentinel",
+		"set-process-window-size", "set-quit-char",
+		"set-safe-terminal-coding-system-internal", "set-screen-color",
+		"set-standard-case-table", "set-syntax-table",
+		"set-terminal-coding-system-internal", "set-terminal-local-value",
+		"set-terminal-parameter", "set-text-properties", "set-time-zone-rule",
+		"set-visited-file-modtime", "set-window-buffer",
+		"set-window-combination-limit", "set-window-configuration",
+		"set-window-dedicated-p", "set-window-display-table",
+		"set-window-fringes", "set-window-hscroll", "set-window-margins",
+		"set-window-new-normal", "set-window-new-pixel",
+		"set-window-new-total", "set-window-next-buffers",
+		"set-window-parameter", "set-window-point", "set-window-prev-buffers",
+		"set-window-redisplay-end-trigger", "set-window-scroll-bars",
+		"set-window-start", "set-window-vscroll", "setcar", "setcdr",
+		"setplist", "show-face-resources", "signal", "signal-process", "sin",
+		"single-key-description", "skip-chars-backward", "skip-chars-forward",
+		"skip-syntax-backward", "skip-syntax-forward", "sleep-for", "sort",
+		"sort-charsets", "special-variable-p", "split-char",
+		"split-window-internal", "sqrt", "standard-case-table",
+		"standard-category-table", "standard-syntax-table", "start-kbd-macro",
+		"start-process", "stop-process", "store-kbd-macro-event", "string",
+		"string-as-multibyte", "string-as-unibyte", "string-bytes",
+		"string-collate-equalp", "string-collate-lessp", "string-equal",
+		"string-lessp", "string-make-multibyte", "string-make-unibyte",
+		"string-match", "string-to-char", "string-to-multibyte",
+		"string-to-number", "string-to-syntax", "string-to-unibyte",
+		"string-width", "stringp", "subr-name", "subrp",
+		"subst-char-in-region", "substitute-command-keys",
+		"substitute-in-file-name", "substring", "substring-no-properties",
+		"suspend-emacs", "suspend-tty", "suspicious-object", "sxhash",
+		"symbol-function", "symbol-name", "symbol-plist", "symbol-value",
+		"symbolp", "syntax-table", "syntax-table-p", "system-groups",
+		"system-move-file-to-trash", "system-name", "system-users", "tan",
+		"terminal-coding-system", "terminal-list", "terminal-live-p",
+		"terminal-local-value", "terminal-name", "terminal-parameter",
+		"terminal-parameters", "terpri", "test-completion",
+		"text-char-description", "text-properties-at", "text-property-any",
+		"text-property-not-all", "this-command-keys",
+		"this-command-keys-vector", "this-single-command-keys",
+		"this-single-command-raw-keys", "time-add", "time-less-p",
+		"time-subtract", "tool-bar-get-system-style", "tool-bar-height",
+		"tool-bar-pixel-width", "top-level", "trace-redisplay",
+		"trace-to-stderr", "translate-region-internal", "transpose-regions",
+		"truncate", "try-completion", "tty-display-color-cells",
+		"tty-display-color-p", "tty-no-underline",
+		"tty-suppress-bold-inverse-default-colors", "tty-top-frame",
+		"tty-type", "type-of", "undo-boundary", "unencodable-char-position",
+		"unhandled-file-name-directory", "unibyte-char-to-multibyte",
+		"unibyte-string", "unicode-property-table-internal", "unify-charset",
+		"unintern", "unix-sync", "unlock-buffer", "upcase", "upcase-initials",
+		"upcase-initials-region", "upcase-region", "upcase-word",
+		"use-global-map", "use-local-map", "user-full-name",
+		"user-login-name", "user-real-login-name", "user-real-uid",
+		"user-uid", "variable-binding-locus", "vconcat", "vector",
+		"vector-or-char-table-p", "vectorp", "verify-visited-file-modtime",
+		"vertical-motion", "visible-frame-list", "visited-file-modtime",
+		"w16-get-clipboard-data", "w16-selection-exists-p",
+		"w16-set-clipboard-data", "w32-battery-status",
+		"w32-default-color-map", "w32-define-rgb-color",
+		"w32-display-monitor-attributes-list", "w32-frame-menu-bar-size",
+		"w32-frame-rect", "w32-get-clipboard-data",
+		"w32-get-codepage-charset", "w32-get-console-codepage",
+		"w32-get-console-output-codepage", "w32-get-current-locale-id",
+		"w32-get-default-locale-id", "w32-get-keyboard-layout",
+		"w32-get-locale-info", "w32-get-valid-codepages",
+		"w32-get-valid-keyboard-layouts", "w32-get-valid-locale-ids",
+		"w32-has-winsock", "w32-long-file-name", "w32-reconstruct-hot-key",
+		"w32-register-hot-key", "w32-registered-hot-keys",
+		"w32-selection-exists-p", "w32-send-sys-command",
+		"w32-set-clipboard-data", "w32-set-console-codepage",
+		"w32-set-console-output-codepage", "w32-set-current-locale",
+		"w32-set-keyboard-layout", "w32-set-process-priority",
+		"w32-shell-execute", "w32-short-file-name", "w32-toggle-lock-key",
+		"w32-unload-winsock", "w32-unregister-hot-key", "w32-window-exists-p",
+		"w32notify-add-watch", "w32notify-rm-watch",
+		"waiting-for-user-input-p", "where-is-internal", "widen",
+		"widget-apply", "widget-get", "widget-put",
+		"window-absolute-pixel-edges", "window-at", "window-body-height",
+		"window-body-width", "window-bottom-divider-width", "window-buffer",
+		"window-combination-limit", "window-configuration-frame",
+		"window-configuration-p", "window-dedicated-p",
+		"window-display-table", "window-edges", "window-end", "window-frame",
+		"window-fringes", "window-header-line-height", "window-hscroll",
+		"window-inside-absolute-pixel-edges", "window-inside-edges",
+		"window-inside-pixel-edges", "window-left-child",
+		"window-left-column", "window-line-height", "window-list",
+		"window-list-1", "window-live-p", "window-margins",
+		"window-minibuffer-p", "window-mode-line-height", "window-new-normal",
+		"window-new-pixel", "window-new-total", "window-next-buffers",
+		"window-next-sibling", "window-normal-size", "window-old-point",
+		"window-parameter", "window-parameters", "window-parent",
+		"window-pixel-edges", "window-pixel-height", "window-pixel-left",
+		"window-pixel-top", "window-pixel-width", "window-point",
+		"window-prev-buffers", "window-prev-sibling",
+		"window-redisplay-end-trigger", "window-resize-apply",
+		"window-resize-apply-total", "window-right-divider-width",
+		"window-scroll-bar-height", "window-scroll-bar-width",
+		"window-scroll-bars", "window-start", "window-system",
+		"window-text-height", "window-text-pixel-size", "window-text-width",
+		"window-top-child", "window-top-line", "window-total-height",
+		"window-total-width", "window-use-time", "window-valid-p",
+		"window-vscroll", "windowp", "write-char", "write-region",
+		"x-backspace-delete-keys-p", "x-change-window-property",
+		"x-change-window-property", "x-close-connection",
+		"x-close-connection", "x-create-frame", "x-create-frame",
+		"x-delete-window-property", "x-delete-window-property",
+		"x-disown-selection-internal", "x-display-backing-store",
+		"x-display-backing-store", "x-display-color-cells",
+		"x-display-color-cells", "x-display-grayscale-p",
+		"x-display-grayscale-p", "x-display-list", "x-display-list",
+		"x-display-mm-height", "x-display-mm-height", "x-display-mm-width",
+		"x-display-mm-width", "x-display-monitor-attributes-list",
+		"x-display-pixel-height", "x-display-pixel-height",
+		"x-display-pixel-width", "x-display-pixel-width", "x-display-planes",
+		"x-display-planes", "x-display-save-under", "x-display-save-under",
+		"x-display-screens", "x-display-screens", "x-display-visual-class",
+		"x-display-visual-class", "x-family-fonts", "x-file-dialog",
+		"x-file-dialog", "x-file-dialog", "x-focus-frame", "x-frame-geometry",
+		"x-frame-geometry", "x-get-atom-name", "x-get-resource",
+		"x-get-selection-internal", "x-hide-tip", "x-hide-tip",
+		"x-list-fonts", "x-load-color-file", "x-menu-bar-open-internal",
+		"x-menu-bar-open-internal", "x-open-connection", "x-open-connection",
+		"x-own-selection-internal", "x-parse-geometry", "x-popup-dialog",
+		"x-popup-menu", "x-register-dnd-atom", "x-select-font",
+		"x-select-font", "x-selection-exists-p", "x-selection-owner-p",
+		"x-send-client-message", "x-server-max-request-size",
+		"x-server-max-request-size", "x-server-vendor", "x-server-vendor",
+		"x-server-version", "x-server-version", "x-show-tip", "x-show-tip",
+		"x-synchronize", "x-synchronize", "x-uses-old-gtk-dialog",
+		"x-window-property", "x-window-property", "x-wm-set-size-hint",
+		"xw-color-defined-p", "xw-color-defined-p", "xw-color-values",
+		"xw-color-values", "xw-display-color-p", "xw-display-color-p",
+		"yes-or-no-p", "zlib-available-p", "zlib-decompress-region",
+		"forward-point",
+	}
+
+	emacsBuiltinFunctionHighlighted = []string{
+		"defvaralias", "provide", "require",
+		"with-no-warnings", "define-widget", "with-electric-help",
+		"throw", "defalias", "featurep",
+	}
+
+	emacsLambdaListKeywords = []string{
+		"&allow-other-keys", "&aux", "&body", "&environment", "&key", "&optional",
+		"&rest", "&whole",
+	}
+
+	emacsErrorKeywords = []string{
+		"cl-assert", "cl-check-type", "error", "signal",
+		"user-error", "warn",
+	}
+)
+
+// EmacsLisp lexer.
+var EmacsLisp = Register(TypeRemappingLexer(MustNewXMLLexer(
+	embedded,
+	"embedded/emacslisp.xml",
+), TypeMapping{
+	{NameVariable, NameFunction, emacsBuiltinFunction},
+	{NameVariable, NameBuiltin, emacsSpecialForms},
+	{NameVariable, NameException, emacsErrorKeywords},
+	{NameVariable, NameBuiltin, append(emacsBuiltinFunctionHighlighted, emacsMacros...)},
+	{NameVariable, KeywordPseudo, emacsLambdaListKeywords},
+}))

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/abap.xml

@@ -0,0 +1,154 @@
+<lexer>
+  <config>
+    <name>ABAP</name>
+    <alias>abap</alias>
+    <filename>*.abap</filename>
+    <filename>*.ABAP</filename>
+    <mime_type>text/x-abap</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="common">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="^\*.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="\&#34;.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="##\w+">
+        <token type="CommentSpecial"/>
+      </rule>
+    </state>
+    <state name="variable-names">
+      <rule pattern="&lt;\S+&gt;">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\w[\w~]*(?:(\[\])|-&gt;\*)?">
+        <token type="NameVariable"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="common"/>
+      </rule>
+      <rule pattern="CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION)">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(CALL\s+(?:DIALOG|SCREEN|SUBSCREEN|SELECTION-SCREEN|TRANSACTION|TRANSFORMATION))\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(FORM|PERFORM)(\s+)(\w+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(PERFORM)(\s+)(\()(\w+)(\))">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="NameVariable"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(MODULE)(\s+)(\S+)(\s+)(INPUT|OUTPUT)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(METHOD)(\s+)([\w~]+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\s+)([\w\-]+)([=\-]&gt;)([\w\-~]+)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="NameVariable"/>
+          <token type="Operator"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(?&lt;=(=|-)&gt;)([\w\-~]+)(?=\()">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(TEXT)(-)(\d{3})">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Punctuation"/>
+          <token type="LiteralNumberInteger"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(TEXT)(-)(\w{3})">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Punctuation"/>
+          <token type="NameVariable"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(ADD-CORRESPONDING|AUTHORITY-CHECK|CLASS-DATA|CLASS-EVENTS|CLASS-METHODS|CLASS-POOL|DELETE-ADJACENT|DIVIDE-CORRESPONDING|EDITOR-CALL|ENHANCEMENT-POINT|ENHANCEMENT-SECTION|EXIT-COMMAND|FIELD-GROUPS|FIELD-SYMBOLS|FUNCTION-POOL|INTERFACE-POOL|INVERTED-DATE|LOAD-OF-PROGRAM|LOG-POINT|MESSAGE-ID|MOVE-CORRESPONDING|MULTIPLY-CORRESPONDING|NEW-LINE|NEW-PAGE|NEW-SECTION|NO-EXTENSION|OUTPUT-LENGTH|PRINT-CONTROL|SELECT-OPTIONS|START-OF-SELECTION|SUBTRACT-CORRESPONDING|SYNTAX-CHECK|SYSTEM-EXCEPTIONS|TYPE-POOL|TYPE-POOLS|NO-DISPLAY)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(?&lt;![-\&gt;])(CREATE\s+(PUBLIC|PRIVATE|DATA|OBJECT)|(PUBLIC|PRIVATE|PROTECTED)\s+SECTION|(TYPE|LIKE)\s+((LINE\s+OF|REF\s+TO|(SORTED|STANDARD|HASHED)\s+TABLE\s+OF))?|FROM\s+(DATABASE|MEMORY)|CALL\s+METHOD|(GROUP|ORDER) BY|HAVING|SEPARATED BY|GET\s+(BADI|BIT|CURSOR|DATASET|LOCALE|PARAMETER|PF-STATUS|(PROPERTY|REFERENCE)\s+OF|RUN\s+TIME|TIME\s+(STAMP)?)?|SET\s+(BIT|BLANK\s+LINES|COUNTRY|CURSOR|DATASET|EXTENDED\s+CHECK|HANDLER|HOLD\s+DATA|LANGUAGE|LEFT\s+SCROLL-BOUNDARY|LOCALE|MARGIN|PARAMETER|PF-STATUS|PROPERTY\s+OF|RUN\s+TIME\s+(ANALYZER|CLOCK\s+RESOLUTION)|SCREEN|TITLEBAR|UPADTE\s+TASK\s+LOCAL|USER-COMMAND)|CONVERT\s+((INVERTED-)?DATE|TIME|TIME\s+STAMP|TEXT)|(CLOSE|OPEN)\s+(DATASET|CURSOR)|(TO|FROM)\s+(DATA BUFFER|INTERNAL TABLE|MEMORY ID|DATABASE|SHARED\s+(MEMORY|BUFFER))|DESCRIBE\s+(DISTANCE\s+BETWEEN|FIELD|LIST|TABLE)|FREE\s(MEMORY|OBJECT)?|PROCESS\s+(BEFORE\s+OUTPUT|AFTER\s+INPUT|ON\s+(VALUE-REQUEST|HELP-REQUEST))|AT\s+(LINE-SELECTION|USER-COMMAND|END\s+OF|NEW)|AT\s+SELECTION-SCREEN(\s+(ON(\s+(BLOCK|(HELP|VALUE)-REQUEST\s+FOR|END\s+OF|RADIOBUTTON\s+GROUP))?|OUTPUT))?|SELECTION-SCREEN:?\s+((BEGIN|END)\s+OF\s+((TABBED\s+)?BLOCK|LINE|SCREEN)|COMMENT|FUNCTION\s+KEY|INCLUDE\s+BLOCKS|POSITION|PUSHBUTTON|SKIP|ULINE)|LEAVE\s+(LIST-PROCESSING|PROGRAM|SCREEN|TO LIST-PROCESSING|TO TRANSACTION)(ENDING|STARTING)\s+AT|FORMAT\s+(COLOR|INTENSIFIED|INVERSE|HOTSPOT|INPUT|FRAMES|RESET)|AS\s+(CHECKBOX|SUBSCREEN|WINDOW)|WITH\s+(((NON-)?UNIQUE)?\s+KEY|FRAME)|(BEGIN|END)\s+OF|DELETE(\s+ADJACENT\s+DUPLICATES\sFROM)?|COMPARING(\s+ALL\s+FIELDS)?|(INSERT|APPEND)(\s+INITIAL\s+LINE\s+(IN)?TO|\s+LINES\s+OF)?|IN\s+((BYTE|CHARACTER)\s+MODE|PROGRAM)|END-OF-(DEFINITION|PAGE|SELECTION)|WITH\s+FRAME(\s+TITLE)|(REPLACE|FIND)\s+((FIRST|ALL)\s+OCCURRENCES?\s+OF\s+)?(SUBSTRING|REGEX)?|MATCH\s+(LENGTH|COUNT|LINE|OFFSET)|(RESPECTING|IGNORING)\s+CASE|IN\s+UPDATE\s+TASK|(SOURCE|RESULT)\s+(XML)?|REFERENCE\s+INTO|AND\s+(MARK|RETURN)|CLIENT\s+SPECIFIED|CORRESPONDING\s+FIELDS\s+OF|IF\s+FOUND|FOR\s+EVENT|INHERITING\s+FROM|LEAVE\s+TO\s+SCREEN|LOOP\s+AT\s+(SCREEN)?|LOWER\s+CASE|MATCHCODE\s+OBJECT|MODIF\s+ID|MODIFY\s+SCREEN|NESTING\s+LEVEL|NO\s+INTERVALS|OF\s+STRUCTURE|RADIOBUTTON\s+GROUP|RANGE\s+OF|REF\s+TO|SUPPRESS DIALOG|TABLE\s+OF|UPPER\s+CASE|TRANSPORTING\s+NO\s+FIELDS|VALUE\s+CHECK|VISIBLE\s+LENGTH|HEADER\s+LINE|COMMON\s+PART)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=(\s|\.)))(ABBREVIATED|ABSTRACT|ADD|ALIASES|ALIGN|ALPHA|ASSERT|AS|ASSIGN(ING)?|AT(\s+FIRST)?|BACK|BLOCK|BREAK-POINT|CASE|CATCH|CHANGING|CHECK|CLASS|CLEAR|COLLECT|COLOR|COMMIT|CREATE|COMMUNICATION|COMPONENTS?|COMPUTE|CONCATENATE|CONDENSE|CONSTANTS|CONTEXTS|CONTINUE|CONTROLS|COUNTRY|CURRENCY|DATA|DATE|DECIMALS|DEFAULT|DEFINE|DEFINITION|DEFERRED|DEMAND|DETAIL|DIRECTORY|DIVIDE|DO|DUMMY|ELSE(IF)?|ENDAT|ENDCASE|ENDCATCH|ENDCLASS|ENDDO|ENDFORM|ENDFUNCTION|ENDIF|ENDINTERFACE|ENDLOOP|ENDMETHOD|ENDMODULE|ENDSELECT|ENDTRY|ENDWHILE|ENHANCEMENT|EVENTS|EXACT|EXCEPTIONS?|EXIT|EXPONENT|EXPORT|EXPORTING|EXTRACT|FETCH|FIELDS?|FOR|FORM|FORMAT|FREE|FROM|FUNCTION|HIDE|ID|IF|IMPORT|IMPLEMENTATION|IMPORTING|IN|INCLUDE|INCLUDING|INDEX|INFOTYPES|INITIALIZATION|INTERFACE|INTERFACES|INTO|LANGUAGE|LEAVE|LENGTH|LINES|LOAD|LOCAL|JOIN|KEY|NEXT|MAXIMUM|MESSAGE|METHOD[S]?|MINIMUM|MODULE|MODIFIER|MODIFY|MOVE|MULTIPLY|NODES|NUMBER|OBLIGATORY|OBJECT|OF|OFF|ON|OTHERS|OVERLAY|PACK|PAD|PARAMETERS|PERCENTAGE|POSITION|PROGRAM|PROVIDE|PUBLIC|PUT|PF\d\d|RAISE|RAISING|RANGES?|READ|RECEIVE|REDEFINITION|REFRESH|REJECT|REPORT|RESERVE|RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|REPLACE|SCROLL|SEARCH|SELECT|SHIFT|SIGN|SINGLE|SIZE|SKIP|SORT|SPLIT|STATICS|STOP|STYLE|SUBMATCHES|SUBMIT|SUBTRACT|SUM(?!\()|SUMMARY|SUMMING|SUPPLY|TABLE|TABLES|TIMESTAMP|TIMES?|TIMEZONE|TITLE|\??TO|TOP-OF-PAGE|TRANSFER|TRANSLATE|TRY|TYPES|ULINE|UNDER|UNPACK|UPDATE|USING|VALUE|VALUES|VIA|VARYING|VARY|WAIT|WHEN|WHERE|WIDTH|WHILE|WITH|WINDOW|WRITE|XSD|ZERO)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(abs|acos|asin|atan|boolc|boolx|bit_set|char_off|charlen|ceil|cmax|cmin|condense|contains|contains_any_of|contains_any_not_of|concat_lines_of|cos|cosh|count|count_any_of|count_any_not_of|dbmaxlen|distance|escape|exp|find|find_end|find_any_of|find_any_not_of|floor|frac|from_mixed|insert|lines|log|log10|match|matches|nmax|nmin|numofchar|repeat|replace|rescale|reverse|round|segment|shift_left|shift_right|sign|sin|sinh|sqrt|strlen|substring|substring_after|substring_from|substring_before|substring_to|tan|tanh|to_upper|to_lower|to_mixed|translate|trunc|xstrlen)(\()\b">
+        <bygroups>
+          <token type="NameBuiltin"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="&amp;[0-9]">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="(?&lt;=(\s|.))(AND|OR|EQ|NE|GT|LT|GE|LE|CO|CN|CA|NA|CS|NOT|NS|CP|NP|BYTE-CO|BYTE-CN|BYTE-CA|BYTE-NA|BYTE-CS|BYTE-NS|IS\s+(NOT\s+)?(INITIAL|ASSIGNED|REQUESTED|BOUND))\b">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule>
+        <include state="variable-names"/>
+      </rule>
+      <rule pattern="[?*&lt;&gt;=\-+&amp;]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="&#39;(&#39;&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="`([^`])*`">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="([|}])([^{}|]*?)([|{])">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="LiteralStringSingle"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[/;:()\[\],.]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(!)(\w+)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Name"/>
+        </bygroups>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/abnf.xml

@@ -0,0 +1,66 @@
+<lexer>
+  <config>
+    <name>ABNF</name>
+    <alias>abnf</alias>
+    <filename>*.abnf</filename>
+    <mime_type>text/x-abnf</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern=";.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="(%[si])?&#34;[^&#34;]*&#34;">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="%b[01]+\-[01]+\b">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="%b[01]+(\.[01]+)*\b">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="%d[0-9]+\-[0-9]+\b">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="%d[0-9]+(\.[0-9]+)*\b">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="%x[0-9a-fA-F]+\-[0-9a-fA-F]+\b">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="%x[0-9a-fA-F]+(\.[0-9a-fA-F]+)*\b">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="\b[0-9]+\*[0-9]+">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\b[0-9]+\*">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\b[0-9]+">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\*">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(HEXDIG|DQUOTE|DIGIT|VCHAR|OCTET|ALPHA|CHAR|CRLF|HTAB|LWSP|BIT|CTL|WSP|LF|SP|CR)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="[a-zA-Z][a-zA-Z0-9-]+\b">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="(=/|=|/)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[\[\]()]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/actionscript.xml

@@ -0,0 +1,68 @@
+<lexer>
+  <config>
+    <name>ActionScript</name>
+    <alias>as</alias>
+    <alias>actionscript</alias>
+    <filename>*.as</filename>
+    <mime_type>application/x-actionscript</mime_type>
+    <mime_type>text/x-actionscript</mime_type>
+    <mime_type>text/actionscript</mime_type>
+    <dot_all>true</dot_all>
+    <not_multiline>true</not_multiline>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/(\\\\|\\/|[^/\n])*/[gim]*">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[~^*!%&amp;&lt;&gt;|+=:;,/?\\-]+">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[{}\[\]();.]+">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(instanceof|arguments|continue|default|typeof|switch|return|catch|break|while|throw|each|this|with|else|case|var|new|for|try|if|do|in)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(implements|protected|namespace|interface|intrinsic|override|function|internal|private|package|extends|dynamic|import|native|return|public|static|class|const|super|final|get|set)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(true|false|null|NaN|Infinity|-Infinity|undefined|Void)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(IDynamicPropertyOutputIDynamicPropertyWriter|DisplacmentMapFilterMode|AccessibilityProperties|ContextMenuBuiltInItems|SharedObjectFlushStatus|DisplayObjectContainer|IllegalOperationError|DisplacmentMapFilter|InterpolationMethod|URLLoaderDataFormat|PrintJobOrientation|ActionScriptVersion|BitmapFilterQuality|GradientBevelFilter|GradientGlowFilter|DeleteObjectSample|StackOverflowError|SoundLoaderContext|ScriptTimeoutError|SecurityErrorEvent|InteractiveObject|StageDisplayState|FileReferenceList|TextFieldAutoSize|ApplicationDomain|BitmapDataChannel|ColorMatrixFilter|ExternalInterface|IMEConversionMode|DropShadowFilter|URLRequestHeader|ContextMenuEvent|ConvultionFilter|URLRequestMethod|BitmapFilterType|IEventDispatcher|ContextMenuItem|LocalConnection|InvalidSWFError|AsyncErrorEvent|MovieClipLoader|IBitmapDrawable|PrintJobOptions|EventDispatcher|NewObjectSample|HTTPStatusEvent|TextFormatAlign|IExternalizable|FullScreenEvent|DefinitionError|TextLineMetrics|NetStatusEvent|ColorTransform|ObjectEncoding|SecurityDomain|StageScaleMode|FocusDirection|ReferenceError|SoundTransform|KeyboardEvent|DisplayObject|PixelSnapping|LoaderContext|NetConnection|SecurityPanel|SecurityError|FileReference|AsBroadcaster|LineScaleMode|AntiAliasType|Accessibility|TextFieldType|URLVariabeles|ActivityEvent|ProgressEvent|TextColorType|StageQuality|TextSnapshot|Capabilities|BitmapFilter|SpreadMethod|GradientType|TextRenderer|SoundChannel|SharedObject|IOErrorEvent|SimpleButton|ContextMenu|InvokeEvent|CSMSettings|SyntaxError|StatusEvent|KeyLocation|IDataOutput|VerifyError|XMLDocument|XMLNodeType|MemoryError|GridFitType|BevelFilter|ErrorEvent|FrameLabel|GlowFilter|LoaderInfo|Microphone|MorphShape|BlurFilter|MouseEvent|FocusEvent|SoundMixer|FileFilter|TimerEvent|JointStyle|EventPhase|StageAlign|Dictionary|URLRequest|StyleSheet|SWFVersion|IDataInput|StaticText|RangeError|BitmapData|TextFormat|StackFrame|Namespace|SyncEvent|Rectangle|URLLoader|TypeError|Responder|NetStream|BlendMode|CapsStyle|DataEvent|ByteArray|MovieClip|Transform|TextField|Selection|AVM1Movie|XMLSocket|URLStream|FontStyle|EvalError|FontType|LoadVars|Graphics|Security|IMEEvent|URIError|Keyboard|Function|EOFError|PrintJob|IOError|XMLList|Boolean|ID3Info|XMLNode|Bitmap|String|RegExp|Sample|Object|Sprite|System|Endian|Matrix|Camera|Locale|Number|Loader|Socket|QName|Class|Timer|Sound|Shape|XMLUI|Mouse|Scene|Stage|Color|Point|Video|Error|Event|Proxy|Array|Date|uint|Math|Font|int|Key|IME|XML)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(decodeURIComponent|updateAfterEvent|clearInterval|setInterval|getVersion|parseFloat|fscommand|isXMLName|encodeURI|decodeURI|getTimer|unescape|isFinite|parseInt|getURL|escape|trace|isNaN|eval)\b">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="[$a-zA-Z_]\w*">
+        <token type="NameOther"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0x[0-9a-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/actionscript_3.xml

@@ -0,0 +1,163 @@
+<lexer>
+  <config>
+    <name>ActionScript 3</name>
+    <alias>as3</alias>
+    <alias>actionscript3</alias>
+    <filename>*.as</filename>
+    <mime_type>application/x-actionscript3</mime_type>
+    <mime_type>text/x-actionscript3</mime_type>
+    <mime_type>text/actionscript3</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="funcparams">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(\s*)(\.\.\.)?([$a-zA-Z_]\w*)(\s*)(:)(\s*)([$a-zA-Z_]\w*(?:\.&lt;\w+&gt;)?|\*)(\s*)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Name"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="defval"/>
+      </rule>
+      <rule pattern="\)">
+        <token type="Operator"/>
+        <push state="type"/>
+      </rule>
+    </state>
+    <state name="type">
+      <rule pattern="(\s*)(:)(\s*)([$a-zA-Z_]\w*(?:\.&lt;\w+&gt;)?|\*)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+        </bygroups>
+        <pop depth="2"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+        <pop depth="2"/>
+      </rule>
+      <rule>
+        <pop depth="2"/>
+      </rule>
+    </state>
+    <state name="defval">
+      <rule pattern="(=)(\s*)([^(),]+)(\s*)(,?)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <usingself state="root"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=",">
+        <token type="Operator"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(function\s+)([$a-zA-Z_]\w*)(\s*)(\()">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+        <push state="funcparams"/>
+      </rule>
+      <rule pattern="(var|const)(\s+)([$a-zA-Z_]\w*)(\s*)(:)(\s*)([$a-zA-Z_]\w*(?:\.&lt;\w+&gt;)?)">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="Text"/>
+          <token type="Name"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(import|package)(\s+)((?:[$a-zA-Z_]\w*|\.)+)(\s*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(new)(\s+)([$a-zA-Z_]\w*(?:\.&lt;\w+&gt;)?)(\s*)(\()">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/(\\\\|\\/|[^\n])*/[gisx]*">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="(\.)([$a-zA-Z_]\w*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameAttribute"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(case|default|for|each|in|while|do|break|return|continue|if|else|throw|try|catch|with|new|typeof|arguments|instanceof|this|switch|import|include|as|is)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(class|public|final|internal|native|override|private|protected|static|import|extends|implements|interface|intrinsic|return|super|dynamic|function|const|get|namespace|package|set)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(true|false|null|NaN|Infinity|-Infinity|undefined|void)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(decodeURI|decodeURIComponent|encodeURI|escape|eval|isFinite|isNaN|isXMLName|clearInterval|fscommand|getTimer|getURL|getVersion|isFinite|parseFloat|parseInt|setInterval|trace|updateAfterEvent|unescape)\b">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="[$a-zA-Z_]\w*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0x[0-9a-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="[~^*!%&amp;&lt;&gt;|+=:;,/?\\{}\[\]().-]+">
+        <token type="Operator"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ada.xml

@@ -0,0 +1,321 @@
+<lexer>
+  <config>
+    <name>Ada</name>
+    <alias>ada</alias>
+    <alias>ada95</alias>
+    <alias>ada2005</alias>
+    <filename>*.adb</filename>
+    <filename>*.ads</filename>
+    <filename>*.ada</filename>
+    <mime_type>text/x-ada</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="end">
+      <rule pattern="(if|case|record|loop|select)">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="&#34;[^&#34;]+&#34;|[\w.]+">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="array_def">
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(\w+)(\s+)(range)">
+        <bygroups>
+          <token type="KeywordType"/>
+          <token type="Text"/>
+          <token type="KeywordReserved"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="package_instantiation">
+      <rule pattern="(&#34;[^&#34;]+&#34;|\w+)(\s+)(=&gt;)">
+        <bygroups>
+          <token type="NameVariable"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[\w.\&#39;&#34;]">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="subprogram">
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="#pop" state="formal_part"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="is\b">
+        <token type="KeywordReserved"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="&#34;[^&#34;]+&#34;|\w+">
+        <token type="NameFunction"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="type_def">
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="formal_part"/>
+      </rule>
+      <rule pattern="with|and|use">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="array\b">
+        <token type="KeywordReserved"/>
+        <push state="#pop" state="array_def"/>
+      </rule>
+      <rule pattern="record\b">
+        <token type="KeywordReserved"/>
+        <push state="record_def"/>
+      </rule>
+      <rule pattern="(null record)(;)">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="import">
+      <rule pattern="[\w.]+">
+        <token type="NameNamespace"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="formal_part">
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\w+">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern=",|:[^=]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(in|not|null|out|access)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="package">
+      <rule pattern="body">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="is\s+new|renames">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="is">
+        <token type="KeywordReserved"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="package_instantiation"/>
+      </rule>
+      <rule pattern="([\w.]+)">
+        <token type="NameClass"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="attribute">
+      <rule pattern="(&#39;)(\w+)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameAttribute"/>
+        </bygroups>
+      </rule>
+    </state>
+    <state name="record_def">
+      <rule pattern="end record">
+        <token type="KeywordReserved"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="--.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="function|procedure|entry">
+        <token type="KeywordDeclaration"/>
+        <push state="subprogram"/>
+      </rule>
+      <rule pattern="(subtype|type)(\s+)(\w+)">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+        </bygroups>
+        <push state="type_def"/>
+      </rule>
+      <rule pattern="task|protected">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(subtype)(\s+)">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(end)(\s+)">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="end"/>
+      </rule>
+      <rule pattern="(pragma)(\s+)(\w+)">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(Short_Short_Integer|Short_Short_Float|Long_Long_Integer|Long_Long_Float|Wide_Character|Reference_Type|Short_Integer|Long_Integer|Wide_String|Short_Float|Controlled|Long_Float|Character|Generator|File_Type|File_Mode|Positive|Duration|Boolean|Natural|Integer|Address|Cursor|String|Count|Float|Byte)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(and(\s+then)?|in|mod|not|or(\s+else)|rem)\b">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="generic|private">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="package">
+        <token type="KeywordDeclaration"/>
+        <push state="package"/>
+      </rule>
+      <rule pattern="array\b">
+        <token type="KeywordReserved"/>
+        <push state="array_def"/>
+      </rule>
+      <rule pattern="(with|use)(\s+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="import"/>
+      </rule>
+      <rule pattern="(\w+)(\s*)(:)(\s*)(constant)">
+        <bygroups>
+          <token type="NameConstant"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="KeywordReserved"/>
+        </bygroups>
+      </rule>
+      <rule pattern="&lt;&lt;\w+&gt;&gt;">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="(\w+)(\s*)(:)(\s*)(declare|begin|loop|for|while)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="KeywordReserved"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(synchronized|overriding|terminate|interface|exception|protected|separate|constant|abstract|renames|reverse|subtype|aliased|declare|requeue|limited|return|tagged|access|record|select|accept|digits|others|pragma|entry|elsif|delta|delay|array|until|range|raise|while|begin|abort|else|loop|when|type|null|then|body|task|goto|case|exit|end|for|abs|xor|all|new|out|is|of|if|or|do|at)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="&#34;[^&#34;]*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule>
+        <include state="attribute"/>
+      </rule>
+      <rule>
+        <include state="numbers"/>
+      </rule>
+      <rule pattern="&#39;[^&#39;]&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="(\w+)(\s*|[(,])">
+        <bygroups>
+          <token type="Name"/>
+          <usingself state="root"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(&lt;&gt;|=&gt;|:=|[()|:;,.&#39;])">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[*&lt;&gt;+=/&amp;-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\n+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="numbers">
+      <rule pattern="[0-9_]+#[0-9a-f]+#">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="[0-9_]+\.[0-9_]*">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[0-9_]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/al.xml

@@ -0,0 +1,75 @@
+<lexer>
+  <config>
+    <name>AL</name>
+    <alias>al</alias>
+    <filename>*.al</filename>
+    <filename>*.dal</filename>
+    <mime_type>text/x-al</mime_type>
+    <case_insensitive>true</case_insensitive>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="(?s)\/\*.*?\\*\*\/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="(?s)//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="\&#34;([^\&#34;])*\&#34;">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="&#39;([^&#39;])*&#39;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\b(?i:(ARRAY|ASSERTERROR|BEGIN|BREAK|CASE|DO|DOWNTO|ELSE|END|EVENT|EXIT|FOR|FOREACH|FUNCTION|IF|IMPLEMENTS|IN|INDATASET|INTERFACE|INTERNAL|LOCAL|OF|PROCEDURE|PROGRAM|PROTECTED|REPEAT|RUNONCLIENT|SECURITYFILTERING|SUPPRESSDISPOSE|TEMPORARY|THEN|TO|TRIGGER|UNTIL|VAR|WHILE|WITH|WITHEVENTS))\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(?i:(AND|DIV|MOD|NOT|OR|XOR))\b">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="\b(?i:(AVERAGE|CONST|COUNT|EXIST|FIELD|FILTER|LOOKUP|MAX|MIN|ORDER|SORTING|SUM|TABLEDATA|UPPERLIMIT|WHERE|ASCENDING|DESCENDING))\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(?i:(CODEUNIT|PAGE|PAGEEXTENSION|PAGECUSTOMIZATION|DOTNET|ENUM|ENUMEXTENSION|VALUE|QUERY|REPORT|TABLE|TABLEEXTENSION|XMLPORT|PROFILE|CONTROLADDIN|REPORTEXTENSION|INTERFACE|PERMISSIONSET|PERMISSIONSETEXTENSION|ENTITLEMENT))\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(?i:(Action|Array|Automation|BigInteger|BigText|Blob|Boolean|Byte|Char|ClientType|Code|Codeunit|CompletionTriggerErrorLevel|ConnectionType|Database|DataClassification|DataScope|Date|DateFormula|DateTime|Decimal|DefaultLayout|Dialog|Dictionary|DotNet|DotNetAssembly|DotNetTypeDeclaration|Duration|Enum|ErrorInfo|ErrorType|ExecutionContext|ExecutionMode|FieldClass|FieldRef|FieldType|File|FilterPageBuilder|Guid|InStream|Integer|Joker|KeyRef|List|ModuleDependencyInfo|ModuleInfo|None|Notification|NotificationScope|ObjectType|Option|OutStream|Page|PageResult|Query|Record|RecordId|RecordRef|Report|ReportFormat|SecurityFilter|SecurityFiltering|Table|TableConnectionType|TableFilter|TestAction|TestField|TestFilterField|TestPage|TestPermissions|TestRequestPage|Text|TextBuilder|TextConst|TextEncoding|Time|TransactionModel|TransactionType|Variant|Verbosity|Version|XmlPort|HttpContent|HttpHeaders|HttpClient|HttpRequestMessage|HttpResponseMessage|JsonToken|JsonValue|JsonArray|JsonObject|View|Views|XmlAttribute|XmlAttributeCollection|XmlComment|XmlCData|XmlDeclaration|XmlDocument|XmlDocumentType|XmlElement|XmlNamespaceManager|XmlNameTable|XmlNode|XmlNodeList|XmlProcessingInstruction|XmlReadOptions|XmlText|XmlWriteOptions|WebServiceActionContext|WebServiceActionResultCode|SessionSettings))\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b([&lt;&gt;]=|&lt;&gt;|&lt;|&gt;)\b?">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\b(\-|\+|\/|\*)\b">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\s*(\:=|\+=|-=|\/=|\*=)\s*?">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\b(?i:(ADD|ADDFIRST|ADDLAST|ADDAFTER|ADDBEFORE|ACTION|ACTIONS|AREA|ASSEMBLY|CHARTPART|CUEGROUP|CUSTOMIZES|COLUMN|DATAITEM|DATASET|ELEMENTS|EXTENDS|FIELD|FIELDGROUP|FIELDATTRIBUTE|FIELDELEMENT|FIELDGROUPS|FIELDS|FILTER|FIXED|GRID|GROUP|MOVEAFTER|MOVEBEFORE|KEY|KEYS|LABEL|LABELS|LAYOUT|MODIFY|MOVEFIRST|MOVELAST|MOVEBEFORE|MOVEAFTER|PART|REPEATER|USERCONTROL|REQUESTPAGE|SCHEMA|SEPARATOR|SYSTEMPART|TABLEELEMENT|TEXTATTRIBUTE|TEXTELEMENT|TYPE))\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\s*[(\.\.)&amp;\|]\s*">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\b">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[;:,]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="#[ \t]*(if|else|elif|endif|define|undef|region|endregion|pragma)\b.*?\n">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="\w+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/angular2.xml

@@ -0,0 +1,108 @@
+<lexer>
+  <config>
+    <name>Angular2</name>
+    <alias>ng2</alias>
+  </config>
+  <rules>
+    <state name="attr">
+      <rule pattern="&#34;.*?&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="&#39;.*?&#39;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^\s&gt;]+">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="[^{([*#]+">
+        <token type="Other"/>
+      </rule>
+      <rule pattern="(\{\{)(\s*)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="ngExpression"/>
+      </rule>
+      <rule pattern="([([]+)([\w:.-]+)([\])]+)(\s*)(=)(\s*)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameAttribute"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="attr"/>
+      </rule>
+      <rule pattern="([([]+)([\w:.-]+)([\])]+)(\s*)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameAttribute"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="([*#])([\w:.-]+)(\s*)(=)(\s*)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameAttribute"/>
+          <token type="Punctuation"/>
+          <token type="Operator"/>
+        </bygroups>
+        <push state="attr"/>
+      </rule>
+      <rule pattern="([*#])([\w:.-]+)(\s*)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameAttribute"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+    </state>
+    <state name="ngExpression">
+      <rule pattern="\s+(\|\s+)?">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\}\}">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=":?(true|false)">
+        <token type="LiteralStringBoolean"/>
+      </rule>
+      <rule pattern=":?&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern=":?&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[a-zA-Z][\w-]*(\(.*\))?">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\.[\w-]+(\(.*\))?">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="(\?)(\s*)([^}\s]+)(\s*)(:)(\s*)([^}\s]+)(\s*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <token type="LiteralString"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <token type="LiteralString"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/antlr.xml

@@ -0,0 +1,317 @@
+<lexer>
+  <config>
+    <name>ANTLR</name>
+    <alias>antlr</alias>
+  </config>
+  <rules>
+    <state name="nested-arg-action">
+      <rule pattern="([^$\[\]\&#39;&#34;/]+|&#34;(\\\\|\\&#34;|[^&#34;])*&#34;|&#39;(\\\\|\\&#39;|[^&#39;])*&#39;|//.*$\n?|/\*(.|\n)*?\*/|/(?!\*)(\\\\|\\/|[^/])*/|/)+">
+        <token type="Other"/>
+      </rule>
+      <rule pattern="\[">
+        <token type="Punctuation"/>
+        <push/>
+      </rule>
+      <rule pattern="\]">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(\$[a-zA-Z]+)(\.?)(text|value)?">
+        <bygroups>
+          <token type="NameVariable"/>
+          <token type="Punctuation"/>
+          <token type="NameProperty"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\\\\|\\\]|\\\[|[^\[\]])+">
+        <token type="Other"/>
+      </rule>
+    </state>
+    <state name="exception">
+      <rule pattern="\n">
+        <token type="TextWhitespace"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\s">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule>
+        <include state="comments"/>
+      </rule>
+      <rule pattern="\[">
+        <token type="Punctuation"/>
+        <push state="nested-arg-action"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push state="action"/>
+      </rule>
+    </state>
+    <state name="whitespace">
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="comments"/>
+      </rule>
+      <rule pattern="(lexer|parser|tree)?(\s*)(grammar\b)(\s*)([A-Za-z]\w*)(;)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+          <token type="NameClass"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="options\b">
+        <token type="Keyword"/>
+        <push state="options"/>
+      </rule>
+      <rule pattern="tokens\b">
+        <token type="Keyword"/>
+        <push state="tokens"/>
+      </rule>
+      <rule pattern="(scope)(\s*)([A-Za-z]\w*)(\s*)(\{)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+          <token type="NameVariable"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="action"/>
+      </rule>
+      <rule pattern="(catch|finally)\b">
+        <token type="Keyword"/>
+        <push state="exception"/>
+      </rule>
+      <rule pattern="(@[A-Za-z]\w*)(\s*)(::)?(\s*)([A-Za-z]\w*)(\s*)(\{)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+          <token type="TextWhitespace"/>
+          <token type="NameLabel"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="action"/>
+      </rule>
+      <rule pattern="((?:protected|private|public|fragment)\b)?(\s*)([A-Za-z]\w*)(!)?">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+          <token type="NameLabel"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="rule-alts" state="rule-prelims"/>
+      </rule>
+    </state>
+    <state name="tokens">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="comments"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="([A-Z]\w*)(\s*)(=)?(\s*)(\&#39;(?:\\\\|\\\&#39;|[^\&#39;]*)\&#39;)?(\s*)(;)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+          <token type="TextWhitespace"/>
+          <token type="LiteralString"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="options">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="comments"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="([A-Za-z]\w*)(\s*)(=)(\s*)([A-Za-z]\w*|\&#39;(?:\\\\|\\\&#39;|[^\&#39;]*)\&#39;|[0-9]+|\*)(\s*)(;)">
+        <bygroups>
+          <token type="NameVariable"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+          <token type="TextWhitespace"/>
+          <token type="Text"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="rule-alts">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="comments"/>
+      </rule>
+      <rule pattern="options\b">
+        <token type="Keyword"/>
+        <push state="options"/>
+      </rule>
+      <rule pattern=":">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&lt;&lt;([^&gt;]|&gt;[^&gt;])&gt;&gt;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\$?[A-Z_]\w*">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="\$?[a-z_]\w*">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="(\+|\||-&gt;|=&gt;|=|\(|\)|\.\.|\.|\?|\*|\^|!|\#|~)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern=",">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\[">
+        <token type="Punctuation"/>
+        <push state="nested-arg-action"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push state="action"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="rule-prelims">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="comments"/>
+      </rule>
+      <rule pattern="returns\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\[">
+        <token type="Punctuation"/>
+        <push state="nested-arg-action"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push state="action"/>
+      </rule>
+      <rule pattern="(throws)(\s+)([A-Za-z]\w*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+          <token type="NameLabel"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(,)(\s*)([A-Za-z]\w*)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="TextWhitespace"/>
+          <token type="NameLabel"/>
+        </bygroups>
+      </rule>
+      <rule pattern="options\b">
+        <token type="Keyword"/>
+        <push state="options"/>
+      </rule>
+      <rule pattern="(scope)(\s+)(\{)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="action"/>
+      </rule>
+      <rule pattern="(scope)(\s+)([A-Za-z]\w*)(\s*)(;)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+          <token type="NameLabel"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(@[A-Za-z]\w*)(\s*)(\{)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="TextWhitespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="action"/>
+      </rule>
+      <rule pattern=":">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="action">
+      <rule pattern="([^${}\&#39;&#34;/\\]+|&#34;(\\\\|\\&#34;|[^&#34;])*&#34;|&#39;(\\\\|\\&#39;|[^&#39;])*&#39;|//.*$\n?|/\*(.|\n)*?\*/|/(?!\*)(\\\\|\\/|[^/])*/|\\(?!%)|/)+">
+        <token type="Other"/>
+      </rule>
+      <rule pattern="(\\)(%)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="Other"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\$[a-zA-Z]+)(\.?)(text|value)?">
+        <bygroups>
+          <token type="NameVariable"/>
+          <token type="Punctuation"/>
+          <token type="NameProperty"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="comments">
+      <rule pattern="//.*$">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="/\*(.|\n)*?\*/">
+        <token type="Comment"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/apacheconf.xml

@@ -0,0 +1,74 @@
+<lexer>
+  <config>
+    <name>ApacheConf</name>
+    <alias>apacheconf</alias>
+    <alias>aconf</alias>
+    <alias>apache</alias>
+    <filename>.htaccess</filename>
+    <filename>apache.conf</filename>
+    <filename>apache2.conf</filename>
+    <mime_type>text/x-apacheconf</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(#.*?)$">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="(&lt;[^\s&gt;]+)(?:(\s+)(.*?))?(&gt;)">
+        <bygroups>
+          <token type="NameTag"/>
+          <token type="Text"/>
+          <token type="LiteralString"/>
+          <token type="NameTag"/>
+        </bygroups>
+      </rule>
+      <rule pattern="([a-z]\w*)(\s+)">
+        <bygroups>
+          <token type="NameBuiltin"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="value"/>
+      </rule>
+      <rule pattern="\.+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="value">
+      <rule pattern="\\\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="$">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\d+\.\d+\.\d+\.\d+(?:/\d+)?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="/([a-z0-9][\w./-]+)">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="(on|off|none|any|all|double|email|dns|min|minimal|os|productonly|full|emerg|alert|crit|error|warn|notice|info|debug|registry|script|inetd|standalone|user|group)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="&#34;([^&#34;\\]*(?:\\.[^&#34;\\]*)*)&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="[^\s&#34;\\]+">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/apl.xml

@@ -0,0 +1,59 @@
+<lexer>
+  <config>
+    <name>APL</name>
+    <alias>apl</alias>
+    <filename>*.apl</filename>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="[⍝#].*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="\&#39;((\&#39;\&#39;)|[^\&#39;])*\&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="&#34;((&#34;&#34;)|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="[⋄◇()]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[\[\];]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="⎕[A-Za-zΔ∆⍙][A-Za-zΔ∆⍙_¯0-9]*">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="[A-Za-zΔ∆⍙_][A-Za-zΔ∆⍙_¯0-9]*">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="¯?(0[Xx][0-9A-Fa-f]+|[0-9]*\.?[0-9]+([Ee][+¯]?[0-9]+)?|¯|∞)([Jj]¯?(0[Xx][0-9A-Fa-f]+|[0-9]*\.?[0-9]+([Ee][+¯]?[0-9]+)?|¯|∞))?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[\.\\/⌿⍀¨⍣⍨⍠⍤∘⍥@⌺⌶⍢]">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="[+\-×÷⌈⌊∣|⍳?*⍟○!⌹&lt;≤=&gt;≥≠≡≢∊⍷∪∩~∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⌷⍋⍒⊤⊥⍕⍎⊣⊢⍁⍂≈⌸⍯↗⊆⍸]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="⍬">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="[⎕⍞]">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="[←→]">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="[⍺⍵⍶⍹∇:]">
+        <token type="NameBuiltinPseudo"/>
+      </rule>
+      <rule pattern="[{}]">
+        <token type="KeywordType"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/applescript.xml

@@ -0,0 +1,130 @@
+<lexer>
+  <config>
+    <name>AppleScript</name>
+    <alias>applescript</alias>
+    <filename>*.applescript</filename>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="¬\n">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="&#39;s\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(--|#).*?$">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="\(\*">
+        <token type="CommentMultiline"/>
+        <push state="comment"/>
+      </rule>
+      <rule pattern="[(){}!,.:]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(«)([^»]+)(»)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="NameBuiltin"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="NameBuiltin"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(-|\*|\+|&amp;|≠|&gt;=?|&lt;=?|=|≥|≤|/|÷|\^)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\b(and|or|is equal|equals|(is )?equal to|is not|isn&#39;t|isn&#39;t equal( to)?|is not equal( to)?|doesn&#39;t equal|does not equal|(is )?greater than|comes after|is not less than or equal( to)?|isn&#39;t less than or equal( to)?|(is )?less than|comes before|is not greater than or equal( to)?|isn&#39;t greater than or equal( to)?|(is  )?greater than or equal( to)?|is not less than|isn&#39;t less than|does not come before|doesn&#39;t come before|(is )?less than or equal( to)?|is not greater than|isn&#39;t greater than|does not come after|doesn&#39;t come after|starts? with|begins? with|ends? with|contains?|does not contain|doesn&#39;t contain|is in|is contained by|is not in|is not contained by|isn&#39;t contained by|div|mod|not|(a  )?(ref( to)?|reference to)|is|does)\b">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="^(\s*(?:on|end)\s+)(zoomed|write to file|will zoom|will show|will select tab view item|will resize( sub views)?|will resign active|will quit|will pop up|will open|will move|will miniaturize|will hide|will finish launching|will display outline cell|will display item cell|will display cell|will display browser cell|will dismiss|will close|will become active|was miniaturized|was hidden|update toolbar item|update parameters|update menu item|shown|should zoom|should selection change|should select tab view item|should select row|should select item|should select column|should quit( after last window closed)?|should open( untitled)?|should expand item|should end editing|should collapse item|should close|should begin editing|selection changing|selection changed|selected tab view item|scroll wheel|rows changed|right mouse up|right mouse dragged|right mouse down|resized( sub views)?|resigned main|resigned key|resigned active|read from file|prepare table drop|prepare table drag|prepare outline drop|prepare outline drag|prepare drop|plugin loaded|parameters updated|panel ended|opened|open untitled|number of rows|number of items|number of browser rows|moved|mouse up|mouse moved|mouse exited|mouse entered|mouse dragged|mouse down|miniaturized|load data representation|launched|keyboard up|keyboard down|items changed|item value changed|item value|item expandable|idle|exposed|end editing|drop|drag( (entered|exited|updated))?|double clicked|document nib name|dialog ended|deminiaturized|data representation|conclude drop|column resized|column moved|column clicked|closed|clicked toolbar item|clicked|choose menu item|child of item|changed|change item value|change cell value|cell value changed|cell value|bounds changed|begin editing|became main|became key|awake from nib|alert ended|activated|action|accept table drop|accept outline drop)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="^(\s*)(in|on|script|to)(\s+)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(as )(alias |application |boolean |class |constant |date |file |integer |list |number |POSIX file |real |record |reference |RGB color |script |text |unit types|(?:Unicode )?text|string)\b">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(AppleScript|current application|false|linefeed|missing value|pi|quote|result|return|space|tab|text item delimiters|true|version)\b">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="\b(ASCII (character|number)|activate|beep|choose URL|choose application|choose color|choose file( name)?|choose folder|choose from list|choose remote application|clipboard info|close( access)?|copy|count|current date|delay|delete|display (alert|dialog)|do shell script|duplicate|exists|get eof|get volume settings|info for|launch|list (disks|folder)|load script|log|make|mount volume|new|offset|open( (for access|location))?|path to|print|quit|random number|read|round|run( script)?|say|scripting components|set (eof|the clipboard to|volume)|store script|summarize|system attribute|system info|the clipboard|time to GMT|write|quoted form)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\b(considering|else|error|exit|from|if|ignoring|in|repeat|tell|then|times|to|try|until|using terms from|while|with|with timeout( of)?|with transaction|by|continue|end|its?|me|my|return|of|as)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(global|local|prop(erty)?|set|get)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(but|put|returning|the)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\b(attachment|attribute run|character|day|month|paragraph|word|year)s?\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\b(about|above|against|apart from|around|aside from|at|below|beneath|beside|between|for|given|instead of|on|onto|out of|over|since)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\b(accepts arrow key|action method|active|alignment|allowed identifiers|allows branch selection|allows column reordering|allows column resizing|allows column selection|allows customization|allows editing text attributes|allows empty selection|allows mixed state|allows multiple selection|allows reordering|allows undo|alpha( value)?|alternate image|alternate increment value|alternate title|animation delay|associated file name|associated object|auto completes|auto display|auto enables items|auto repeat|auto resizes( outline column)?|auto save expanded items|auto save name|auto save table columns|auto saves configuration|auto scroll|auto sizes all columns to fit|auto sizes cells|background color|bezel state|bezel style|bezeled|border rect|border type|bordered|bounds( rotation)?|box type|button returned|button type|can choose directories|can choose files|can draw|can hide|cell( (background color|size|type))?|characters|class|click count|clicked( data)? column|clicked data item|clicked( data)? row|closeable|collating|color( (mode|panel))|command key down|configuration|content(s| (size|view( margins)?))?|context|continuous|control key down|control size|control tint|control view|controller visible|coordinate system|copies( on scroll)?|corner view|current cell|current column|current( field)?  editor|current( menu)? item|current row|current tab view item|data source|default identifiers|delta (x|y|z)|destination window|directory|display mode|displayed cell|document( (edited|rect|view))?|double value|dragged column|dragged distance|dragged items|draws( cell)? background|draws grid|dynamically scrolls|echos bullets|edge|editable|edited( data)? column|edited data item|edited( data)? row|enabled|enclosing scroll view|ending page|error handling|event number|event type|excluded from windows menu|executable path|expanded|fax number|field editor|file kind|file name|file type|first responder|first visible column|flipped|floating|font( panel)?|formatter|frameworks path|frontmost|gave up|grid color|has data items|has horizontal ruler|has horizontal scroller|has parent data item|has resize indicator|has shadow|has sub menu|has vertical ruler|has vertical scroller|header cell|header view|hidden|hides when deactivated|highlights by|horizontal line scroll|horizontal page scroll|horizontal ruler view|horizontally resizable|icon image|id|identifier|ignores multiple clicks|image( (alignment|dims when disabled|frame style|scaling))?|imports graphics|increment value|indentation per level|indeterminate|index|integer value|intercell spacing|item height|key( (code|equivalent( modifier)?|window))?|knob thickness|label|last( visible)? column|leading offset|leaf|level|line scroll|loaded|localized sort|location|loop mode|main( (bunde|menu|window))?|marker follows cell|matrix mode|maximum( content)? size|maximum visible columns|menu( form representation)?|miniaturizable|miniaturized|minimized image|minimized title|minimum column width|minimum( content)? size|modal|modified|mouse down state|movie( (controller|file|rect))?|muted|name|needs display|next state|next text|number of tick marks|only tick mark values|opaque|open panel|option key down|outline table column|page scroll|pages across|pages down|palette label|pane splitter|parent data item|parent window|pasteboard|path( (names|separator))?|playing|plays every frame|plays selection only|position|preferred edge|preferred type|pressure|previous text|prompt|properties|prototype cell|pulls down|rate|released when closed|repeated|requested print time|required file type|resizable|resized column|resource path|returns records|reuses columns|rich text|roll over|row height|rulers visible|save panel|scripts path|scrollable|selectable( identifiers)?|selected cell|selected( data)? columns?|selected data items?|selected( data)? rows?|selected item identifier|selection by rect|send action on arrow key|sends action when done editing|separates columns|separator item|sequence number|services menu|shared frameworks path|shared support path|sheet|shift key down|shows alpha|shows state by|size( mode)?|smart insert delete enabled|sort case sensitivity|sort column|sort order|sort type|sorted( data rows)?|sound|source( mask)?|spell checking enabled|starting page|state|string value|sub menu|super menu|super view|tab key traverses cells|tab state|tab type|tab view|table view|tag|target( printer)?|text color|text container insert|text container origin|text returned|tick mark position|time stamp|title(d| (cell|font|height|position|rect))?|tool tip|toolbar|trailing offset|transparent|treat packages as directories|truncated labels|types|unmodified characters|update views|use sort indicator|user defaults|uses data source|uses ruler|uses threaded animation|uses title from previous column|value wraps|version|vertical( (line scroll|page scroll|ruler view))?|vertically resizable|view|visible( document rect)?|volume|width|window|windows menu|wraps|zoomable|zoomed)\b">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="\b(action cell|alert reply|application|box|browser( cell)?|bundle|button( cell)?|cell|clip view|color well|color-panel|combo box( item)?|control|data( (cell|column|item|row|source))?|default entry|dialog reply|document|drag info|drawer|event|font(-panel)?|formatter|image( (cell|view))?|matrix|menu( item)?|item|movie( view)?|open-panel|outline view|panel|pasteboard|plugin|popup button|progress indicator|responder|save-panel|scroll view|secure text field( cell)?|slider|sound|split view|stepper|tab view( item)?|table( (column|header cell|header view|view))|text( (field( cell)?|view))?|toolbar( item)?|user-defaults|view|window)s?\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\b(animate|append|call method|center|close drawer|close panel|display|display alert|display dialog|display panel|go|hide|highlight|increment|item for|load image|load movie|load nib|load panel|load sound|localized string|lock focus|log|open drawer|path for|pause|perform action|play|register|resume|scroll|select( all)?|show|size to fit|start|step back|step forward|stop|synchronize|unlock focus|update)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\b((in )?back of|(in )?front of|[0-9]+(st|nd|rd|th)|first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|after|back|before|behind|every|front|index|last|middle|some|that|through|thru|where|whose)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="\b([a-zA-Z]\w*)\b">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[-+]?\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+    </state>
+    <state name="comment">
+      <rule pattern="\(\*">
+        <token type="CommentMultiline"/>
+        <push/>
+      </rule>
+      <rule pattern="\*\)">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^*(]+">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="[*(]">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/arangodb_aql.xml

@@ -0,0 +1,174 @@
+<lexer>
+  <config>
+    <name>ArangoDB AQL</name>
+    <alias>aql</alias>
+    <filename>*.aql</filename>
+    <mime_type>text/x-aql</mime_type>
+    <case_insensitive>true</case_insensitive>
+    <dot_all>true</dot_all>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="comments-and-whitespace">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push state="multiline-comment"/>
+      </rule>
+    </state>
+    <state name="multiline-comment">
+      <rule pattern="[^*]+">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\*">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="double-quote">
+      <rule pattern="\\.">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="[^&#34;\\]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="single-quote">
+      <rule pattern="\\.">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="[^&#39;\\]+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="backtick">
+      <rule pattern="\\.">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[^`\\]+">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="`">
+        <token type="Name"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="forwardtick">
+      <rule pattern="\\.">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[^´\\]+">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="´">
+        <token type="Name"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="identifier">
+      <rule pattern="(?:\$?|_+)[a-z]+[_a-z0-9]*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="`">
+        <token type="Name"/>
+        <push state="backtick"/>
+      </rule>
+      <rule pattern="´">
+        <token type="Name"/>
+        <push state="forwardtick"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="comments-and-whitespace"/>
+      </rule>
+      <rule pattern="0b[01]+">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="0x[0-9a-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="(?:0|[1-9][0-9]*)(?![\.e])">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="(?:(?:0|[1-9][0-9]*)(?:\.[0-9]+)?|\.[0-9]+)(?:e[\-\+]?[0-9]+)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="@@(?:_+[a-z0-9]+[a-z0-9_]*|[a-z0-9][a-z0-9_]*)">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="@(?:_+[a-z0-9]+[a-z0-9_]*|[a-z0-9][a-z0-9_]*)">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="=~|!~|[=!&lt;&gt;]=?|[%?:/*+-]|\.\.|&amp;&amp;|\|\|">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[.,(){}\[\]]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[a-zA-Z0-9][a-zA-Z0-9_]*(?:::[a-zA-Z0-9_]+)+(?=\s*\()">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(WITH)(\s+)(COUNT)(\s+)(INTO)\b">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+          <token type="KeywordPseudo"/>
+          <token type="Text"/>
+          <token type="KeywordReserved"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(?:KEEP|PRUNE|SEARCH|TO)\b">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="OPTIONS(?=\s*\{)">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="(?:AGGREGATE|ALL|ALL_SHORTEST_PATHS|AND|ANY|ASC|AT LEAST|COLLECT|DESC|DISTINCT|FILTER|FOR|GRAPH|IN|INBOUND|INSERT|INTO|K_PATHS|K_SHORTEST_PATHS|LIKE|LIMIT|NONE|NOT|OR|OUTBOUND|REMOVE|REPLACE|RETURN|SHORTEST_PATH|SORT|UPDATE|UPSERT|WITH|WINDOW)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="LET\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(?:true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(?-i)(?:CURRENT|NEW|OLD)\b">
+        <token type="NameBuiltinPseudo"/>
+      </rule>
+      <rule pattern="(?:to_bool|to_number|to_string|to_array|to_list|is_null|is_bool|is_number|is_string|is_array|is_list|is_object|is_document|is_datestring|typename|json_stringify|json_parse|concat|concat_separator|char_length|lower|upper|substring|substring_bytes|left|right|trim|reverse|contains|log|log2|log10|exp|exp2|sin|cos|tan|asin|acos|atan|atan2|radians|degrees|pi|regex_test|regex_replace|like|floor|ceil|round|abs|rand|sqrt|pow|length|count|min|max|average|avg|sum|product|median|variance_population|variance_sample|variance|percentile|bit_and|bit_or|bit_xor|bit_negate|bit_test|bit_popcount|bit_shift_left|bit_shift_right|bit_construct|bit_deconstruct|bit_to_string|bit_from_string|first|last|unique|outersection|interleave|in_range|jaccard|matches|merge|merge_recursive|has|attributes|keys|values|unset|unset_recursive|keep|keep_recursive|near|within|within_rectangle|is_in_polygon|distance|fulltext|stddev_sample|stddev_population|stddev|slice|nth|position|contains_array|translate|zip|call|apply|push|append|pop|shift|unshift|remove_value|remove_values|remove_nth|replace_nth|date_now|date_timestamp|date_iso8601|date_dayofweek|date_year|date_month|date_day|date_hour|date_minute|date_second|date_millisecond|date_dayofyear|date_isoweek|date_isoweekyear|date_leapyear|date_quarter|date_days_in_month|date_trunc|date_round|date_add|date_subtract|date_diff|date_compare|date_format|date_utctolocal|date_localtoutc|date_timezone|date_timezones|fail|passthru|v8|sleep|schema_get|schema_validate|shard_id|version|noopt|noeval|not_null|first_list|first_document|parse_identifier|current_user|current_database|collection_count|pregel_result|collections|document|decode_rev|range|union|union_distinct|minus|intersection|flatten|is_same_collection|check_document|ltrim|rtrim|find_first|find_last|split|substitute|ipv4_to_number|ipv4_from_number|is_ipv4|md5|sha1|sha256|sha512|crc32|fnv64|hash|random_token|to_base64|to_hex|encode_uri_component|soundex|assert|warn|is_key|sorted|sorted_unique|count_distinct|count_unique|levenshtein_distance|levenshtein_match|regex_matches|regex_split|ngram_match|ngram_similarity|ngram_positional_similarity|uuid|tokens|exists|starts_with|phrase|min_match|bm25|tfidf|boost|analyzer|offset_info|value|cosine_similarity|decay_exp|decay_gauss|decay_linear|l1_distance|l2_distance|minhash|minhash_count|minhash_error|minhash_match|geo_point|geo_multipoint|geo_polygon|geo_multipolygon|geo_linestring|geo_multilinestring|geo_contains|geo_intersects|geo_equals|geo_distance|geo_area|geo_in_range)(?=\s*\()">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="double-quote"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <push state="single-quote"/>
+      </rule>
+      <rule pattern="#\d+\b">
+        <token type="NameLabel"/>
+      </rule>
+      <rule>
+        <include state="identifier"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/arduino.xml

@@ -0,0 +1,309 @@
+<lexer>
+  <config>
+    <name>Arduino</name>
+    <alias>arduino</alias>
+    <filename>*.ino</filename>
+    <mime_type>text/x-arduino</mime_type>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="whitespace">
+      <rule pattern="^#if\s+0">
+        <token type="CommentPreproc"/>
+        <push state="if0"/>
+      </rule>
+      <rule pattern="^#">
+        <token type="CommentPreproc"/>
+        <push state="macro"/>
+      </rule>
+      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#if\s+0)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <push state="if0"/>
+      </rule>
+      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <push state="macro"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//(\n|[\w\W]*?[^\\]\n)">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/(\\\n)?[*][\w\W]*?[*](\\\n)?/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/(\\\n)?[*][\w\W]*">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\([\\abfnrtv&#34;\&#39;]|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="[^\\&#34;\n]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="macro">
+      <rule pattern="(include)(\s*(?:/[*].*?[*]/\s*)?)([^\n]+)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="CommentPreprocFile"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[^/\n]+">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="/[*](.|\n)*?[*]/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="/">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="(?&lt;=\\)\n">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="statements">
+      <rule pattern="(reinterpret_cast|static_assert|dynamic_cast|thread_local|static_cast|const_cast|protected|constexpr|namespace|restrict|noexcept|override|operator|typename|template|explicit|decltype|nullptr|private|alignof|virtual|mutable|alignas|typeid|friend|throws|export|public|delete|final|using|throw|catch|this|try|new)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="char(16_t|32_t)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(class)\b">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="classname"/>
+      </rule>
+      <rule pattern="(R)(&#34;)([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(&#34;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralString"/>
+          <token type="LiteralStringDelimiter"/>
+          <token type="LiteralStringDelimiter"/>
+          <token type="LiteralString"/>
+          <token type="LiteralStringDelimiter"/>
+          <token type="LiteralString"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(u8|u|U)(&#34;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralString"/>
+        </bygroups>
+        <push state="string"/>
+      </rule>
+      <rule pattern="(L?)(&#34;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralString"/>
+        </bygroups>
+        <push state="string"/>
+      </rule>
+      <rule pattern="(L?)(&#39;)(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\&#39;\n])(&#39;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringChar"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="(\d+\.\d*|\.\d+|\d+[fF])[fF]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0x[0-9a-fA-F]+[LlUu]*">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="0[0-7]+[LlUu]*">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="\d+[LlUu]*">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="Error"/>
+      </rule>
+      <rule pattern="[~!%^&amp;*+=|?:&lt;&gt;/-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[()\[\],.]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(restricted|volatile|continue|register|default|typedef|struct|extern|switch|sizeof|static|return|union|while|const|break|goto|enum|else|case|auto|for|asm|if|do)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(_Bool|_Complex|_Imaginary|array|atomic_bool|atomic_char|atomic_int|atomic_llong|atomic_long|atomic_schar|atomic_short|atomic_uchar|atomic_uint|atomic_ullong|atomic_ulong|atomic_ushort|auto|bool|boolean|BooleanVariables|Byte|byte|Char|char|char16_t|char32_t|class|complex|Const|const|const_cast|delete|double|dynamic_cast|enum|explicit|extern|Float|float|friend|inline|Int|int|int16_t|int32_t|int64_t|int8_t|Long|long|new|NULL|null|operator|private|PROGMEM|protected|public|register|reinterpret_cast|short|signed|sizeof|Static|static|static_cast|String|struct|typedef|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|virtual|Void|void|Volatile|volatile|word)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(and|final|If|Loop|loop|not|or|override|setup|Setup|throw|try|xor)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(ANALOG_MESSAGE|BIN|CHANGE|DEC|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FALLING|FIRMATA_STRING|HALF_PI|HEX|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL1V1|INTERNAL2V56|INTERNAL2V56|LED_BUILTIN|LED_BUILTIN_RX|LED_BUILTIN_TX|LOW|LSBFIRST|MSBFIRST|OCT|OUTPUT|PI|REPORT_ANALOG|REPORT_DIGITAL|RISING|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET|TWO_PI)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(boolean|const|byte|word|string|String|array)\b">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="(Keyboard|KeyboardController|MouseController|SoftwareSerial|EthernetServer|EthernetClient|LiquidCrystal|RobotControl|GSMVoiceCall|EthernetUDP|EsploraTFT|HttpClient|RobotMotor|WiFiClient|GSMScanner|FileSystem|Scheduler|GSMServer|YunClient|YunServer|IPAddress|GSMClient|GSMModem|Keyboard|Ethernet|Console|GSMBand|Esplora|Stepper|Process|WiFiUDP|GSM_SMS|Mailbox|USBHost|Firmata|PImage|Client|Server|GSMPIN|FileIO|Bridge|Serial|EEPROM|Stream|Mouse|Audio|Servo|File|Task|GPRS|WiFi|Wire|TFT|GSM|SPI|SD)\b">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="(abs|Abs|accept|ACos|acos|acosf|addParameter|analogRead|AnalogRead|analogReadResolution|AnalogReadResolution|analogReference|AnalogReference|analogWrite|AnalogWrite|analogWriteResolution|AnalogWriteResolution|answerCall|asin|ASin|asinf|atan|ATan|atan2|ATan2|atan2f|atanf|attach|attached|attachGPRS|attachInterrupt|AttachInterrupt|autoscroll|available|availableForWrite|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|Bit|BitClear|bitClear|bitRead|BitRead|bitSet|BitSet|BitWrite|bitWrite|blink|blinkVersion|BSSID|buffer|byte|cbrt|cbrtf|Ceil|ceil|ceilf|changePIN|char|charAt|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compareTo|compassRead|concat|config|connect|connected|constrain|Constrain|copysign|copysignf|cos|Cos|cosf|cosh|coshf|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|degrees|Delay|delay|DelayMicroseconds|delayMicroseconds|detach|DetachInterrupt|detachInterrupt|DigitalPinToInterrupt|digitalPinToInterrupt|DigitalRead|digitalRead|DigitalWrite|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endsWith|endTransmission|endWrite|equals|equalsIgnoreCase|exists|exitValue|Exp|exp|expf|fabs|fabsf|fdim|fdimf|fill|find|findUntil|float|floor|Floor|floorf|flush|fma|fmaf|fmax|fmaxf|fmin|fminf|fmod|fmodf|gatewayIP|get|getAsynchronously|getBand|getButton|getBytes|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|HighByte|home|hypot|hypotf|image|indexOf|int|interrupts|IPAddress|IRread|isActionDone|isAlpha|isAlphaNumeric|isAscii|isControl|isDigit|isDirectory|isfinite|isGraph|isHexadecimalDigit|isinf|isListening|isLowerCase|isnan|isPIN|isPressed|isPrintable|isPunct|isSpace|isUpperCase|isValid|isWhitespace|keyboardRead|keyPressed|keyReleased|knobRead|lastIndexOf|ldexp|ldexpf|leftToRight|length|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|log|Log|log10|log10f|logf|long|lowByte|LowByte|lrint|lrintf|lround|lroundf|macAddress|maintain|map|Map|Max|max|messageAvailable|Micros|micros|millis|Millis|Min|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|NoInterrupts|noListenOnLocalhost|noStroke|noTone|NoTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|PinMode|pinMode|playFile|playMelody|point|pointTo|position|Pow|pow|powf|prepare|press|print|printFirmwareVersion|println|printVersion|process|processInput|PulseIn|pulseIn|pulseInLong|PulseInLong|put|radians|random|Random|randomSeed|RandomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|replace|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|round|roundf|RSSI|run|runAsynchronously|running|runShellCommand|runShellCommandAsynchronously|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|Serial_Available|Serial_Begin|Serial_End|Serial_Flush|Serial_Peek|Serial_Print|Serial_Println|Serial_Read|serialEvent|setBand|setBitOrder|setCharAt|setClockDivider|setCursor|setDataMode|setDNS|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|ShiftIn|shiftIn|ShiftOut|shiftOut|shutdown|signbit|sin|Sin|sinf|sinh|sinhf|size|sizeof|Sq|sq|Sqrt|sqrt|sqrtf|SSID|startLoop|startsWith|step|stop|stroke|subnetMask|substring|switchPIN|tan|Tan|tanf|tanh|tanhf|tempoWrite|text|toCharArray|toInt|toLowerCase|tone|Tone|toUpperCase|transfer|trim|trunc|truncf|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|WiFiServer|word|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRed|writeRGB|yield|Yield)\b">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(typename|__inline|restrict|_inline|thread|inline|naked)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(__m(128i|128d|128|64))\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="__(forceinline|identifier|unaligned|declspec|fastcall|finally|stdcall|wchar_t|assume|except|int32|cdecl|int16|leave|based|raise|int64|noop|int8|w64|try|asm)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(true|false|NULL)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="([a-zA-Z_]\w*)(\s*)(:)(?!:)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="Name"/>
+      </rule>
+    </state>
+    <state name="function">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="statements"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="if0">
+      <rule pattern="^\s*#if.*?(?&lt;!\\)\n">
+        <token type="CommentPreproc"/>
+        <push/>
+      </rule>
+      <rule pattern="^\s*#el(?:se|if).*\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="^\s*#endif.*?(?&lt;!\\)\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=".*?\n">
+        <token type="Comment"/>
+      </rule>
+    </state>
+    <state name="classname">
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\s*(?=&gt;)">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="statement">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="statements"/>
+      </rule>
+      <rule pattern="[{}]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <usingself state="root"/>
+          <usingself state="root"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="function"/>
+      </rule>
+      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <usingself state="root"/>
+          <usingself state="root"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <push state="statement"/>
+      </rule>
+      <rule pattern="__(multiple_inheritance|virtual_inheritance|single_inheritance|interface|uuidof|super|event)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="__(offload|blockingoffload|outer)\b">
+        <token type="KeywordPseudo"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/armasm.xml

@@ -0,0 +1,126 @@
+<lexer>
+  <config>
+    <name>ArmAsm</name>
+    <alias>armasm</alias>
+    <filename>*.s</filename>
+    <filename>*.S</filename>
+    <mime_type>text/x-armasm</mime_type>
+    <mime_type>text/x-asm</mime_type>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="root">
+      <rule>
+        <include state="commentsandwhitespace"/>
+      </rule>
+      <rule pattern="(\.\w+)([ \t]+\w+\s+?)?">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="NameLabel"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\w+)(:)(\s+\.\w+\s+)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="Punctuation"/>
+          <token type="KeywordNamespace"/>
+        </bygroups>
+        <push state="literal"/>
+      </rule>
+      <rule pattern="(\w+)(:)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="svc\s+\w+">
+        <token type="NameNamespace"/>
+      </rule>
+      <rule pattern="[a-zA-Z]+">
+        <token type="Text"/>
+        <push state="opcode"/>
+      </rule>
+    </state>
+    <state name="commentsandwhitespace">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="[@;].*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="literal">
+      <rule pattern="0b[01]+">
+        <token type="LiteralNumberBin"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="0x\w{1,8}">
+        <token type="LiteralNumberHex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="0\d+">
+        <token type="LiteralNumberOct"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\d+?\.\d+?">
+        <token type="LiteralNumberFloat"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumberInteger"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(&#34;)(.+)(&#34;)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="LiteralStringDouble"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(&#39;)(.{1}|\\.{1})(&#39;)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="LiteralStringChar"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="opcode">
+      <rule pattern="\n">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(@|;).*\n">
+        <token type="CommentSingle"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(\s+|,)">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="[rapcfxwbhsdqv]\d{1,2}">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="=0x\w+">
+        <bygroups>
+          <token type="Text"/>
+          <token type="NameLabel"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(=)(\w+)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="NameLabel"/>
+        </bygroups>
+      </rule>
+      <rule pattern="#">
+        <token type="Text"/>
+        <push state="literal"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/autohotkey.xml

@@ -0,0 +1,78 @@
+
+<lexer>
+  <config>
+    <name>AutoHotkey</name>
+    <alias>autohotkey</alias>
+    <alias>ahk</alias>
+    <filename>*.ahk</filename>
+    <filename>*.ahkl</filename>
+    <mime_type>text/x-autohotkey</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="^(\s*)(/\*)"><bygroups><token type="Text"/><token type="CommentMultiline"/></bygroups><push state="incomment"/></rule>
+      <rule pattern="^(\s*)(\()"><bygroups><token type="Text"/><token type="Generic"/></bygroups><push state="incontinuation"/></rule>
+      <rule pattern="\s+;.*?$"><token type="CommentSingle"/></rule>
+      <rule pattern="^;.*?$"><token type="CommentSingle"/></rule>
+      <rule pattern="[]{}(),;[]"><token type="Punctuation"/></rule>
+      <rule pattern="(in|is|and|or|not)\b"><token type="OperatorWord"/></rule>
+      <rule pattern="\%[a-zA-Z_#@$][\w#@$]*\%"><token type="NameVariable"/></rule>
+      <rule pattern="!=|==|:=|\.=|&lt;&lt;|&gt;&gt;|[-~+/*%=&lt;&gt;&amp;^|?:!.]"><token type="Operator"/></rule>
+      <rule><include state="commands"/></rule>
+      <rule><include state="labels"/></rule>
+      <rule><include state="builtInFunctions"/></rule>
+      <rule><include state="builtInVariables"/></rule>
+      <rule pattern="&quot;"><token type="LiteralString"/><combined state="stringescape" state="dqs"/></rule>
+      <rule><include state="numbers"/></rule>
+      <rule pattern="[a-zA-Z_#@$][\w#@$]*"><token type="Name"/></rule>
+      <rule pattern="\\|\&#x27;"><token type="Text"/></rule>
+      <rule pattern="\`([,%`abfnrtv\-+;])"><token type="LiteralStringEscape"/></rule>
+      <rule><include state="garbage"/></rule>
+    </state>
+    <state name="incomment">
+      <rule pattern="^\s*\*/"><token type="CommentMultiline"/><pop depth="1"/></rule>
+      <rule pattern="[^*]+"><token type="CommentMultiline"/></rule>
+      <rule pattern="\*"><token type="CommentMultiline"/></rule>
+    </state>
+    <state name="incontinuation">
+      <rule pattern="^\s*\)"><token type="Generic"/><pop depth="1"/></rule>
+      <rule pattern="[^)]"><token type="Generic"/></rule>
+      <rule pattern="[)]"><token type="Generic"/></rule>
+    </state>
+    <state name="commands">
+      <rule pattern="(?i)^(\s*)(global|local|static|#AllowSameLineComments|#ClipboardTimeout|#CommentFlag|#ErrorStdOut|#EscapeChar|#HotkeyInterval|#HotkeyModifierTimeout|#Hotstring|#IfWinActive|#IfWinExist|#IfWinNotActive|#IfWinNotExist|#IncludeAgain|#Include|#InstallKeybdHook|#InstallMouseHook|#KeyHistory|#LTrim|#MaxHotkeysPerInterval|#MaxMem|#MaxThreads|#MaxThreadsBuffer|#MaxThreadsPerHotkey|#NoEnv|#NoTrayIcon|#Persistent|#SingleInstance|#UseHook|#WinActivateForce|AutoTrim|BlockInput|Break|Click|ClipWait|Continue|Control|ControlClick|ControlFocus|ControlGetFocus|ControlGetPos|ControlGetText|ControlGet|ControlMove|ControlSend|ControlSendRaw|ControlSetText|CoordMode|Critical|DetectHiddenText|DetectHiddenWindows|Drive|DriveGet|DriveSpaceFree|Edit|Else|EnvAdd|EnvDiv|EnvGet|EnvMult|EnvSet|EnvSub|EnvUpdate|Exit|ExitApp|FileAppend|FileCopy|FileCopyDir|FileCreateDir|FileCreateShortcut|FileDelete|FileGetAttrib|FileGetShortcut|FileGetSize|FileGetTime|FileGetVersion|FileInstall|FileMove|FileMoveDir|FileRead|FileReadLine|FileRecycle|FileRecycleEmpty|FileRemoveDir|FileSelectFile|FileSelectFolder|FileSetAttrib|FileSetTime|FormatTime|GetKeyState|Gosub|Goto|GroupActivate|GroupAdd|GroupClose|GroupDeactivate|Gui|GuiControl|GuiControlGet|Hotkey|IfEqual|IfExist|IfGreaterOrEqual|IfGreater|IfInString|IfLess|IfLessOrEqual|IfMsgBox|IfNotEqual|IfNotExist|IfNotInString|IfWinActive|IfWinExist|IfWinNotActive|IfWinNotExist|If |ImageSearch|IniDelete|IniRead|IniWrite|InputBox|Input|KeyHistory|KeyWait|ListHotkeys|ListLines|ListVars|Loop|Menu|MouseClickDrag|MouseClick|MouseGetPos|MouseMove|MsgBox|OnExit|OutputDebug|Pause|PixelGetColor|PixelSearch|PostMessage|Process|Progress|Random|RegDelete|RegRead|RegWrite|Reload|Repeat|Return|RunAs|RunWait|Run|SendEvent|SendInput|SendMessage|SendMode|SendPlay|SendRaw|Send|SetBatchLines|SetCapslockState|SetControlDelay|SetDefaultMouseSpeed|SetEnv|SetFormat|SetKeyDelay|SetMouseDelay|SetNumlockState|SetScrollLockState|SetStoreCapslockMode|SetTimer|SetTitleMatchMode|SetWinDelay|SetWorkingDir|Shutdown|Sleep|Sort|SoundBeep|SoundGet|SoundGetWaveVolume|SoundPlay|SoundSet|SoundSetWaveVolume|SplashImage|SplashTextOff|SplashTextOn|SplitPath|StatusBarGetText|StatusBarWait|StringCaseSense|StringGetPos|StringLeft|StringLen|StringLower|StringMid|StringReplace|StringRight|StringSplit|StringTrimLeft|StringTrimRight|StringUpper|Suspend|SysGet|Thread|ToolTip|Transform|TrayTip|URLDownloadToFile|While|WinActivate|WinActivateBottom|WinClose|WinGetActiveStats|WinGetActiveTitle|WinGetClass|WinGetPos|WinGetText|WinGetTitle|WinGet|WinHide|WinKill|WinMaximize|WinMenuSelectItem|WinMinimizeAllUndo|WinMinimizeAll|WinMinimize|WinMove|WinRestore|WinSetTitle|WinSet|WinShow|WinWaitActive|WinWaitClose|WinWaitNotActive|WinWait)\b"><bygroups><token type="Text"/><token type="NameBuiltin"/></bygroups></rule>
+    </state>
+    <state name="builtInFunctions">
+      <rule pattern="(?i)(Abs|ACos|Asc|ASin|ATan|Ceil|Chr|Cos|DllCall|Exp|FileExist|Floor|GetKeyState|IL_Add|IL_Create|IL_Destroy|InStr|IsFunc|IsLabel|Ln|Log|LV_Add|LV_Delete|LV_DeleteCol|LV_GetCount|LV_GetNext|LV_GetText|LV_Insert|LV_InsertCol|LV_Modify|LV_ModifyCol|LV_SetImageList|Mod|NumGet|NumPut|OnMessage|RegExMatch|RegExReplace|RegisterCallback|Round|SB_SetIcon|SB_SetParts|SB_SetText|Sin|Sqrt|StrLen|SubStr|Tan|TV_Add|TV_Delete|TV_GetChild|TV_GetCount|TV_GetNext|TV_Get|TV_GetParent|TV_GetPrev|TV_GetSelection|TV_GetText|TV_Modify|VarSetCapacity|WinActive|WinExist|Object|ComObjActive|ComObjArray|ComObjEnwrap|ComObjUnwrap|ComObjParameter|ComObjType|ComObjConnect|ComObjCreate|ComObjGet|ComObjError|ComObjValue|Insert|MinIndex|MaxIndex|Remove|SetCapacity|GetCapacity|GetAddress|_NewEnum|FileOpen|Read|Write|ReadLine|WriteLine|ReadNumType|WriteNumType|RawRead|RawWrite|Seek|Tell|Close|Next|IsObject|StrPut|StrGet|Trim|LTrim|RTrim)\b"><token type="NameFunction"/></rule>
+    </state>
+    <state name="builtInVariables">
+      <rule pattern="(?i)(A_AhkPath|A_AhkVersion|A_AppData|A_AppDataCommon|A_AutoTrim|A_BatchLines|A_CaretX|A_CaretY|A_ComputerName|A_ControlDelay|A_Cursor|A_DDDD|A_DDD|A_DD|A_DefaultMouseSpeed|A_Desktop|A_DesktopCommon|A_DetectHiddenText|A_DetectHiddenWindows|A_EndChar|A_EventInfo|A_ExitReason|A_FormatFloat|A_FormatInteger|A_Gui|A_GuiEvent|A_GuiControl|A_GuiControlEvent|A_GuiHeight|A_GuiWidth|A_GuiX|A_GuiY|A_Hour|A_IconFile|A_IconHidden|A_IconNumber|A_IconTip|A_Index|A_IPAddress1|A_IPAddress2|A_IPAddress3|A_IPAddress4|A_ISAdmin|A_IsCompiled|A_IsCritical|A_IsPaused|A_IsSuspended|A_KeyDelay|A_Language|A_LastError|A_LineFile|A_LineNumber|A_LoopField|A_LoopFileAttrib|A_LoopFileDir|A_LoopFileExt|A_LoopFileFullPath|A_LoopFileLongPath|A_LoopFileName|A_LoopFileShortName|A_LoopFileShortPath|A_LoopFileSize|A_LoopFileSizeKB|A_LoopFileSizeMB|A_LoopFileTimeAccessed|A_LoopFileTimeCreated|A_LoopFileTimeModified|A_LoopReadLine|A_LoopRegKey|A_LoopRegName|A_LoopRegSubkey|A_LoopRegTimeModified|A_LoopRegType|A_MDAY|A_Min|A_MM|A_MMM|A_MMMM|A_Mon|A_MouseDelay|A_MSec|A_MyDocuments|A_Now|A_NowUTC|A_NumBatchLines|A_OSType|A_OSVersion|A_PriorHotkey|A_ProgramFiles|A_Programs|A_ProgramsCommon|A_ScreenHeight|A_ScreenWidth|A_ScriptDir|A_ScriptFullPath|A_ScriptName|A_Sec|A_Space|A_StartMenu|A_StartMenuCommon|A_Startup|A_StartupCommon|A_StringCaseSense|A_Tab|A_Temp|A_ThisFunc|A_ThisHotkey|A_ThisLabel|A_ThisMenu|A_ThisMenuItem|A_ThisMenuItemPos|A_TickCount|A_TimeIdle|A_TimeIdlePhysical|A_TimeSincePriorHotkey|A_TimeSinceThisHotkey|A_TitleMatchMode|A_TitleMatchModeSpeed|A_UserName|A_WDay|A_WinDelay|A_WinDir|A_WorkingDir|A_YDay|A_YEAR|A_YWeek|A_YYYY|Clipboard|ClipboardAll|ComSpec|ErrorLevel|ProgramFiles|True|False|A_IsUnicode|A_FileEncoding|A_OSVersion|A_PtrSize)\b"><token type="NameVariable"/></rule>
+    </state>
+    <state name="labels">
+      <rule pattern="(^\s*)([^:\s(&quot;]+?:{1,2})"><bygroups><token type="Text"/><token type="NameLabel"/></bygroups></rule>
+      <rule pattern="(^\s*)(::[^:\s]+?::)"><bygroups><token type="Text"/><token type="NameLabel"/></bygroups></rule>
+    </state>
+    <state name="numbers">
+      <rule pattern="(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?"><token type="LiteralNumberFloat"/></rule>
+      <rule pattern="\d+[eE][+-]?[0-9]+"><token type="LiteralNumberFloat"/></rule>
+      <rule pattern="0\d+"><token type="LiteralNumberOct"/></rule>
+      <rule pattern="0[xX][a-fA-F0-9]+"><token type="LiteralNumberHex"/></rule>
+      <rule pattern="\d+L"><token type="LiteralNumberIntegerLong"/></rule>
+      <rule pattern="\d+"><token type="LiteralNumberInteger"/></rule>
+    </state>
+    <state name="stringescape">
+      <rule pattern="\&quot;\&quot;|\`([,%`abfnrtv])"><token type="LiteralStringEscape"/></rule>
+    </state>
+    <state name="strings">
+      <rule pattern="[^&quot;\n]+"><token type="LiteralString"/></rule>
+    </state>
+    <state name="dqs">
+      <rule pattern="&quot;"><token type="LiteralString"/><pop depth="1"/></rule>
+      <rule><include state="strings"/></rule>
+    </state>
+    <state name="garbage">
+      <rule pattern="[^\S\n]"><token type="Text"/></rule>
+    </state>
+  </rules>
+</lexer>
+

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/awk.xml

@@ -0,0 +1,95 @@
+<lexer>
+  <config>
+    <name>Awk</name>
+    <alias>awk</alias>
+    <alias>gawk</alias>
+    <alias>mawk</alias>
+    <alias>nawk</alias>
+    <filename>*.awk</filename>
+    <mime_type>application/x-awk</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="^(?=\s|/)">
+        <token type="Text"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule>
+        <include state="commentsandwhitespace"/>
+      </rule>
+      <rule pattern="\+\+|--|\|\||&amp;&amp;|in\b|\$|!?~|\|&amp;|(\*\*|[-&lt;&gt;+*%\^/!=|])=?">
+        <token type="Operator"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="[{(\[;,]">
+        <token type="Punctuation"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="[})\].]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(break|continue|do|while|exit|for|if|else|return|switch|case|default)\b">
+        <token type="Keyword"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="function\b">
+        <token type="KeywordDeclaration"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="(atan2|cos|exp|int|log|rand|sin|sqrt|srand|gensub|gsub|index|length|match|split|patsplit|sprintf|sub|substr|tolower|toupper|close|fflush|getline|next(file)|print|printf|strftime|systime|mktime|delete|system|strtonum|and|compl|lshift|or|rshift|asorti?|isarray|bindtextdomain|dcn?gettext|@(include|load|namespace))\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(ARGC|ARGIND|ARGV|BEGIN(FILE)?|BINMODE|CONVFMT|ENVIRON|END(FILE)?|ERRNO|FIELDWIDTHS|FILENAME|FNR|FPAT|FS|IGNORECASE|LINT|NF|NR|OFMT|OFS|ORS|PROCINFO|RLENGTH|RS|RSTART|RT|SUBSEP|TEXTDOMAIN)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="[@$a-zA-Z_]\w*">
+        <token type="NameOther"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0x[0-9a-fA-F]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+    <state name="commentsandwhitespace">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="#.*$">
+        <token type="CommentSingle"/>
+      </rule>
+    </state>
+    <state name="slashstartsregex">
+      <rule>
+        <include state="commentsandwhitespace"/>
+      </rule>
+      <rule pattern="/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/\B">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?=/)">
+        <token type="Text"/>
+        <push state="#pop" state="badregex"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="badregex">
+      <rule pattern="\n">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ballerina.xml

@@ -0,0 +1,97 @@
+<lexer>
+  <config>
+    <name>Ballerina</name>
+    <alias>ballerina</alias>
+    <filename>*.bal</filename>
+    <mime_type>text/x-ballerina</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="(break|catch|continue|done|else|finally|foreach|forever|fork|if|lock|match|return|throw|transaction|try|while)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="((?:(?:[^\W\d]|\$)[\w.\[\]$&lt;&gt;]*\s+)+?)((?:[^\W\d]|\$)[\w$]*)(\s*)(\()">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="@[^\W\d][\w.]*">
+        <token type="NameDecorator"/>
+      </rule>
+      <rule pattern="(annotation|bind|but|endpoint|error|function|object|private|public|returns|service|type|var|with|worker)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(boolean|byte|decimal|float|int|json|map|nil|record|string|table|xml)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(import)(\s+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="import"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#39;\\.&#39;|&#39;[^\\]&#39;|&#39;\\u[0-9a-fA-F]{4}&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="(\.)((?:[^\W\d]|\$)[\w$]*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameAttribute"/>
+        </bygroups>
+      </rule>
+      <rule pattern="^\s*([^\W\d]|\$)[\w$]*:">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="([^\W\d]|\$)[\w$]*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="([0-9][0-9_]*\.([0-9][0-9_]*)?|\.[0-9][0-9_]*)([eE][+\-]?[0-9][0-9_]*)?[fFdD]?|[0-9][eE][+\-]?[0-9][0-9_]*[fFdD]?|[0-9]([eE][+\-]?[0-9][0-9_]*)?[fFdD]|0[xX]([0-9a-fA-F][0-9a-fA-F_]*\.?|([0-9a-fA-F][0-9a-fA-F_]*)?\.[0-9a-fA-F][0-9a-fA-F_]*)[pP][+\-]?[0-9][0-9_]*[fFdD]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0[xX][0-9a-fA-F][0-9a-fA-F_]*[lL]?">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="0[bB][01][01_]*[lL]?">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="0[0-7_]+[lL]?">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0|[1-9][0-9_]*[lL]?">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[~^*!%&amp;\[\](){}&lt;&gt;|+=:;,./?-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="import">
+      <rule pattern="[\w.]+">
+        <token type="NameNamespace"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bash.xml

@@ -0,0 +1,220 @@
+<lexer>
+  <config>
+    <name>Bash</name>
+    <alias>bash</alias>
+    <alias>sh</alias>
+    <alias>ksh</alias>
+    <alias>zsh</alias>
+    <alias>shell</alias>
+    <filename>*.sh</filename>
+    <filename>*.ksh</filename>
+    <filename>*.bash</filename>
+    <filename>*.ebuild</filename>
+    <filename>*.eclass</filename>
+    <filename>.env</filename>
+    <filename>*.env</filename>
+    <filename>*.exheres-0</filename>
+    <filename>*.exlib</filename>
+    <filename>*.zsh</filename>
+    <filename>*.zshrc</filename>
+    <filename>.bashrc</filename>
+    <filename>bashrc</filename>
+    <filename>.bash_*</filename>
+    <filename>bash_*</filename>
+    <filename>zshrc</filename>
+    <filename>.zshrc</filename>
+    <filename>PKGBUILD</filename>
+    <mime_type>application/x-sh</mime_type>
+    <mime_type>application/x-shellscript</mime_type>
+    <analyse first="true" >
+      <regex pattern="(?m)^#!.*/bin/(?:env |)(?:bash|zsh|sh|ksh)" score="1.0" />
+    </analyse>
+  </config>
+  <rules>
+    <state name="data">
+      <rule pattern="(?s)\$?&#34;(\\\\|\\[0-7]+|\\.|[^&#34;\\$])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="(?s)\$&#39;(\\\\|\\[0-7]+|\\.|[^&#39;\\])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="(?s)&#39;.*?&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="&amp;">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\|">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\d+(?= |$)">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[^=\s\[\]{}()$&#34;\&#39;`\\&lt;&amp;|;]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="&lt;">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?s)(\\\\|\\[0-7]+|\\.|[^&#34;\\$])+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule>
+        <include state="interp"/>
+      </rule>
+    </state>
+    <state name="interp">
+      <rule pattern="\$\(\(">
+        <token type="Keyword"/>
+        <push state="math"/>
+      </rule>
+      <rule pattern="\$\(">
+        <token type="Keyword"/>
+        <push state="paren"/>
+      </rule>
+      <rule pattern="\$\{#?">
+        <token type="LiteralStringInterpol"/>
+        <push state="curly"/>
+      </rule>
+      <rule pattern="\$[a-zA-Z_]\w*">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\$(?:\d+|[#$?!_*@-])">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\$">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="paren">
+      <rule pattern="\)">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="math">
+      <rule pattern="\)\)">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[-+*/%^|&amp;]|\*\*|\|\|">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\d+#\d+">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\d+#(?! )">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="backticks">
+      <rule pattern="`">
+        <token type="LiteralStringBacktick"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="basic"/>
+      </rule>
+      <rule pattern="`">
+        <token type="LiteralStringBacktick"/>
+        <push state="backticks"/>
+      </rule>
+      <rule>
+        <include state="data"/>
+      </rule>
+      <rule>
+        <include state="interp"/>
+      </rule>
+    </state>
+    <state name="basic">
+      <rule pattern="\b(if|fi|else|while|do|done|for|then|return|function|case|select|continue|until|esac|elif)(\s*)\b">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(alias|bg|bind|break|builtin|caller|cd|command|compgen|complete|declare|dirs|disown|echo|enable|eval|exec|exit|export|false|fc|fg|getopts|hash|help|history|jobs|kill|let|local|logout|popd|printf|pushd|pwd|read|readonly|set|shift|shopt|source|suspend|test|time|times|trap|true|type|typeset|ulimit|umask|unalias|unset|wait)(?=[\s)`])">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\A#!.+\n">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="#.*(\S|$)">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="\\[\w\W]">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="(\b\w+)(\s*)(\+?=)">
+        <bygroups>
+          <token type="NameVariable"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[\[\]{}()=]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="&lt;&lt;&lt;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="&lt;&lt;-?\s*(\&#39;?)\\?(\w+)[\w\W]+?\2">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&amp;&amp;|\|\|">
+        <token type="Operator"/>
+      </rule>
+    </state>
+    <state name="curly">
+      <rule pattern="\}">
+        <token type="LiteralStringInterpol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=":-">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\w+">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[^}:&#34;\&#39;`$\\]+">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern=":">
+        <token type="Punctuation"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bash_session.xml

@@ -0,0 +1,25 @@
+<lexer>
+  <config>
+    <name>Bash Session</name>
+    <alias>bash-session</alias>
+    <alias>console</alias>
+    <alias>shell-session</alias>
+    <filename>*.sh-session</filename>
+    <mime_type>text/x-sh</mime_type>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="^((?:\[[^]]+@[^]]+\]\s?)?[#$%&gt;])(\s*)(.*\n?)">
+        <bygroups>
+          <token type="GenericPrompt"/>
+          <token type="Text"/>
+          <using lexer="bash"/>
+        </bygroups>
+      </rule>
+      <rule pattern="^.+\n?">
+        <token type="GenericOutput"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/batchfile.xml

@@ -0,0 +1,660 @@
+<lexer>
+  <config>
+    <name>Batchfile</name>
+    <alias>bat</alias>
+    <alias>batch</alias>
+    <alias>dosbatch</alias>
+    <alias>winbatch</alias>
+    <filename>*.bat</filename>
+    <filename>*.cmd</filename>
+    <mime_type>application/x-dos-batch</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="arithmetic">
+      <rule pattern="0[0-7]+">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0x[\da-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[(),]+">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="([=+\-*/!~]|%|\^\^)+">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="((?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(\^[\n\x1a]?)?[^()=+\-*/!~%^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0]|\^[\n\x1a\t\v\f\r ,;=\xa0]?[\w\W])+">
+        <usingself state="variable"/>
+      </rule>
+      <rule pattern="(?=[\x00|&amp;])">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="follow"/>
+      </rule>
+    </state>
+    <state name="else?">
+      <rule pattern="(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)">
+        <usingself state="text"/>
+      </rule>
+      <rule pattern="else(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="sqstring">
+      <rule>
+        <include state="variable-or-escape"/>
+      </rule>
+      <rule pattern="[^%]+|%">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\)((?=\()|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))(?:(?:[^\n\x1a^]|\^[\n\x1a]?[\w\W])*)">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="(?=((?:(?&lt;=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:))">
+        <token type="Text"/>
+        <push state="follow"/>
+      </rule>
+      <rule pattern="(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)">
+        <usingself state="text"/>
+      </rule>
+      <rule>
+        <include state="redirect"/>
+      </rule>
+      <rule pattern="[\n\x1a]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="root/compound"/>
+      </rule>
+      <rule pattern="@+">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="((?:for|if|rem)(?:(?=(?:\^[\n\x1a]?)?/)|(?:(?!\^)|(?&lt;=m))(?:(?=\()|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+)?(?:\^[\n\x1a]?)?/(?:\^[\n\x1a]?)?\?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+        </bygroups>
+        <push state="follow"/>
+      </rule>
+      <rule pattern="(goto(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(]))((?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|[^&#34;%\n\x1a&amp;&lt;&gt;|])*(?:\^[\n\x1a]?)?/(?:\^[\n\x1a]?)?\?(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|[^&#34;%\n\x1a&amp;&lt;&gt;|])*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+        </bygroups>
+        <push state="follow"/>
+      </rule>
+      <rule pattern="(setlocal|endlocal|prompt|verify|rename|mklink|rmdir|shift|start|color|dpath|title|chdir|erase|pushd|ftype|break|pause|mkdir|assoc|date|path|time|popd|keys|exit|type|copy|echo|move|dir|del|ren|ver|cls|vol|rd|md|cd)(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(])">
+        <token type="Keyword"/>
+        <push state="follow"/>
+      </rule>
+      <rule pattern="(call)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(:)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="call"/>
+      </rule>
+      <rule pattern="call(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(])">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(for(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/f(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <push state="for/f" state="for"/>
+      </rule>
+      <rule pattern="(for(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/l(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <push state="for/l" state="for"/>
+      </rule>
+      <rule pattern="for(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])(?!\^)">
+        <token type="Keyword"/>
+        <push state="for2" state="for"/>
+      </rule>
+      <rule pattern="(goto(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(:?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="label"/>
+      </rule>
+      <rule pattern="(if(?:(?=\()|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:/i(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))?)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:not(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))?)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+        </bygroups>
+        <push state="(?" state="if"/>
+      </rule>
+      <rule pattern="rem(((?=\()|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+)?.*|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(])(?:(?:[^\n\x1a^]|\^[\n\x1a]?[\w\W])*))">
+        <token type="CommentSingle"/>
+        <push state="follow"/>
+      </rule>
+      <rule pattern="(set(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(]))((?:(?:\^[\n\x1a]?)?[^\S\n])*)(/a)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <push state="arithmetic"/>
+      </rule>
+      <rule pattern="(set(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(]))((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:/p)?)((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|^=]|\^[\n\x1a]?[^&#34;=])+)?)((?:(?:\^[\n\x1a]?)?=)?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <usingself state="variable"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="follow"/>
+      </rule>
+      <rule>
+        <push state="follow"/>
+      </rule>
+    </state>
+    <state name="follow">
+      <rule pattern="((?:(?&lt;=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:)([\t\v\f\r ,;=\xa0]*)((?:(?:[^\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0+:^]|\^[\n\x1a]?[\w\W])*))(.*)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="NameLabel"/>
+          <token type="CommentSingle"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <include state="redirect"/>
+      </rule>
+      <rule pattern="(?=[\n\x1a])">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\|\|?|&amp;&amp;?">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="text"/>
+      </rule>
+    </state>
+    <state name="bqstring">
+      <rule>
+        <include state="variable-or-escape"/>
+      </rule>
+      <rule pattern="[^%]+|%">
+        <token type="LiteralStringBacktick"/>
+      </rule>
+    </state>
+    <state name="for2">
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(do(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))">
+        <bygroups>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[\n\x1a]+">
+        <token type="Text"/>
+      </rule>
+      <rule>
+        <include state="follow"/>
+      </rule>
+    </state>
+    <state name="label/compound">
+      <rule pattern="(?=\))">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="((?:(?:[^\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0+:^)]|\^[\n\x1a]?[^)])*)?)((?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|\^[\n\x1a]?[^)]|[^&#34;%^\n\x1a&amp;&lt;&gt;|)])*)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="CommentSingle"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="for">
+      <rule pattern="((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(in)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(\()">
+        <bygroups>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="follow"/>
+      </rule>
+    </state>
+    <state name="redirect/compound">
+      <rule pattern="((?:(?&lt;=[\n\x1a\t\v\f\r ,;=\xa0])\d)?)(&gt;&gt;?&amp;|&lt;&amp;)([\n\x1a\t\v\f\r ,;=\xa0]*)(\d)">
+        <bygroups>
+          <token type="LiteralNumberInteger"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="LiteralNumberInteger"/>
+        </bygroups>
+      </rule>
+      <rule pattern="((?:(?&lt;=[\n\x1a\t\v\f\r ,;=\xa0])(?&lt;!\^[\n\x1a])\d)?)(&gt;&gt;?|&lt;)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0)])+))+))">
+        <bygroups>
+          <token type="LiteralNumberInteger"/>
+          <token type="Punctuation"/>
+          <usingself state="text"/>
+        </bygroups>
+      </rule>
+    </state>
+    <state name="if">
+      <rule pattern="((?:cmdextversion|errorlevel)(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(\d+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="LiteralNumberInteger"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(defined(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))((?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+))">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <usingself state="variable"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(exist(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+))">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="((?:-?(?:0[0-7]+|0x[\da-f]+|\d+)(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))((?:equ|geq|gtr|leq|lss|neq))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)(?:-?(?:0[0-7]+|0x[\da-f]+|\d+)(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))">
+        <bygroups>
+          <usingself state="arithmetic"/>
+          <token type="OperatorWord"/>
+          <usingself state="arithmetic"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+)">
+        <usingself state="text"/>
+        <push state="#pop" state="if2"/>
+      </rule>
+    </state>
+    <state name="root/compound">
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?=((?:(?&lt;=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:))">
+        <token type="Text"/>
+        <push state="follow/compound"/>
+      </rule>
+      <rule pattern="(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)">
+        <usingself state="text"/>
+      </rule>
+      <rule>
+        <include state="redirect/compound"/>
+      </rule>
+      <rule pattern="[\n\x1a]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="root/compound"/>
+      </rule>
+      <rule pattern="@+">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="((?:for|if|rem)(?:(?=(?:\^[\n\x1a]?)?/)|(?:(?!\^)|(?&lt;=m))(?:(?=\()|(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0)])+)?(?:\^[\n\x1a]?)?/(?:\^[\n\x1a]?)?\?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+        </bygroups>
+        <push state="follow/compound"/>
+      </rule>
+      <rule pattern="(goto(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(])))((?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|[^&#34;%\n\x1a&amp;&lt;&gt;|)])*(?:\^[\n\x1a]?)?/(?:\^[\n\x1a]?)?\?(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|[^&#34;%\n\x1a&amp;&lt;&gt;|)])*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+        </bygroups>
+        <push state="follow/compound"/>
+      </rule>
+      <rule pattern="(setlocal|endlocal|prompt|verify|rename|mklink|rmdir|shift|start|color|dpath|title|chdir|erase|pushd|ftype|break|pause|mkdir|assoc|date|path|time|popd|keys|exit|type|copy|echo|move|dir|del|ren|ver|cls|vol|rd|md|cd)(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(]))">
+        <token type="Keyword"/>
+        <push state="follow/compound"/>
+      </rule>
+      <rule pattern="(call)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(:)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="call/compound"/>
+      </rule>
+      <rule pattern="call(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(]))">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(for(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/f(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <push state="for/f" state="for"/>
+      </rule>
+      <rule pattern="(for(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/l(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <push state="for/l" state="for"/>
+      </rule>
+      <rule pattern="for(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a]))(?!\^)">
+        <token type="Keyword"/>
+        <push state="for2" state="for"/>
+      </rule>
+      <rule pattern="(goto(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(])))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(:?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="label/compound"/>
+      </rule>
+      <rule pattern="(if(?:(?=\()|(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:/i(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))?)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:not(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))?)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+        </bygroups>
+        <push state="(?" state="if"/>
+      </rule>
+      <rule pattern="rem(((?=\()|(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&amp;&lt;&gt;|\n\x1a])))(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+)?.*|(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(]))(?:(?:[^\n\x1a^)]|\^[\n\x1a]?[^)])*))">
+        <token type="CommentSingle"/>
+        <push state="follow/compound"/>
+      </rule>
+      <rule pattern="(set(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(])))((?:(?:\^[\n\x1a]?)?[^\S\n])*)(/a)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <push state="arithmetic/compound"/>
+      </rule>
+      <rule pattern="(set(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&amp;&lt;&gt;|(])))((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:/p)?)((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|^=)]|\^[\n\x1a]?[^&#34;=])+)?)((?:(?:\^[\n\x1a]?)?=)?)">
+        <bygroups>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <token type="Keyword"/>
+          <usingself state="text"/>
+          <usingself state="variable"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="follow/compound"/>
+      </rule>
+      <rule>
+        <push state="follow/compound"/>
+      </rule>
+    </state>
+    <state name="follow/compound">
+      <rule pattern="(?=\))">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="((?:(?&lt;=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:)([\t\v\f\r ,;=\xa0]*)((?:(?:[^\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0+:^)]|\^[\n\x1a]?[^)])*))(.*)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="NameLabel"/>
+          <token type="CommentSingle"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <include state="redirect/compound"/>
+      </rule>
+      <rule pattern="(?=[\n\x1a])">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\|\|?|&amp;&amp;?">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="text"/>
+      </rule>
+    </state>
+    <state name="text">
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string"/>
+      </rule>
+      <rule>
+        <include state="variable-or-escape"/>
+      </rule>
+      <rule pattern="[^&#34;%^\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0\d)]+|.">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="redirect">
+      <rule pattern="((?:(?&lt;=[\n\x1a\t\v\f\r ,;=\xa0])\d)?)(&gt;&gt;?&amp;|&lt;&amp;)([\n\x1a\t\v\f\r ,;=\xa0]*)(\d)">
+        <bygroups>
+          <token type="LiteralNumberInteger"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="LiteralNumberInteger"/>
+        </bygroups>
+      </rule>
+      <rule pattern="((?:(?&lt;=[\n\x1a\t\v\f\r ,;=\xa0])(?&lt;!\^[\n\x1a])\d)?)(&gt;&gt;?|&lt;)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+))">
+        <bygroups>
+          <token type="LiteralNumberInteger"/>
+          <token type="Punctuation"/>
+          <usingself state="text"/>
+        </bygroups>
+      </rule>
+    </state>
+    <state name="label">
+      <rule pattern="((?:(?:[^\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0+:^]|\^[\n\x1a]?[\w\W])*)?)((?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|\^[\n\x1a]?[\w\W]|[^&#34;%^\n\x1a&amp;&lt;&gt;|])*)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="CommentSingle"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="arithmetic/compound">
+      <rule pattern="(?=\))">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="0[0-7]+">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0x[\da-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[(),]+">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="([=+\-*/!~]|%|\^\^)+">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="((?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(\^[\n\x1a]?)?[^()=+\-*/!~%^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0]|\^[\n\x1a\t\v\f\r ,;=\xa0]?[^)])+">
+        <usingself state="variable"/>
+      </rule>
+      <rule pattern="(?=[\x00|&amp;])">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="follow"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\^!|%%">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="[^&#34;%^\n\x1a]+|[%^]">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="variable">
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string"/>
+      </rule>
+      <rule>
+        <include state="variable-or-escape"/>
+      </rule>
+      <rule pattern="[^&#34;%^\n\x1a]+|.">
+        <token type="NameVariable"/>
+      </rule>
+    </state>
+    <state name="call/compound">
+      <rule pattern="(?=\))">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(:?)((?:(?:[^\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0+:^)]|\^[\n\x1a]?[^)])*))">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameLabel"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="for/f">
+      <rule pattern="(&#34;)((?:(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|[^&#34;])*?&#34;)([\n\x1a\t\v\f\r ,;=\xa0]*)(\))">
+        <bygroups>
+          <token type="LiteralStringDouble"/>
+          <usingself state="string"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="#pop" state="for2" state="string"/>
+      </rule>
+      <rule pattern="(&#39;(?:%%|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|[\w\W])*?&#39;)([\n\x1a\t\v\f\r ,;=\xa0]*)(\))">
+        <bygroups>
+          <usingself state="sqstring"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(`(?:%%|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|[\w\W])*?`)([\n\x1a\t\v\f\r ,;=\xa0]*)(\))">
+        <bygroups>
+          <usingself state="bqstring"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <include state="for2"/>
+      </rule>
+    </state>
+    <state name="for/l">
+      <rule pattern="-?\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule>
+        <include state="for2"/>
+      </rule>
+    </state>
+    <state name="if2">
+      <rule pattern="((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(==)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+))">
+        <bygroups>
+          <usingself state="text"/>
+          <token type="Operator"/>
+          <usingself state="text"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))((?:equ|geq|gtr|leq|lss|neq))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)(?:[&amp;&lt;&gt;|]+|(?:(?:&#34;[^\n\x1a&#34;]*(?:&#34;|(?=[\n\x1a])))|(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))|(?:(?:(?:\^[\n\x1a]?)?[^&#34;\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0])+))+))">
+        <bygroups>
+          <usingself state="text"/>
+          <token type="OperatorWord"/>
+          <usingself state="text"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="(?">
+      <rule pattern="(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)">
+        <usingself state="text"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="#pop" state="else?" state="root/compound"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="call">
+      <rule pattern="(:?)((?:(?:[^\n\x1a&amp;&lt;&gt;|\t\v\f\r ,;=\xa0+:^]|\^[\n\x1a]?[\w\W])*))">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameLabel"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="variable-or-escape">
+      <rule pattern="(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|[^%:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%\n\x1a^]|\^[^%\n\x1a])[^=\n\x1a]*=(?:[^%\n\x1a^]|\^[^%\n\x1a])*)?)?%))|(?:\^?![^!:\n\x1a]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^!\n\x1a^]|\^[^!\n\x1a])[^=\n\x1a]*=(?:[^!\n\x1a^]|\^[^!\n\x1a])*)?)?\^?!))">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="%%|\^[\n\x1a]?(\^!|[\w\W])">
+        <token type="LiteralStringEscape"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bibtex.xml

@@ -0,0 +1,152 @@
+<lexer>
+  <config>
+    <name>BibTeX</name>
+    <alias>bib</alias>
+    <alias>bibtex</alias>
+    <filename>*.bib</filename>
+    <mime_type>text/x-bibtex</mime_type>
+    <case_insensitive>true</case_insensitive>
+    <not_multiline>true</not_multiline>
+  </config>
+  <rules>
+    <state name="closing-brace">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="[})]">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="braced-string">
+      <rule pattern="\{">
+        <token type="LiteralString"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^\{\}]+">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="whitespace">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="value">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="[a-z_@!$&amp;*+\-./:;&lt;&gt;?\[\\\]^`|~][\w@!$&amp;*+\-./:;&lt;&gt;?\[\\\]^`|~]*">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="quoted-string"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="LiteralString"/>
+        <push state="braced-string"/>
+      </rule>
+      <rule pattern="[\d]+">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="#">
+        <token type="Punctuation"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="quoted-string">
+      <rule pattern="\{">
+        <token type="LiteralString"/>
+        <push state="braced-string"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^\{\&#34;]+">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="@comment">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="@preamble">
+        <token type="NameClass"/>
+        <push state="closing-brace" state="value" state="opening-brace"/>
+      </rule>
+      <rule pattern="@string">
+        <token type="NameClass"/>
+        <push state="closing-brace" state="field" state="opening-brace"/>
+      </rule>
+      <rule pattern="@[a-z_@!$&amp;*+\-./:;&lt;&gt;?\[\\\]^`|~][\w@!$&amp;*+\-./:;&lt;&gt;?\[\\\]^`|~]*">
+        <token type="NameClass"/>
+        <push state="closing-brace" state="command-body" state="opening-brace"/>
+      </rule>
+      <rule pattern=".+">
+        <token type="Comment"/>
+      </rule>
+    </state>
+    <state name="command-body">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="[^\s\,\}]+">
+        <token type="NameLabel"/>
+        <push state="#pop" state="fields"/>
+      </rule>
+    </state>
+    <state name="fields">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern=",">
+        <token type="Punctuation"/>
+        <push state="field"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="=">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="=">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="field">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="[a-z_@!$&amp;*+\-./:;&lt;&gt;?\[\\\]^`|~][\w@!$&amp;*+\-./:;&lt;&gt;?\[\\\]^`|~]*">
+        <token type="NameAttribute"/>
+        <push state="value" state="="/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="opening-brace">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="[{(]">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bicep.xml

@@ -0,0 +1,68 @@
+<lexer>
+  <config>
+    <name>Bicep</name>
+    <alias>bicep</alias>
+    <filename>*.bicep</filename>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="//[^\n\r]+">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="([&#39;]?\w+[&#39;]?)(:)">
+        <bygroups>
+          <token type="NameProperty"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(&#39;(resourceGroup|subscription|managementGroup|tenant)&#39;)\b">
+        <token type="KeywordNamespace"/>
+      </rule>
+      <rule pattern="&#39;[\w\$\{\(\)\}\.]{1,}?&#39;">
+        <token type="LiteralStringInterpol"/>
+      </rule>
+      <rule pattern="(&#39;&#39;&#39;|&#39;).*?(&#39;&#39;&#39;|&#39;)">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\b(allowed|batchSize|description|maxLength|maxValue|metadata|minLength|minValue|secure)\b">
+        <token type="NameDecorator"/>
+      </rule>
+      <rule pattern="\b(az|sys)\.">
+        <token type="NameNamespace"/>
+      </rule>
+      <rule pattern="\b(any|array|concat|contains|empty|first|intersection|items|last|length|min|max|range|skip|take|union|dateTimeAdd|utcNow|deployment|environment|loadFileAsBase64|loadTextContent|int|json|extensionResourceId|getSecret|list|listKeys|listKeyValue|listAccountSas|listSecrets|pickZones|reference|resourceId|subscriptionResourceId|tenantResourceId|managementGroup|resourceGroup|subscription|tenant|base64|base64ToJson|base64ToString|dataUri|dataUriToString|endsWith|format|guid|indexOf|lastIndexOf|length|newGuid|padLeft|replace|split|startsWith|string|substring|toLower|toUpper|trim|uniqueString|uri|uriComponent|uriComponentToString)\b">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="\b(bool)(\()">
+        <bygroups>
+          <token type="NameFunction"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(for|if|in)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(module|output|param|resource|var)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="\b(array|bool|int|object|string)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(&gt;=|&gt;|&lt;=|&lt;|==|!=|=~|!~|::|&amp;&amp;|\?\?|!|-|%|\*|\/|\+)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[\(\)\[\]\.:\?{}@=]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[\w_-]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/blitzbasic.xml

@@ -0,0 +1,141 @@
+<lexer>
+  <config>
+    <name>BlitzBasic</name>
+    <alias>blitzbasic</alias>
+    <alias>b3d</alias>
+    <alias>bplus</alias>
+    <filename>*.bb</filename>
+    <filename>*.decls</filename>
+    <mime_type>text/x-bb</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="string">
+      <rule pattern="&#34;&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;C?">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^&#34;]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="[ \t]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="[0-9]+\.[0-9]*(?!\.)">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="\.[0-9]+(?!\.)">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="\$[0-9a-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\%[10]+">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="\b(Before|Handle|After|First|Float|Last|Sgn|Abs|Not|And|Int|Mod|Str|Sar|Shr|Shl|Or)\b">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="([+\-*/~=&lt;&gt;^])">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[(),:\[\]\\]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\.([ \t]*)([a-z]\w*)">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="\b(New)\b([ \t]+)([a-z]\w*)">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(Gosub|Goto)\b([ \t]+)([a-z]\w*)">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+          <token type="NameLabel"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(Object)\b([ \t]*)([.])([ \t]*)([a-z]\w*)\b">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b([a-z]\w*)(?:([ \t]*)(@{1,2}|[#$%])|([ \t]*)([.])([ \t]*)(?:([a-z]\w*)))?\b([ \t]*)(\()">
+        <bygroups>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(Function)\b([ \t]+)([a-z]\w*)(?:([ \t]*)(@{1,2}|[#$%])|([ \t]*)([.])([ \t]*)(?:([a-z]\w*)))?">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(Type)([ \t]+)([a-z]\w*)">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b(Pi|True|False|Null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="\b(Local|Global|Const|Field|Dim)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="\b(Function|Restore|Default|Forever|Include|Return|Repeat|ElseIf|Delete|Insert|Select|EndIf|Until|While|Gosub|Type|Goto|Else|Data|Next|Step|Each|Case|Wend|Exit|Read|Then|For|New|Asc|Len|Chr|End|To|If)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="([a-z]\w*)(?:([ \t]*)(@{1,2}|[#$%])|([ \t]*)([.])([ \t]*)(?:([a-z]\w*)))?">
+        <bygroups>
+          <token type="NameVariable"/>
+          <token type="Text"/>
+          <token type="KeywordType"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bnf.xml

@@ -0,0 +1,28 @@
+<lexer>
+  <config>
+    <name>BNF</name>
+    <alias>bnf</alias>
+    <filename>*.bnf</filename>
+    <mime_type>text/x-bnf</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="(&lt;)([ -;=?-~]+)(&gt;)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameClass"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="::=">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[^&lt;&gt;:]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bqn.xml

@@ -0,0 +1,83 @@
+<lexer>
+  <config>
+    <name>BQN</name>
+    <alias>bqn</alias>
+    <filename>*.bqn</filename>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="\A#!.+$">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="#.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="&quot;(?:[^&quot;]|&quot;&quot;)*&quot;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="[{}]">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="[⟨⟩\[\]‿]">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="[()]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[:;?]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[⋄,]">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="[←⇐↩→]">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="'.'">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="[˙˜˘¨⌜⁼´˝`]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[∘○⊸⟜⌾⊘◶⎉⚇⍟⎊]">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="[𝔽𝔾𝕎𝕏𝕊+\-×÷⋆√⌊⌈|¬∧∨&lt;&gt;≠=≤≥≡≢⊣⊢⥊∾≍⋈↑↓↕«»⌽⍉/⍋⍒⊏⊑⊐⊒∊⍷⊔!⍕⍎]">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="[𝕗𝕘𝕨𝕩𝕤]">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="·">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="@">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="\d+(?:\.\d+)?[eE]¯?\d+">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[¯∞π]?(?:\d*\.?\b\d+(?:e[+¯]?\d+|E[+¯]?\d+)?|¯|∞|π)(?:j¯?(?:(?:\d+(?:\.\d+)?|\.\d+)(?:e[+¯]?\d+|E[+¯]?\d+)?|¯|∞|π))?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="(•?[a-z][A-Z_a-z0-9π∞¯]*|𝕣)">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="•?[A-Z][A-Z_a-z0-9π∞¯]*">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(•?_[A-Za-z][A-Z_a-z0-9π∞¯]*|_𝕣)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(•?_[A-Za-z][A-Z_a-z0-9π∞¯]*_|_𝕣_)">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="\.">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/brainfuck.xml

@@ -0,0 +1,51 @@
+<lexer>
+  <config>
+    <name>Brainfuck</name>
+    <alias>brainfuck</alias>
+    <alias>bf</alias>
+    <filename>*.bf</filename>
+    <filename>*.b</filename>
+    <mime_type>application/x-brainfuck</mime_type>
+  </config>
+  <rules>
+    <state name="common">
+      <rule pattern="[.,]+">
+        <token type="NameTag"/>
+      </rule>
+      <rule pattern="[+-]+">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="[&lt;&gt;]+">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[^.,+\-&lt;&gt;\[\]]+">
+        <token type="Comment"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\[">
+        <token type="Keyword"/>
+        <push state="loop"/>
+      </rule>
+      <rule pattern="\]">
+        <token type="Error"/>
+      </rule>
+      <rule>
+        <include state="common"/>
+      </rule>
+    </state>
+    <state name="loop">
+      <rule pattern="\[">
+        <token type="Keyword"/>
+        <push/>
+      </rule>
+      <rule pattern="\]">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="common"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c#.xml

@@ -0,0 +1,121 @@
+<lexer>
+  <config>
+    <name>C#</name>
+    <alias>csharp</alias>
+    <alias>c#</alias>
+    <filename>*.cs</filename>
+    <mime_type>text/x-csharp</mime_type>
+    <dot_all>true</dot_all>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="^\s*\[.*?\]">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="///[^\n\r]+">
+        <token type="CommentSpecial"/>
+      </rule>
+      <rule pattern="//[^\n\r]+">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/[*].*?[*]/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="[~!%^&amp;*()+=|\[\]:;,.&lt;&gt;/?-]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[{}]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="@&#34;(&#34;&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\$@?&#34;(&#34;&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;\n])*[&#34;\n]">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#39;\\.&#39;|&#39;[^\\]&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="0[xX][0-9a-fA-F]+[Ll]?|\d[_\d]*(\.\d*)?([eE][+-]?\d+)?[flFLdD]?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="#[ \t]*(if|endif|else|elif|define|undef|line|error|warning|region|endregion|pragma|nullable)\b">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="\b(extern)(\s+)(alias)\b">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(as|await|base|break|by|case|catch|checked|continue|default|delegate|do|else|event|finally|fixed|for|foreach|goto|if|in|init|is|let|lock|new|on|out|params|readonly|ref|return|sizeof|stackalloc|switch|this|throw|try|typeof|unchecked|virtual|void|while|get|set|new|yield|add|remove|value|alias|ascending|descending|from|group|into|orderby|select|thenby|where|join|equals)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(global)(::)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(abstract|async|const|enum|explicit|extern|implicit|internal|operator|override|partial|private|protected|public|static|sealed|unsafe|volatile)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(bool|byte|char|decimal|double|dynamic|float|int|long|object|sbyte|short|string|uint|ulong|ushort|var)\b\??">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(class|struct|record|interface)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="class"/>
+      </rule>
+      <rule pattern="(namespace|using)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="namespace"/>
+      </rule>
+      <rule pattern="@?[_a-zA-Z]\w*">
+        <token type="Name"/>
+      </rule>
+    </state>
+    <state name="class">
+      <rule pattern="@?[_a-zA-Z]\w*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="namespace">
+      <rule pattern="(?=\()">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(@?[_a-zA-Z]\w*|\.)+">
+        <token type="NameNamespace"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c++.xml

@@ -0,0 +1,331 @@
+<lexer>
+  <config>
+    <name>C++</name>
+    <alias>cpp</alias>
+    <alias>c++</alias>
+    <filename>*.cpp</filename>
+    <filename>*.hpp</filename>
+    <filename>*.c++</filename>
+    <filename>*.h++</filename>
+    <filename>*.cc</filename>
+    <filename>*.hh</filename>
+    <filename>*.cxx</filename>
+    <filename>*.hxx</filename>
+    <filename>*.C</filename>
+    <filename>*.H</filename>
+    <filename>*.cp</filename>
+    <filename>*.CPP</filename>
+    <filename>*.tpp</filename>
+    <mime_type>text/x-c++hdr</mime_type>
+    <mime_type>text/x-c++src</mime_type>
+    <ensure_nl>true</ensure_nl>
+    <analyse first="true">
+      <regex pattern="#include &lt;[a-z_]+>" score="0.2" />
+      <regex pattern="using namespace " score="0.4" />
+    </analyse>
+  </config>
+  <rules>
+    <state name="classname">
+      <rule pattern="(\[\[.+\]\])(\s*)">
+        <bygroups>
+          <token type="NameAttribute"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\s*(?=[&gt;{])">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="whitespace">
+      <rule pattern="^#if\s+0">
+        <token type="CommentPreproc"/>
+        <push state="if0"/>
+      </rule>
+      <rule pattern="^#">
+        <token type="CommentPreproc"/>
+        <push state="macro"/>
+      </rule>
+      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#if\s+0)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <push state="if0"/>
+      </rule>
+      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <push state="macro"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//(\n|[\w\W]*?[^\\]\n)">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/(\\\n)?[*][\w\W]*?[*](\\\n)?/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/(\\\n)?[*][\w\W]*">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="macro">
+      <rule pattern="(include)(\s+)(&quot;[^&quot;]+?&quot;|&lt;[^&gt;]+?&gt;)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="CommentPreprocFile"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[^/\n]+">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="/[*](.|\n)*?[*]/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="/">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="(?&lt;=\\)\n">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="statements">
+      <rule pattern="(reinterpret_cast|static_assert|thread_local|dynamic_cast|static_cast|const_cast|co_return|protected|namespace|consteval|constexpr|typename|co_await|co_yield|operator|restrict|explicit|template|override|noexcept|requires|decltype|alignof|private|alignas|virtual|mutable|nullptr|concept|export|friend|typeid|throws|public|delete|final|throw|catch|using|this|new|try)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(enum)\b(\s+)(class)\b(\s*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="classname"/>
+      </rule>
+      <rule pattern="(class|struct|enum|union)\b(\s*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="classname"/>
+      </rule>
+      <rule pattern="\[\[.+\]\]">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="(R)(&#34;)([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(&#34;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralString"/>
+          <token type="LiteralStringDelimiter"/>
+          <token type="LiteralStringDelimiter"/>
+          <token type="LiteralString"/>
+          <token type="LiteralStringDelimiter"/>
+          <token type="LiteralString"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(u8|u|U)(&#34;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralString"/>
+        </bygroups>
+        <push state="string"/>
+      </rule>
+      <rule pattern="(L?)(&#34;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralString"/>
+        </bygroups>
+        <push state="string"/>
+      </rule>
+      <rule pattern="(L?)(&#39;)(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\&#39;\n])(&#39;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringChar"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="(\d+\.\d*|\.\d+|\d+[fF])[fF]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0[xX]([0-9A-Fa-f](&#39;?[0-9A-Fa-f]+)*)[LlUu]*">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="0(&#39;?[0-7]+)+[LlUu]*">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0[Bb][01](&#39;?[01]+)*[LlUu]*">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="[0-9](&#39;?[0-9]+)*[LlUu]*">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="Error"/>
+      </rule>
+      <rule pattern="[~!%^&amp;*+=|?:&lt;&gt;/-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[()\[\],.]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(restricted|volatile|continue|register|default|typedef|struct|extern|switch|sizeof|static|return|union|while|const|break|goto|enum|else|case|auto|for|asm|if|do)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(bool|int|long|float|short|double|char((8|16|32)_t)?|wchar_t|unsigned|signed|void|u?int(_fast|_least|)(8|16|32|64)_t)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(typename|__inline|restrict|_inline|thread|inline|naked)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(__m(128i|128d|128|64))\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="__(forceinline|identifier|unaligned|declspec|fastcall|stdcall|finally|except|assume|int32|cdecl|int64|based|leave|int16|raise|noop|int8|w64|try|asm)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(true|false|NULL)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="([a-zA-Z_]\w*)(\s*)(:)(?!:)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="Name"/>
+      </rule>
+    </state>
+    <state name="function">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="statements"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\([\\abfnrtv&#34;\&#39;]|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="[^\\&#34;\n]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="if0">
+      <rule pattern="^\s*#if.*?(?&lt;!\\)\n">
+        <token type="CommentPreproc"/>
+        <push/>
+      </rule>
+      <rule pattern="^\s*#el(?:se|if).*\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="^\s*#endif.*?(?&lt;!\\)\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=".*?\n">
+        <token type="Comment"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <usingself state="root"/>
+          <usingself state="root"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="function"/>
+      </rule>
+      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <usingself state="root"/>
+          <usingself state="root"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <push state="statement"/>
+      </rule>
+      <rule pattern="__(multiple_inheritance|virtual_inheritance|single_inheritance|interface|uuidof|super|event)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="__(offload|blockingoffload|outer)\b">
+        <token type="KeywordPseudo"/>
+      </rule>
+    </state>
+    <state name="statement">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="statements"/>
+      </rule>
+      <rule pattern="[{]">
+        <token type="Punctuation"/>
+        <push state="root"/>
+      </rule>
+      <rule pattern="[;}]">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c.xml

@@ -0,0 +1,260 @@
+<lexer>
+  <config>
+    <name>C</name>
+    <alias>c</alias>
+    <filename>*.c</filename>
+    <filename>*.h</filename>
+    <filename>*.idc</filename>
+    <filename>*.x[bp]m</filename>
+    <mime_type>text/x-chdr</mime_type>
+    <mime_type>text/x-csrc</mime_type>
+    <mime_type>image/x-xbitmap</mime_type>
+    <mime_type>image/x-xpixmap</mime_type>
+    <ensure_nl>true</ensure_nl>
+    <analyse first="true" >
+      <regex pattern="(?m)^\s*#include &lt;" score="0.1" />
+      <regex pattern="(?m)^\s*#ifn?def " score="0.1" />
+    </analyse>
+  </config>
+  <rules>
+    <state name="statement">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="statements"/>
+      </rule>
+      <rule pattern="[{}]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="function">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="statements"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\([\\abfnrtv&#34;\&#39;]|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="[^\\&#34;\n]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="macro">
+      <rule pattern="(include)(\s*(?:/[*].*?[*]/\s*)?)([^\n]+)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="CommentPreprocFile"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[^/\n]+">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="/[*](.|\n)*?[*]/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="/">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="(?&lt;=\\)\n">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="if0">
+      <rule pattern="^\s*#if.*?(?&lt;!\\)\n">
+        <token type="CommentPreproc"/>
+        <push/>
+      </rule>
+      <rule pattern="^\s*#el(?:se|if).*\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="^\s*#endif.*?(?&lt;!\\)\n">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=".*?\n">
+        <token type="Comment"/>
+      </rule>
+    </state>
+    <state name="whitespace">
+      <rule pattern="^#if\s+0">
+        <token type="CommentPreproc"/>
+        <push state="if0"/>
+      </rule>
+      <rule pattern="^#">
+        <token type="CommentPreproc"/>
+        <push state="macro"/>
+      </rule>
+      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#if\s+0)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <push state="if0"/>
+      </rule>
+      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <push state="macro"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//(\n|[\w\W]*?[^\\]\n)">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/(\\\n)?[*][\w\W]*?[*](\\\n)?/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/(\\\n)?[*][\w\W]*">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="statements">
+      <rule pattern="(L?)(&#34;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralString"/>
+        </bygroups>
+        <push state="string"/>
+      </rule>
+      <rule pattern="(L?)(&#39;)(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\&#39;\n])(&#39;)">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringChar"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="(\d+\.\d*|\.\d+|\d+[fF])[fF]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0x[0-9a-fA-F]+[LlUu]*">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="0[0-7]+[LlUu]*">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="\d+[LlUu]*">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="Error"/>
+      </rule>
+      <rule pattern="[~!%^&amp;*+=|?:&lt;&gt;/-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[()\[\],.]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(restricted|volatile|continue|register|default|typedef|struct|extern|switch|sizeof|static|return|union|while|const|break|goto|enum|else|case|auto|for|asm|if|do)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(bool|int|long|float|short|double|char((8|16|32)_t)?|unsigned|signed|void|u?int(_fast|_least|)(8|16|32|64)_t)\b|\b[a-z]\w*_t\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(typename|__inline|restrict|_inline|thread|inline|naked)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(__m(128i|128d|128|64))\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="__(forceinline|identifier|unaligned|declspec|fastcall|finally|stdcall|wchar_t|assume|except|int32|cdecl|int16|leave|based|raise|int64|noop|int8|w64|try|asm)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(true|false|NULL)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="([a-zA-Z_]\w*)(\s*)(:)(?!:)">
+        <bygroups>
+          <token type="NameLabel"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\b[A-Za-z_]\w*(?=\s*\()">
+          <token type="NameFunction"/>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="Name"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <usingself state="root"/>
+          <usingself state="root"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="function"/>
+      </rule>
+      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <usingself state="root"/>
+          <usingself state="root"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <push state="statement"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cap_n_proto.xml

@@ -0,0 +1,122 @@
+<lexer>
+  <config>
+    <name>Cap&#39;n Proto</name>
+    <alias>capnp</alias>
+    <filename>*.capnp</filename>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="#.*?$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="@[0-9a-zA-Z]*">
+        <token type="NameDecorator"/>
+      </rule>
+      <rule pattern="=">
+        <token type="Literal"/>
+        <push state="expression"/>
+      </rule>
+      <rule pattern=":">
+        <token type="NameClass"/>
+        <push state="type"/>
+      </rule>
+      <rule pattern="\$">
+        <token type="NameAttribute"/>
+        <push state="annotation"/>
+      </rule>
+      <rule pattern="(struct|enum|interface|union|import|using|const|annotation|extends|in|of|on|as|with|from|fixed)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="[\w.]+">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[^#@=:$\w]+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="type">
+      <rule pattern="[^][=;,(){}$]+">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="[[(]">
+        <token type="NameClass"/>
+        <push state="parentype"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="parentype">
+      <rule pattern="[^][;()]+">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="[[(]">
+        <token type="NameClass"/>
+        <push/>
+      </rule>
+      <rule pattern="[])]">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="expression">
+      <rule pattern="[^][;,(){}$]+">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="[[(]">
+        <token type="Literal"/>
+        <push state="parenexp"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="parenexp">
+      <rule pattern="[^][;()]+">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="[[(]">
+        <token type="Literal"/>
+        <push/>
+      </rule>
+      <rule pattern="[])]">
+        <token type="Literal"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="annotation">
+      <rule pattern="[^][;,(){}=:]+">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="[[(]">
+        <token type="NameAttribute"/>
+        <push state="annexp"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="annexp">
+      <rule pattern="[^][;()]+">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="[[(]">
+        <token type="NameAttribute"/>
+        <push/>
+      </rule>
+      <rule pattern="[])]">
+        <token type="NameAttribute"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cassandra_cql.xml

@@ -0,0 +1,137 @@
+<lexer>
+  <config>
+    <name>Cassandra CQL</name>
+    <alias>cassandra</alias>
+    <alias>cql</alias>
+    <filename>*.cql</filename>
+    <mime_type>text/x-cql</mime_type>
+    <case_insensitive>true</case_insensitive>
+    <not_multiline>true</not_multiline>
+  </config>
+  <rules>
+    <state name="string">
+      <rule pattern="[^&#39;]+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="&#39;&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="quoted-ident">
+      <rule pattern="[^&#34;]+">
+        <token type="LiteralStringName"/>
+      </rule>
+      <rule pattern="&#34;&#34;">
+        <token type="LiteralStringName"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringName"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="dollar-string">
+      <rule pattern="[^\$]+">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule pattern="\$\$">
+        <token type="LiteralStringHeredoc"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="(--|\/\/).*\n?">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push state="multiline-comments"/>
+      </rule>
+      <rule pattern="(ascii|bigint|blob|boolean|counter|date|decimal|double|float|frozen|inet|int|list|map|set|smallint|text|time|timestamp|timeuuid|tinyint|tuple|uuid|varchar|varint)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(DURABLE_WRITES|LOCAL_QUORUM|MATERIALIZED|COLUMNFAMILY|REPLICATION|NORECURSIVE|NOSUPERUSER|PERMISSIONS|EACH_QUORUM|CONSISTENCY|PERMISSION|CLUSTERING|WRITETIME|SUPERUSER|KEYSPACES|AUTHORIZE|LOCAL_ONE|AGGREGATE|FINALFUNC|PARTITION|FILTERING|UNLOGGED|CONTAINS|DISTINCT|FUNCTION|LANGUAGE|INFINITY|INITCOND|TRUNCATE|KEYSPACE|PASSWORD|REPLACE|OPTIONS|TRIGGER|STORAGE|ENTRIES|RETURNS|COMPACT|PRIMARY|EXISTS|STATIC|PAGING|UPDATE|CUSTOM|VALUES|INSERT|DELETE|MODIFY|CREATE|SELECT|SCHEMA|LOGGED|REVOKE|RENAME|QUORUM|CALLED|STYPE|ORDER|ALTER|BATCH|BEGIN|COUNT|ROLES|APPLY|WHERE|SFUNC|LEVEL|INPUT|LOGIN|INDEX|TABLE|THREE|ALLOW|TOKEN|LIMIT|USING|USERS|GRANT|FROM|KEYS|JSON|USER|INTO|ROLE|TYPE|VIEW|DESC|WITH|DROP|FULL|ASC|TTL|OFF|PER|KEY|USE|ADD|NAN|ONE|ALL|ANY|TWO|AND|NOT|AS|IN|IF|OF|IS|ON|TO|BY|OR)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="[+*/&lt;&gt;=~!@#%^&amp;|`?-]+">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(?s)(java|javascript)(\s+)(AS)(\s+)(&#39;|\$\$)(.*?)(\5)">
+        <usingbygroup>
+          <sublexer_name_group>1</sublexer_name_group>
+          <code_group>6</code_group>
+          <emitters>
+            <token type="NameBuiltin"/>
+            <token type="TextWhitespace"/>
+            <token type="Keyword"/>
+            <token type="TextWhitespace"/>
+            <token type="LiteralStringHeredoc"/>
+            <token type="LiteralStringHeredoc"/>
+            <token type="LiteralStringHeredoc"/>
+          </emitters>
+        </usingbygroup>
+      </rule>
+      <rule pattern="(true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="0x[0-9a-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\.[0-9]+(e[+-]?[0-9]+)?">
+        <token type="Error"/>
+      </rule>
+      <rule pattern="-?[0-9]+(\.[0-9])?(e[+-]?[0-9]+)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringName"/>
+        <push state="quoted-ident"/>
+      </rule>
+      <rule pattern="\$\$">
+        <token type="LiteralStringHeredoc"/>
+        <push state="dollar-string"/>
+      </rule>
+      <rule pattern="[a-z_]\w*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern=":([&#39;&#34;]?)[a-z]\w*\b\1">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[;:()\[\]\{\},.]">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+    <state name="multiline-comments">
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push state="multiline-comments"/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^/*]+">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="[/*]">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ceylon.xml

@@ -0,0 +1,151 @@
+<lexer>
+  <config>
+    <name>Ceylon</name>
+    <alias>ceylon</alias>
+    <filename>*.ceylon</filename>
+    <mime_type>text/x-ceylon</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="class">
+      <rule pattern="[A-Za-z_]\w*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="import">
+      <rule pattern="[a-z][\w.]*">
+        <token type="NameNamespace"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="comment">
+      <rule pattern="[^*/]">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[*/]">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)([a-zA-Z_]\w*)(\s*)(\()">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push state="comment"/>
+      </rule>
+      <rule pattern="(shared|abstract|formal|default|actual|variable|deprecated|small|late|literal|doc|by|see|throws|optional|license|tagged|final|native|annotation|sealed)\b">
+        <token type="NameDecorator"/>
+      </rule>
+      <rule pattern="(break|case|catch|continue|else|finally|for|in|if|return|switch|this|throw|try|while|is|exists|dynamic|nonempty|then|outer|assert|let)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(abstracts|extends|satisfies|super|given|of|out|assign)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(function|value|void|new)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(assembly|module|package)(\s+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(class|interface|object|alias)(\s+)">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="class"/>
+      </rule>
+      <rule pattern="(import)(\s+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="import"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#39;\\.&#39;|&#39;[^\\]&#39;|&#39;\\\{#[0-9a-fA-F]{4}\}&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="&#34;.*``.*``.*&#34;">
+        <token type="LiteralStringInterpol"/>
+      </rule>
+      <rule pattern="(\.)([a-z_]\w*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameAttribute"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*:">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[~^*!%&amp;\[\](){}&lt;&gt;|+=:;,./?-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\d{1,3}(_\d{3})+\.\d{1,3}(_\d{3})+[kMGTPmunpf]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="\d{1,3}(_\d{3})+\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*\.\d{1,3}(_\d{3})+[kMGTPmunpf]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="#([0-9a-fA-F]{4})(_[0-9a-fA-F]{4})+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="#[0-9a-fA-F]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\$([01]{4})(_[01]{4})+">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="\$[01]+">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="\d{1,3}(_\d{3})+[kMGTP]?">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[0-9]+[kMGTP]?">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cfengine3.xml

@@ -0,0 +1,197 @@
+<lexer>
+  <config>
+    <name>CFEngine3</name>
+    <alias>cfengine3</alias>
+    <alias>cf3</alias>
+    <filename>*.cf</filename>
+  </config>
+  <rules>
+    <state name="interpol">
+      <rule pattern="\$[{(]">
+        <token type="LiteralStringInterpol"/>
+        <push/>
+      </rule>
+      <rule pattern="[})]">
+        <token type="LiteralStringInterpol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^${()}]+">
+        <token type="LiteralStringInterpol"/>
+      </rule>
+    </state>
+    <state name="arglist">
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=",">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\w+">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="#.*?\n">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="^@.*?\n">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="(body)(\s+)(\S+)(\s+)(control)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(body|bundle|promise)(\s+)(\S+)(\s+)(\w+)(\()">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="arglist"/>
+      </rule>
+      <rule pattern="(body|bundle|promise)(\s+)(\S+)(\s+)(\w+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\S+)(\s*)(=&gt;)(\s*)">
+        <bygroups>
+          <token type="KeywordReserved"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="([\w.!&amp;|()&#34;&#36;]+)(::)">
+        <bygroups>
+          <token type="NameClass"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="doublequotestring"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralString"/>
+        <push state="singlequotestring"/>
+      </rule>
+      <rule pattern="&#96;">
+        <token type="LiteralString"/>
+        <push state="backtickstring"/>
+      </rule>
+      <rule pattern="(\w+)(\()">
+        <bygroups>
+          <token type="NameFunction"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\w+)(:)">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="@[{(][^)}]+[})]">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\$[(][^)]+[)]">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[(){},;]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="=&gt;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="-&gt;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\d+\.\d+">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="\w+">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="doublequotestring">
+      <rule pattern="\$[{(]">
+        <token type="LiteralStringInterpol"/>
+        <push state="interpol"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern=".">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="singlequotestring">
+      <rule pattern="\$[{(]">
+        <token type="LiteralStringInterpol"/>
+        <push state="interpol"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern=".">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="backtickstring">
+      <rule pattern="\$[{(]">
+        <token type="LiteralStringInterpol"/>
+        <push state="interpol"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="&#96;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern=".">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cfstatement.xml

@@ -0,0 +1,92 @@
+<lexer>
+  <config>
+    <name>cfstatement</name>
+    <alias>cfs</alias>
+    <case_insensitive>true</case_insensitive>
+    <not_multiline>true</not_multiline>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*(?:.|\n)*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="\+\+|--">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[-+*/^&amp;=!]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="&lt;=|&gt;=|&lt;|&gt;|==">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="mod\b">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(eq|lt|gt|lte|gte|not|is|and|or)\b">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\|\||&amp;&amp;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\?">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="&#39;.*?&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="(if|else|len|var|xml|default|break|switch|component|property|function|do|try|catch|in|continue|for|return|while|required|any|array|binary|boolean|component|date|guid|numeric|query|string|struct|uuid|case)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(application|session|client|cookie|super|this|variables|arguments)\b">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="([a-z_$][\w.]*)(\s*)(\()">
+        <bygroups>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[a-z_$][\w.]*">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[()\[\]{};:,.\\]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="&#34;&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="#.+?#">
+        <token type="LiteralStringInterpol"/>
+      </rule>
+      <rule pattern="[^&#34;#]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="#">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/chaiscript.xml

@@ -0,0 +1,134 @@
+<lexer>
+  <config>
+    <name>ChaiScript</name>
+    <alias>chai</alias>
+    <alias>chaiscript</alias>
+    <filename>*.chai</filename>
+    <mime_type>text/x-chaiscript</mime_type>
+    <mime_type>application/x-chaiscript</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="dqstring">
+      <rule pattern="\$\{[^&#34;}]+?\}">
+        <token type="LiteralStringInterpol"/>
+      </rule>
+      <rule pattern="\$">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="\\\\">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="\\&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="[^\\&#34;$]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="commentsandwhitespace">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="^\#.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+    </state>
+    <state name="slashstartsregex">
+      <rule>
+        <include state="commentsandwhitespace"/>
+      </rule>
+      <rule pattern="/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?=/)">
+        <token type="Text"/>
+        <push state="#pop" state="badregex"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="badregex">
+      <rule pattern="\n">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="commentsandwhitespace"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\+\+|--|~|&amp;&amp;|\?|:|\|\||\\(?=\n)|\.\.(&lt;&lt;|&gt;&gt;&gt;?|==?|!=?|[-&lt;&gt;+*%&amp;|^/])=?">
+        <token type="Operator"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="[{(\[;,]">
+        <token type="Punctuation"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="[})\].]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[=+\-*/]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(for|in|while|do|break|return|continue|if|else|throw|try|catch)\b">
+        <token type="Keyword"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="(var)\b">
+        <token type="KeywordDeclaration"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="(attr|def|fun)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(true|false)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(eval|throw)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="`\S+`">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="[$a-zA-Z_]\w*">
+        <token type="NameOther"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0x[0-9a-fA-F]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="dqstring"/>
+      </rule>
+      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/chapel.xml

@@ -0,0 +1,143 @@
+<lexer>
+  <config>
+    <name>Chapel</name>
+    <alias>chapel</alias>
+    <alias>chpl</alias>
+    <filename>*.chpl</filename>
+  </config>
+  <rules>
+    <state name="procname">
+      <rule pattern="([a-zA-Z_][.\w$]*|\~[a-zA-Z_][.\w$]*|[+*/!~%&lt;&gt;=&amp;^|\-:]{1,2})">
+        <token type="NameFunction"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="receivertype"/>
+      </rule>
+      <rule pattern="\)+\.">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+    <state name="receivertype">
+      <rule pattern="(unmanaged|borrowed|atomic|single|shared|owned|sync)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(complex|nothing|opaque|string|locale|bytes|range|imag|real|bool|uint|void|int)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="[^()]*">
+        <token type="NameOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\n">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//(.*?)\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/(\\\n)?[*](.|\n)*?[*](\\\n)?/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="(config|const|inout|param|type|out|ref|var|in)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(false|none|true|nil)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(complex|nothing|opaque|string|locale|bytes|range|imag|real|bool|uint|void|int)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(implements|forwarding|prototype|otherwise|subdomain|primitive|unmanaged|override|borrowed|lifetime|coforall|continue|private|require|dmapped|cobegin|foreach|lambda|sparse|shared|domain|pragma|reduce|except|export|extern|throws|forall|delete|return|noinit|single|import|select|public|inline|serial|atomic|defer|break|local|index|throw|catch|label|begin|where|while|align|yield|owned|only|this|sync|with|scan|else|enum|init|when|then|let|for|try|use|new|zip|if|by|as|on|do)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(iter)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+        </bygroups>
+        <push state="procname"/>
+      </rule>
+      <rule pattern="(proc)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+        </bygroups>
+        <push state="procname"/>
+      </rule>
+      <rule pattern="(operator)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+        </bygroups>
+        <push state="procname"/>
+      </rule>
+      <rule pattern="(class|interface|module|record|union)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="TextWhitespace"/>
+        </bygroups>
+        <push state="classname"/>
+      </rule>
+      <rule pattern="\d+i">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\d+\.\d*([Ee][-+]\d+)?i">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\.\d+([Ee][-+]\d+)?i">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\d+[Ee][-+]\d+i">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="(\d*\.\d+)([eE][+-]?[0-9]+)?i?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="\d+[eE][+-]?[0-9]+i?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0[bB][01]+">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="0[xX][0-9a-fA-F]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="0[oO][0-7]+">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="(=|\+=|-=|\*=|/=|\*\*=|%=|&amp;=|\|=|\^=|&amp;&amp;=|\|\|=|&lt;&lt;=|&gt;&gt;=|&lt;=&gt;|&lt;~&gt;|\.\.|by|#|\.\.\.|&amp;&amp;|\|\||!|&amp;|\||\^|~|&lt;&lt;|&gt;&gt;|==|!=|&lt;=|&gt;=|&lt;|&gt;|[+\-*/%]|\*\*)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[:;,.?()\[\]{}]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[a-zA-Z_][\w$]*">
+        <token type="NameOther"/>
+      </rule>
+    </state>
+    <state name="classname">
+      <rule pattern="[a-zA-Z_][\w$]*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cheetah.xml

@@ -0,0 +1,55 @@
+<lexer>
+  <config>
+    <name>Cheetah</name>
+    <alias>cheetah</alias>
+    <alias>spitfire</alias>
+    <filename>*.tmpl</filename>
+    <filename>*.spt</filename>
+    <mime_type>application/x-cheetah</mime_type>
+    <mime_type>application/x-spitfire</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="(##[^\n]*)$">
+        <bygroups>
+          <token type="Comment"/>
+        </bygroups>
+      </rule>
+      <rule pattern="#[*](.|\n)*?[*]#">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="#end[^#\n]*(?:#|$)">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="#slurp$">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="(#[a-zA-Z]+)([^#\n]*)(#|$)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <using lexer="Python"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\$)([a-zA-Z_][\w.]*\w)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <using lexer="Python"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\$\{!?)(.*?)(\})(?s)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <using lexer="Python"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(?sx)&#xA;                (.+?)               # anything, followed by:&#xA;                (?:&#xA;                 (?=\#[#a-zA-Z]*) | # an eval comment&#xA;                 (?=\$[a-zA-Z_{]) | # a substitution&#xA;                 \Z                 # end of string&#xA;                )&#xA;            ">
+        <token type="Other"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/clojure.xml

@@ -0,0 +1,71 @@
+<lexer>
+  <config>
+    <name>Clojure</name>
+    <alias>clojure</alias>
+    <alias>clj</alias>
+    <alias>edn</alias>
+    <filename>*.clj</filename>
+    <filename>*.edn</filename>
+    <mime_type>text/x-clojure</mime_type>
+    <mime_type>application/x-clojure</mime_type>
+    <mime_type>application/edn</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern=";.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="[,\s]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="-?\d+\.\d+">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="-?\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="0x-?[abcdef\d]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#39;(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="\\(.|[a-z]+)">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="::?#?(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="~@|[`\&#39;#^~&amp;@]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(quote|loop|new|var|let|def|if|do|fn|\.) ">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(definterface|defprotocol|defproject|defstruct|definline|defmethod|defrecord|defmulti|defmacro|defonce|declare|deftype|defn-|def-|defn|ns) ">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(clear-agent-errors|construct-proxy|bit-shift-right|get-proxy-class|special-symbol\?|with-local-vars|proxy-mappings|bit-shift-left|sorted-map-by|macroexpand-1|remove-method|create-struct|resultset-seq|inspect-table|inspect-tree|update-proxy|aset-boolean|agent-errors|with-out-str|insert-child|append-child|intersection|insert-right|to-array-2d|rename-keys|println-str|macroexpand|aset-double|select-keys|insert-left|aset-float|aset-short|interleave|re-pattern|make-array|identical\?|take-while|into-array|re-matches|re-matcher|complement|vector-zip|drop-while|when-first|map-invert|sorted-map|ns-resolve|difference|sorted-set|merge-with|ns-publics|split-with|ns-interns|ns-imports|constantly|struct-map|comparator|not-every\?|aset-long|print-str|re-groups|lazy-cons|remove-ns|namespace|await-for|contains\?|array-map|create-ns|make-node|with-meta|with-open|instance\?|ns-refers|aset-byte|aset-char|load-file|read-line|replicate|send-off|aset-int|distinct|not-any\?|take-nth|tree-seq|split-at|to-array|ns-unmap|identity|find-doc|find-var|hash-set|when-not|children|when-let|lazy-cat|hash-map|line-seq|rand-int|keyword\?|file-seq|accessor|replace|bit-not|find-ns|resolve|bit-and|println|binding|locking|vector\?|partial|nthrest|max-key|bit-xor|dotimes|ref-set|xml-seq|boolean|var-get|seq-zip|sort-by|branch\?|butlast|symbol\?|project|min-key|ns-name|comment|string\?|iterate|commute|alength|xml-zip|keyword|newline|re-find|reverse|var-set|prn-str|bit-or|import|re-seq|rights|assert|reduce|remove|gensym|rename|filter|ffirst|if-let|false\?|pr-str|every\?|vector|mapcat|ensure|rfirst|concat|second|double|select|dosync|symbol|subvec|if-not|ns-map|struct|zipper|zipmap|all-ns|dissoc|repeat|assoc|cycle|class|deref|zero\?|slurp|short|dorun|doseq|merge|memfn|agent|rrest|count|parse|right|float|flush|alter|fnseq|frest|doall|print|refer|in-ns|apply|union|await|list\*|proxy|lefts|true\?|index|first|range|left|keys|aset|join|into|last|read|rand|list|load|long|loop|conj|test|vals|pos\?|bean|peek|subs|path|time|find|rest|eval|end\?|edit|map\?|drop|root|aget|rseq|down|doto|meta|send|when|byte|take|seq\?|sync|name|neg\?|some|sort|cast|char|disj|next|not=|nil\?|node|comp|cond|cons|quot|var\?|max|new|rem|set|doc|seq|for|get|ref|inc|int|key|not|prn|min|map|val|nth|dec|pop|and|str|pr|\.\.|up|&gt;=|-&gt;|==|&lt;=|or|=|/|&gt;|-|\*|\+|&lt;) ">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(?&lt;=\()(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="(\[|\])">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(\{|\})">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(\(|\))">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cmake.xml

@@ -0,0 +1,90 @@
+<lexer>
+  <config>
+    <name>CMake</name>
+    <alias>cmake</alias>
+    <filename>*.cmake</filename>
+    <filename>CMakeLists.txt</filename>
+    <mime_type>text/x-cmake</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\b(\w+)([ \t]*)(\()">
+        <bygroups>
+          <token type="NameBuiltin"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="args"/>
+      </rule>
+      <rule>
+        <include state="keywords"/>
+      </rule>
+      <rule>
+        <include state="ws"/>
+      </rule>
+    </state>
+    <state name="args">
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push/>
+      </rule>
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(\$\{)(.+?)(\})">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameVariable"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\$ENV\{)(.+?)(\})">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameVariable"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\$&lt;)(.+?)(&gt;)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameVariable"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(?s)&#34;.*?&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="\\\S+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="[^)$&#34;# \t\n]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule>
+        <include state="keywords"/>
+      </rule>
+      <rule>
+        <include state="ws"/>
+      </rule>
+    </state>
+    <state name="string"/>
+    <state name="keywords">
+      <rule pattern="\b(WIN32|UNIX|APPLE|CYGWIN|BORLAND|MINGW|MSVC|MSVC_IDE|MSVC60|MSVC70|MSVC71|MSVC80|MSVC90)\b">
+        <token type="Keyword"/>
+      </rule>
+    </state>
+    <state name="ws">
+      <rule pattern="[ \t]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="#.*\n">
+        <token type="Comment"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cobol.xml

@@ -0,0 +1,90 @@
+<lexer>
+  <config>
+    <name>COBOL</name>
+    <alias>cobol</alias>
+    <filename>*.cob</filename>
+    <filename>*.COB</filename>
+    <filename>*.cpy</filename>
+    <filename>*.CPY</filename>
+    <mime_type>text/x-cobol</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="strings">
+      <rule pattern="&#34;[^&#34;\n]*(&#34;|\n)">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#39;[^&#39;\n]*(&#39;|\n)">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+    <state name="nums">
+      <rule pattern="\d+(\s*|\.$|$)">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[+-]?\d*\.\d+(E[-+]?\d+)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[+-]?\d+\.\d*(E[-+]?\d+)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="comment"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+      <rule>
+        <include state="core"/>
+      </rule>
+      <rule>
+        <include state="nums"/>
+      </rule>
+      <rule pattern="[a-z0-9]([\w\-]*[a-z0-9]+)?">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[ \t]+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="comment">
+      <rule pattern="(^.{6}[*/].*\n|^.{6}|\*&gt;.*\n)">
+        <token type="Comment"/>
+      </rule>
+    </state>
+    <state name="core">
+      <rule pattern="(^|(?&lt;=[^\w\-]))(ALL\s+)?((ZEROES)|(HIGH-VALUE|LOW-VALUE|QUOTE|SPACE|ZERO)(S)?)\s*($|(?=[^\w\-]))">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=[^\w\-]))(WORKING-STORAGE|IDENTIFICATION|LOCAL-STORAGE|CONFIGURATION|END-EVALUATE|FILE-CONTROL|END-UNSTRING|END-SUBTRACT|END-MULTIPLY|INPUT-OUTPUT|END-PERFORM|END-DISPLAY|END-OF-PAGE|END-COMPUTE|ENVIRONMENT|I-O-CONTROL|END-REWRITE|END-RETURN|INITIALIZE|END-ACCEPT|END-DIVIDE|PROGRAM-ID|END-STRING|END-DELETE|END-SEARCH|END-WRITE|PROCEDURE|END-START|TERMINATE|END-READ|MULTIPLY|CONTINUE|SUPPRESS|SUBTRACT|INITIATE|UNSTRING|DIVISION|VALIDATE|END-CALL|ALLOCATE|GENERATE|EVALUATE|PERFORM|FOREVER|LINKAGE|END-ADD|REWRITE|INSPECT|SECTION|RELEASE|COMPUTE|DISPLAY|END-IF|GOBACK|INVOKE|CANCEL|UNLOCK|SCREEN|SEARCH|DELETE|STRING|DIVIDE|ACCEPT|RETURN|RESUME|START|RAISE|MERGE|CLOSE|WRITE|FILE|STOP|FREE|READ|ELSE|THEN|SORT|EXIT|OPEN|CALL|MOVE|DATA|END|SET|ADD|USE|GO|FD|SD|IF)\s*($|(?=[^\w\-]))">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=[^\w\-]))(ALPHANUMERIC-EDITED|PROCEDURE-POINTER|ENVIRONMENT-VALUE|ENVIRONMENT-NAME|ALPHABETIC-UPPER|FOREGROUND-COLOR|ALPHABETIC-LOWER|BACKGROUND-COLOR|OBJECT-COMPUTER|SOURCE-COMPUTER|PROGRAM-POINTER|ARGUMENT-NUMBER|NATIONAL-EDITED|NUMERIC-EDITED|LINAGE-COUNTER|UNSIGNED-SHORT|ARGUMENT-VALUE|PACKED-DECIMAL|SPECIAL-NAMES|AUTOTERMINATE|DECIMAL-POINT|CORRESPONDING|UNSIGNED-LONG|SEGMENT-LIMIT|REVERSE-VIDEO|SIGNED-SHORT|SYNCHRONIZED|ALPHANUMERIC|ALTERNATEANY|UNSIGNED-INT|ORGANIZATION|DECLARATIVES|COMMAND-LINE|FUNCTION-ID|SIGNED-LONG|INITIALIZED|FLOAT-SHORT|BYTE-LENGTH|DAY-OF-WEEK|DESCENDING|CHARACTERS|SEQUENTIAL|REPOSITORY|SIGNED-INT|SORT-MERGE|DUPLICATES|STANDARD-1|STANDARD-2|CONVERTING|FLOAT-LONG|ALPHABETIC|PROCEDURES|RECORDING|HIGHLIGHT|ADVANCING|RETURNING|REPLACING|UNDERLINE|TRANSFORM|REMAINDER|INTRINSIC|JUSTIFIED|REFERENCE|REDEFINES|EXCLUSIVE|RECURSIVE|EXCEPTION|COLLATING|ASCENDING|REPORTING|AUTO-SKIP|DEBUGGING|AUTOMATIC|CHARACTER|PARAGRAPH|DELIMITED|DELIMITER|DEPENDING|PREVIOUS|POSITIVE|POSITION|CHAINING|STANDARD|FUNCTION|OVERFLOW|PRINTING|CODE-SET|SEPARATE|OPTIONAL|SYMBOLIC|SEQUENCE|NEGATIVE|TALLYING|NATIONAL|REQUIRED|CURRENCY|MULTIPLE|TRAILING|LOWLIGHT|OVERLINE|SENTENCE|RELATIVE|ROLLBACK|CONTROLS|UNSIGNED|INDICATE|IGNORING|ALPHABET|CONTAINS|CONSTANT|EXTERNAL|YYYYMMDD|FILE-ID|CONTROL|RENAMES|REMOVAL|HEADING|YYYYDDD|RESERVE|VARYING|RECORDS|REPORTS|COLUMNS|PROGRAM|INDEXED|FOOTING|INITIAL|PROCEED|ROUNDED|DEFAULT|PRESENT|INVALID|POINTER|SHARING|PADDING|DYNAMIC|OMITTED|ADDRESS|LEADING|CONTENT|NUMBERS|THROUGH|NUMERIC|PRINTER|SELECT|COMMON|REPORT|LOCALE|ACCESS|LINAGE|MANUAL|MEMORY|LIMITS|FILLER|EXTEND|ESCAPE|GIVING|NATIVE|GLOBAL|COMMIT|ASSIGN|STATUS|OUTPUT|NUMBER|LENGTH|REWIND|CURSOR|BEFORE|OCCURS|SOURCE|IGNORE|VALUES|RECORD|BOTTOM|SIGNED|RANDOM|QUOTES|PROMPT|SCROLL|EBCDIC|FORMAT|SECURE|DETAIL|UPDATE|COLUMN|TIMES|USAGE|CLASS|FINAL|FIRST|USING|CYCLE|UNTIL|MINUS|INPUT|FIXED|INDEX|VALUE|OTHER|QUOTE|ENTRY|ORDER|RIGHT|BLOCK|LABEL|BLINK|BASED|AFTER|NULLS|COUNT|AREAS|WORDS|GROUP|ERASE|LIMIT|LINES|ALTER|COMMA|ERROR|BLANK|THRU|CORR|REEL|FROM|WITH|DATE|WHEN|CODE|SAME|WAIT|COPY|DISK|PLUS|COLS|INTO|UPON|DOWN|PAGE|SIGN|JUST|ONLY|LAST|ALSO|SIZE|UNIT|LINE|BELL|TYPE|BEEP|LOCK|AUTO|NULL|AREA|MODE|SYNC|TIME|NEXT|TAPE|TEST|FULL|LEFT|EOL|CRT|I-O|TOP|DAY|EOS|EOP|FOR|ARE|OFF|ALL|COL|SUM|KEY|RUN|UP|ON|IS|IN|BY|OF|ID|DE|AT|RD|TO|NO|AS)\s*($|(?=[^\w\-]))">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=[^\w\-]))(REPRESENTS-NOT-A-NUMBER|FUNCTION-POINTER|FLOAT-DECIMAL-34|FLOAT-DECIMAL-16|ENTRY-CONVENTION|EXCEPTION-OBJECT|OBJECT-REFERENCE|FLOAT-BINARY-34|FLOAT-BINARY-16|VALIDATE-STATUS|FLOAT-EXTENDED|CLASSIFICATION|FLOAT-BINARY-7|SYSTEM-DEFAULT|COMMUNICATION|PAGE-COUNTER|USER-DEFAULT|LINE-COUNTER|ACTIVE-CLASS|DATA-POINTER|INTERFACE-ID|DESTINATION|GROUP-USAGE|LC_MESSAGES|SUB-QUEUE-3|SUB-QUEUE-2|SUB-QUEUE-1|END-RECEIVE|LC_MONETARY|VAL-STATUS|LC_NUMERIC|IMPLEMENTS|LC_COLLATE|ARITHMETIC|STATEMENT|METHOD-ID|INTERFACE|ATTRIBUTE|PROTOTYPE|CONDITION|UNIVERSAL|LC_CTYPE|VALIDATE|PROPERTY|TERMINAL|INFINITY|INHERITS|CLASS-ID|RELATION|OVERRIDE|ANYCASE|DISABLE|ALIGNED|REPLACE|RAISING|EXPANDS|FACTORY|TYPEDEF|MESSAGE|RECEIVE|BOOLEAN|SECONDS|SOURCES|SEGMENT|LC_TIME|OPTIONS|METHOD|UTF-16|OBJECT|NORMAL|NESTED|CENTER|LC_ALL|RESUME|INVOKE|ENABLE|STRONG|FORMAT|SYMBOL|B-XOR|QUEUE|RESET|PURGE|RETRY|B-AND|VALID|B-NOT|UTF-8|SUPER|RAISE|UCS-4|TABLE|CHAIN|NONE|B-OR|STEP|SEND|SELF|TEXT|BIT|EMI|ESI|EGI|GET|CD|CF|EC|EO|PF|PH|RH|RF|CH)\s*($|(?=[^\w\-]))">
+        <token type="Error"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=[^\w\-]))(PIC\s+.+?(?=(\s|\.\s))|PICTURE\s+.+?(?=(\s|\.\s))|(COMPUTATIONAL)(-[1-5X])?|(COMP)(-[1-5X])?|BINARY-C-LONG|BINARY-CHAR|BINARY-DOUBLE|BINARY-LONG|BINARY-SHORT|BINARY)\s*($|(?=[^\w\-]))">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(\*\*|\*|\+|-|/|&lt;=|&gt;=|&lt;|&gt;|==|/=|=)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="([(),;:&amp;%.])">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=[^\w\-]))(ABS|ACOS|ANNUITY|ASIN|ATAN|BYTE-LENGTH|CHAR|COMBINED-DATETIME|CONCATENATE|COS|CURRENT-DATE|DATE-OF-INTEGER|DATE-TO-YYYYMMDD|DAY-OF-INTEGER|DAY-TO-YYYYDDD|EXCEPTION-(?:FILE|LOCATION|STATEMENT|STATUS)|EXP10|EXP|E|FACTORIAL|FRACTION-PART|INTEGER-OF-(?:DATE|DAY|PART)|INTEGER|LENGTH|LOCALE-(?:DATE|TIME(?:-FROM-SECONDS)?)|LOG(?:10)?|LOWER-CASE|MAX|MEAN|MEDIAN|MIDRANGE|MIN|MOD|NUMVAL(?:-C)?|ORD(?:-MAX|-MIN)?|PI|PRESENT-VALUE|RANDOM|RANGE|REM|REVERSE|SECONDS-FROM-FORMATTED-TIME|SECONDS-PAST-MIDNIGHT|SIGN|SIN|SQRT|STANDARD-DEVIATION|STORED-CHAR-LENGTH|SUBSTITUTE(?:-CASE)?|SUM|TAN|TEST-DATE-YYYYMMDD|TEST-DAY-YYYYDDD|TRIM|UPPER-CASE|VARIANCE|WHEN-COMPILED|YEAR-TO-YYYY)\s*($|(?=[^\w\-]))">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=[^\w\-]))(true|false)\s*($|(?=[^\w\-]))">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(^|(?&lt;=[^\w\-]))(equal|equals|ne|lt|le|gt|ge|greater|less|than|not|and|or)\s*($|(?=[^\w\-]))">
+        <token type="OperatorWord"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/coffeescript.xml

@@ -0,0 +1,210 @@
+<lexer>
+  <config>
+    <name>CoffeeScript</name>
+    <alias>coffee-script</alias>
+    <alias>coffeescript</alias>
+    <alias>coffee</alias>
+    <filename>*.coffee</filename>
+    <mime_type>text/coffeescript</mime_type>
+    <dot_all>true</dot_all>
+    <not_multiline>true</not_multiline>
+  </config>
+  <rules>
+    <state name="commentsandwhitespace">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="###[^#].*?###">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="#(?!##[^#]).*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+    </state>
+    <state name="multilineregex">
+      <rule pattern="[^/#]+">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="///([gim]+\b|\B)">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="#\{">
+        <token type="LiteralStringInterpol"/>
+        <push state="interpoling_string"/>
+      </rule>
+      <rule pattern="[/#]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+    </state>
+    <state name="slashstartsregex">
+      <rule>
+        <include state="commentsandwhitespace"/>
+      </rule>
+      <rule pattern="///">
+        <token type="LiteralStringRegex"/>
+        <push state="#pop" state="multilineregex"/>
+      </rule>
+      <rule pattern="/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="/">
+        <token type="Operator"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="tsqs">
+      <rule pattern="&#39;&#39;&#39;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="#|\\.|\&#39;|&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+    </state>
+    <state name="dqs">
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\.|\&#39;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="#\{">
+        <token type="LiteralStringInterpol"/>
+        <push state="interpoling_string"/>
+      </rule>
+      <rule pattern="#">
+        <token type="LiteralString"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+    </state>
+    <state name="sqs">
+      <rule pattern="&#39;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="#|\\.|&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+    </state>
+    <state name="tdqs">
+      <rule pattern="&#34;&#34;&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\.|\&#39;|&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="#\{">
+        <token type="LiteralStringInterpol"/>
+        <push state="interpoling_string"/>
+      </rule>
+      <rule pattern="#">
+        <token type="LiteralString"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="commentsandwhitespace"/>
+      </rule>
+      <rule pattern="^(?=\s|/)">
+        <token type="Text"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="\+\+|~|&amp;&amp;|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|\|\||\\(?=\n)|(&lt;&lt;|&gt;&gt;&gt;?|==?(?!&gt;)|!=?|=(?!&gt;)|-(?!&gt;)|[&lt;&gt;+*`%&amp;\|\^/])=?">
+        <token type="Operator"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="(?:\([^()]*\))?\s*[=-]&gt;">
+        <token type="NameFunction"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="[{(\[;,]">
+        <token type="Punctuation"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="[})\].]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(?&lt;![.$])(for|own|in|of|while|until|loop|break|return|continue|switch|when|then|if|unless|else|throw|try|catch|finally|new|delete|typeof|instanceof|super|extends|this|class|by)\b">
+        <token type="Keyword"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="(?&lt;![.$])(true|false|yes|no|on|off|null|NaN|Infinity|undefined)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="[$a-zA-Z_][\w.:$]*\s*[:=]\s">
+        <token type="NameVariable"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="@[$a-zA-Z_][\w.:$]*\s*[:=]\s">
+        <token type="NameVariableInstance"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="@">
+        <token type="NameOther"/>
+        <push state="slashstartsregex"/>
+      </rule>
+      <rule pattern="@?[$a-zA-Z_][\w$]*">
+        <token type="NameOther"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0x[0-9a-fA-F]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;&#34;&#34;">
+        <token type="LiteralString"/>
+        <push state="tdqs"/>
+      </rule>
+      <rule pattern="&#39;&#39;&#39;">
+        <token type="LiteralString"/>
+        <push state="tsqs"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="dqs"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralString"/>
+        <push state="sqs"/>
+      </rule>
+    </state>
+    <state name="interpoling_string">
+      <rule pattern="\}">
+        <token type="LiteralStringInterpol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="strings">
+      <rule pattern="[^#\\\&#39;&#34;]+">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/common_lisp.xml

@@ -0,0 +1,184 @@
+<lexer>
+  <config>
+    <name>Common Lisp</name>
+    <alias>common-lisp</alias>
+    <alias>cl</alias>
+    <alias>lisp</alias>
+    <filename>*.cl</filename>
+    <filename>*.lisp</filename>
+    <mime_type>text/x-common-lisp</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="body">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="#\|">
+        <token type="CommentMultiline"/>
+        <push state="multiline-comment"/>
+      </rule>
+      <rule pattern="#\d*Y.*$">
+        <token type="CommentSpecial"/>
+      </rule>
+      <rule pattern="&#34;(\\.|\\\n|[^&#34;\\])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern=":(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="::(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern=":#(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="&#39;(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="`">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[-+]?\d+\.?(?=[ &#34;()\&#39;\n,;`])">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[-+]?\d+/\d+(?=[ &#34;()\&#39;\n,;`])">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[-+]?(\d*\.\d+([defls][-+]?\d+)?|\d+(\.\d*)?[defls][-+]?\d+)(?=[ &#34;()\&#39;\n,;`])">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="#\\.(?=[ &#34;()\&#39;\n,;`])">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="#\\(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="#\(">
+        <token type="Operator"/>
+        <push state="body"/>
+      </rule>
+      <rule pattern="#\d*\*[01]*">
+        <token type="LiteralOther"/>
+      </rule>
+      <rule pattern="#:(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="#[.,]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="#\&#39;">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="#b[+-]?[01]+(/[01]+)?">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="#o[+-]?[0-7]+(/[0-7]+)?">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="#x[+-]?[0-9a-f]+(/[0-9a-f]+)?">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="#\d+r[+-]?[0-9a-z]+(/[0-9a-z]+)?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="(#c)(\()">
+        <bygroups>
+          <token type="LiteralNumber"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="body"/>
+      </rule>
+      <rule pattern="(#\d+a)(\()">
+        <bygroups>
+          <token type="LiteralOther"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="body"/>
+      </rule>
+      <rule pattern="(#s)(\()">
+        <bygroups>
+          <token type="LiteralOther"/>
+          <token type="Punctuation"/>
+        </bygroups>
+        <push state="body"/>
+      </rule>
+      <rule pattern="#p?&#34;(\\.|[^&#34;])*&#34;">
+        <token type="LiteralOther"/>
+      </rule>
+      <rule pattern="#\d+=">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="#\d+#">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="#+nil(?=[ &#34;()\&#39;\n,;`])\s*\(">
+        <token type="CommentPreproc"/>
+        <push state="commented-form"/>
+      </rule>
+      <rule pattern="#[+-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(,@|,|\.)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(t|nil)(?=[ &#34;()\&#39;\n,;`])">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="\*(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)\*">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="(\|[^|]+\||(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@\[\]^{}~]|[#.:])*)">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="body"/>
+      </rule>
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <push state="body"/>
+      </rule>
+    </state>
+    <state name="multiline-comment">
+      <rule pattern="#\|">
+        <token type="CommentMultiline"/>
+        <push/>
+      </rule>
+      <rule pattern="\|#">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^|#]+">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="[|#]">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="commented-form">
+      <rule pattern="\(">
+        <token type="CommentPreproc"/>
+        <push/>
+      </rule>
+      <rule pattern="\)">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^()]+">
+        <token type="CommentPreproc"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/coq.xml

@@ -0,0 +1,136 @@
+<lexer>
+  <config>
+    <name>Coq</name>
+    <alias>coq</alias>
+    <filename>*.v</filename>
+    <mime_type>text/x-coq</mime_type>
+  </config>
+  <rules>
+    <state name="string">
+      <rule pattern="[^&#34;]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="dotted">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\.">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[A-Z][\w\&#39;]*(?=\s*\.)">
+        <token type="NameNamespace"/>
+      </rule>
+      <rule pattern="[A-Z][\w\&#39;]*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[a-z][a-z0-9_\&#39;]*">
+        <token type="Name"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="false|true|\(\)|\[\]">
+        <token type="NameBuiltinPseudo"/>
+      </rule>
+      <rule pattern="\(\*">
+        <token type="Comment"/>
+        <push state="comment"/>
+      </rule>
+      <rule pattern="\b(Projections|Monomorphic|Polymorphic|Proposition|CoInductive|Hypothesis|CoFixpoint|Contextual|Definition|Parameters|Hypotheses|Structure|Inductive|Corollary|Implicits|Parameter|Variables|Arguments|Canonical|Printing|Coercion|Reserved|Universe|Notation|Instance|Fixpoint|Variable|Morphism|Relation|Existing|Implicit|Example|Theorem|Delimit|Defined|Rewrite|outside|Require|Resolve|Section|Context|Prenex|Strict|Module|Import|Export|Global|inside|Remark|Tactic|Search|Record|Scope|Unset|Check|Local|Close|Class|Graph|Proof|Lemma|Print|Axiom|Show|Goal|Open|Fact|Hint|Bind|Ltac|Save|View|Let|Set|All|End|Qed)\b">
+        <token type="KeywordNamespace"/>
+      </rule>
+      <rule pattern="\b(exists2|nosimpl|struct|exists|return|forall|match|cofix|then|with|else|for|fix|let|fun|end|is|of|if|in|as)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(Type|Prop)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="\b(native_compute|setoid_rewrite|etransitivity|econstructor|transitivity|autorewrite|constructor|cutrewrite|vm_compute|bool_congr|generalize|inversion|induction|injection|nat_congr|intuition|destruct|suffices|erewrite|symmetry|nat_norm|replace|rewrite|compute|pattern|trivial|without|assert|unfold|change|eapply|intros|unlock|revert|rename|refine|eauto|tauto|after|right|congr|split|field|simpl|intro|clear|apply|using|subst|case|left|suff|loss|wlog|have|fold|ring|move|lazy|elim|pose|auto|red|cbv|hnf|cut|set)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(contradiction|discriminate|reflexivity|assumption|congruence|romega|omega|exact|solve|tauto|done|by)\b">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="\b(repeat|first|idtac|last|try|do)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="\b([A-Z][\w\&#39;]*)">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="(λ|Π|\|\}|\{\||\\/|/\\|=&gt;|~|\}|\|]|\||\{&lt;|\{|`|_|]|\[\||\[&gt;|\[&lt;|\[|\?\?|\?|&gt;\}|&gt;]|&gt;|=|&lt;-&gt;|&lt;-|&lt;|;;|;|:&gt;|:=|::|:|\.\.|\.|-&gt;|-\.|-|,|\+|\*|\)|\(|&amp;&amp;|&amp;|#|!=)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="([=&lt;&gt;@^|&amp;+\*/$%-]|[!?~])?[!$%&amp;*+\./:&lt;=&gt;?@^|~-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\b(unit|nat|bool|string|ascii|list)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="[^\W\d][\w&#39;]*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="\d[\d_]*">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="0[xX][\da-fA-F][\da-fA-F_]*">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="0[oO][0-7][0-7_]*">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0[bB][01][01_]*">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="&#39;(?:(\\[\\\&#34;&#39;ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="&#39;.&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="[~?][a-z][\w\&#39;]*:">
+        <token type="Name"/>
+      </rule>
+    </state>
+    <state name="comment">
+      <rule pattern="[^(*)]+">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="\(\*">
+        <token type="Comment"/>
+        <push/>
+      </rule>
+      <rule pattern="\*\)">
+        <token type="Comment"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[(*)]">
+        <token type="Comment"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/crystal.xml

@@ -0,0 +1,762 @@
+<lexer>
+  <config>
+    <name>Crystal</name>
+    <alias>cr</alias>
+    <alias>crystal</alias>
+    <filename>*.cr</filename>
+    <mime_type>text/x-crystal</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="pa-intp-string">
+      <rule pattern="\\[\(]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="\)">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp-escaped"/>
+      </rule>
+      <rule pattern="[\\#()]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#()]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="ab-regex">
+      <rule pattern="\\[\\&lt;&gt;]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="&lt;">
+        <token type="LiteralStringRegex"/>
+        <push/>
+      </rule>
+      <rule pattern="&gt;[imsx]*">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule pattern="[\\#&lt;&gt;]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[^\\#&lt;&gt;]+">
+        <token type="LiteralStringRegex"/>
+      </rule>
+    </state>
+    <state name="cb-regex">
+      <rule pattern="\\[\\{}]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="LiteralStringRegex"/>
+        <push/>
+      </rule>
+      <rule pattern="\}[imsx]*">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule pattern="[\\#{}]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[^\\#{}]+">
+        <token type="LiteralStringRegex"/>
+      </rule>
+    </state>
+    <state name="simple-backtick">
+      <rule>
+        <include state="string-intp-escaped"/>
+      </rule>
+      <rule pattern="[^\\`#]+">
+        <token type="LiteralStringBacktick"/>
+      </rule>
+      <rule pattern="[\\#]">
+        <token type="LiteralStringBacktick"/>
+      </rule>
+      <rule pattern="`">
+        <token type="LiteralStringBacktick"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="string-intp">
+      <rule pattern="#\{">
+        <token type="LiteralStringInterpol"/>
+        <push state="in-intp"/>
+      </rule>
+    </state>
+    <state name="interpolated-regex">
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule pattern="[\\#]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[^\\#]+">
+        <token type="LiteralStringRegex"/>
+      </rule>
+    </state>
+    <state name="cb-string">
+      <rule pattern="\\[\\{}]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[\\#{}]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#{}]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="in-macro-control">
+      <rule pattern="\{%">
+        <token type="LiteralStringInterpol"/>
+        <push/>
+      </rule>
+      <rule pattern="%\}">
+        <token type="LiteralStringInterpol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="for\b|in\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="interpolated-string">
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule pattern="[\\#]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="in-macro-expr">
+      <rule pattern="\{\{">
+        <token type="LiteralStringInterpol"/>
+        <push/>
+      </rule>
+      <rule pattern="\}\}">
+        <token type="LiteralStringInterpol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="simple-string">
+      <rule>
+        <include state="string-intp-escaped"/>
+      </rule>
+      <rule pattern="[^\\&#34;#]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="[\\#]">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="cb-intp-string">
+      <rule pattern="\\[\{]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp-escaped"/>
+      </rule>
+      <rule pattern="[\\#{}]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#{}]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="string-intp-escaped">
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule>
+        <include state="string-escaped"/>
+      </rule>
+    </state>
+    <state name="sb-regex">
+      <rule pattern="\\[\\\[\]]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="\[">
+        <token type="LiteralStringRegex"/>
+        <push/>
+      </rule>
+      <rule pattern="\][imsx]*">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule pattern="[\\#\[\]]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[^\\#\[\]]+">
+        <token type="LiteralStringRegex"/>
+      </rule>
+    </state>
+    <state name="classname">
+      <rule pattern="[A-Z_]\w*">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="(\()(\s*)([A-Z_]\w*)(\s*)(\))">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="string-escaped">
+      <rule pattern="\\([\\befnstv#&#34;\&#39;]|x[a-fA-F0-9]{1,2}|[0-7]{1,3})">
+        <token type="LiteralStringEscape"/>
+      </rule>
+    </state>
+    <state name="sb-intp-string">
+      <rule pattern="\\[\[]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\[">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="\]">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp-escaped"/>
+      </rule>
+      <rule pattern="[\\#\[\]]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#\[\]]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="pa-regex">
+      <rule pattern="\\[\\()]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="LiteralStringRegex"/>
+        <push/>
+      </rule>
+      <rule pattern="\)[imsx]*">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule pattern="[\\#()]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[^\\#()]+">
+        <token type="LiteralStringRegex"/>
+      </rule>
+    </state>
+    <state name="in-attr">
+      <rule pattern="\[">
+        <token type="Operator"/>
+        <push/>
+      </rule>
+      <rule pattern="\]">
+        <token type="Operator"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="ab-intp-string">
+      <rule pattern="\\[&lt;]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&lt;">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="&gt;">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="string-intp-escaped"/>
+      </rule>
+      <rule pattern="[\\#&lt;&gt;]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#&lt;&gt;]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="in-intp">
+      <rule pattern="\{">
+        <token type="LiteralStringInterpol"/>
+        <push/>
+      </rule>
+      <rule pattern="\}">
+        <token type="LiteralStringInterpol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="end-part">
+      <rule pattern=".+">
+        <token type="CommentPreproc"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="#.*?$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="(instance_sizeof|pointerof|protected|abstract|require|private|include|unless|typeof|sizeof|return|extend|ensure|rescue|ifdef|super|break|begin|until|while|elsif|yield|next|when|else|then|case|with|end|asm|if|do|as|of)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(false|true|nil)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(module|lib)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(def|fun|macro)(\s+)((?:[a-zA-Z_]\w*::)*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+        </bygroups>
+        <push state="funcname"/>
+      </rule>
+      <rule pattern="def(?=[*%&amp;^`~+-/\[&lt;&gt;=])">
+        <token type="Keyword"/>
+        <push state="funcname"/>
+      </rule>
+      <rule pattern="(class|struct|union|type|alias|enum)(\s+)((?:[a-zA-Z_]\w*::)*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+        </bygroups>
+        <push state="classname"/>
+      </rule>
+      <rule pattern="(self|out|uninitialized)\b|(is_a|responds_to)\?">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="(def_equals_and_hash|assert_responds_to|forward_missing_to|def_equals|property|def_hash|parallel|delegate|debugger|getter|record|setter|spawn|pp)\b">
+        <token type="NameBuiltinPseudo"/>
+      </rule>
+      <rule pattern="getter[!?]|property[!?]|__(DIR|FILE|LINE)__\b">
+        <token type="NameBuiltinPseudo"/>
+      </rule>
+      <rule pattern="(?&lt;!\.)(get_stack_top|StaticArray|Concurrent|with_color|Reference|Scheduler|read_line|Exception|at_exit|Pointer|Channel|Float64|sprintf|Float32|Process|Object|Struct|caller|UInt16|UInt32|UInt64|system|future|Number|printf|String|Symbol|Int32|Range|Slice|Regex|Mutex|sleep|Array|Class|raise|Tuple|Deque|delay|Float|Int16|print|abort|Value|UInt8|Int64|puts|Proc|File|Void|exit|fork|Bool|Char|gets|lazy|loop|main|rand|Enum|Int8|Time|Hash|Set|Box|Nil|Dir|Int|p)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(?&lt;!\w)(&lt;&lt;-?)([&#34;`\&#39;]?)([a-zA-Z_]\w*)(\2)(.*?\n)">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule pattern="(&lt;&lt;-?)(&#34;|\&#39;)()(\2)(.*?\n)">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule pattern="__END__">
+        <token type="CommentPreproc"/>
+        <push state="end-part"/>
+      </rule>
+      <rule pattern="(?:^|(?&lt;=[=&lt;&gt;~!:])|(?&lt;=(?:\s|;)when\s)|(?&lt;=(?:\s|;)or\s)|(?&lt;=(?:\s|;)and\s)|(?&lt;=\.index\s)|(?&lt;=\.scan\s)|(?&lt;=\.sub\s)|(?&lt;=\.sub!\s)|(?&lt;=\.gsub\s)|(?&lt;=\.gsub!\s)|(?&lt;=\.match\s)|(?&lt;=(?:\s|;)if\s)|(?&lt;=(?:\s|;)elsif\s)|(?&lt;=^when\s)|(?&lt;=^index\s)|(?&lt;=^scan\s)|(?&lt;=^sub\s)|(?&lt;=^gsub\s)|(?&lt;=^sub!\s)|(?&lt;=^gsub!\s)|(?&lt;=^match\s)|(?&lt;=^if\s)|(?&lt;=^elsif\s))(\s*)(/)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="LiteralStringRegex"/>
+        </bygroups>
+        <push state="multiline-regex"/>
+      </rule>
+      <rule pattern="(?&lt;=\(|,|\[)/">
+        <token type="LiteralStringRegex"/>
+        <push state="multiline-regex"/>
+      </rule>
+      <rule pattern="(\s+)(/)(?![\s=])">
+        <bygroups>
+          <token type="Text"/>
+          <token type="LiteralStringRegex"/>
+        </bygroups>
+        <push state="multiline-regex"/>
+      </rule>
+      <rule pattern="(0o[0-7]+(?:_[0-7]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?">
+        <bygroups>
+          <token type="LiteralNumberOct"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?">
+        <bygroups>
+          <token type="LiteralNumberHex"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(0b[01]+(?:_[01]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?">
+        <bygroups>
+          <token type="LiteralNumberBin"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)(?:e[+-]?[0-9]+)?(?:_?f[0-9]+)?)(\s*)([/?])?">
+        <bygroups>
+          <token type="LiteralNumberFloat"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)?(?:e[+-]?[0-9]+)(?:_?f[0-9]+)?)(\s*)([/?])?">
+        <bygroups>
+          <token type="LiteralNumberFloat"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)?(?:e[+-]?[0-9]+)?(?:_?f[0-9]+))(\s*)([/?])?">
+        <bygroups>
+          <token type="LiteralNumberFloat"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(0\b|[1-9][\d]*(?:_\d+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?">
+        <bygroups>
+          <token type="LiteralNumberInteger"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="@@[a-zA-Z_]\w*">
+        <token type="NameVariableClass"/>
+      </rule>
+      <rule pattern="@[a-zA-Z_]\w*">
+        <token type="NameVariableInstance"/>
+      </rule>
+      <rule pattern="\$\w+">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="\$[!@&amp;`\&#39;+~=/\\,;.&lt;&gt;_*$?:&#34;^-]">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="\$-[0adFiIlpvw]">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="::">
+        <token type="Operator"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+      <rule pattern="\?(\\[MC]-)*(\\([\\befnrtv#&#34;\&#39;]|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)(?!\w)">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="[A-Z][A-Z_]+\b">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="\{%">
+        <token type="LiteralStringInterpol"/>
+        <push state="in-macro-control"/>
+      </rule>
+      <rule pattern="\{\{">
+        <token type="LiteralStringInterpol"/>
+        <push state="in-macro-expr"/>
+      </rule>
+      <rule pattern="(@\[)(\s*)([A-Z]\w*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <token type="NameDecorator"/>
+        </bygroups>
+        <push state="in-attr"/>
+      </rule>
+      <rule pattern="(\.|::)(\[\]\?|&lt;=&gt;|===|\[\]=|&gt;&gt;|&amp;&amp;|\*\*|\[\]|\|\||&gt;=|=~|!~|&lt;&lt;|&lt;=|!=|==|&lt;|/|=|-|\+|&gt;|\*|&amp;|%|\^|!|\||~)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameOperator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\.|::)([a-zA-Z_]\w*[!?]?|[*%&amp;^`~+\-/\[&lt;&gt;=])">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Name"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*(?:[!?](?!=))?">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="(\[|\]\??|\*\*|&lt;=&gt;?|&gt;=|&lt;&lt;?|&gt;&gt;?|=~|===|!~|&amp;&amp;?|\|\||\.{1,3})">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[-+/*%=&lt;&gt;&amp;!^|~]=?">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[(){};,/?:\\]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="multiline-regex">
+      <rule>
+        <include state="string-intp"/>
+      </rule>
+      <rule pattern="\\\\">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="\\/">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[\\#]">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="[^\\/#]+">
+        <token type="LiteralStringRegex"/>
+      </rule>
+      <rule pattern="/[imsx]*">
+        <token type="LiteralStringRegex"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="ab-string">
+      <rule pattern="\\[\\&lt;&gt;]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&lt;">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="&gt;">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[\\#&lt;&gt;]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#&lt;&gt;]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="pa-string">
+      <rule pattern="\\[\\()]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="\)">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[\\#()]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#()]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="strings">
+      <rule pattern="\:@{0,2}[a-zA-Z_]\w*[!?]?">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="\:@{0,2}(\[\]\?|&lt;=&gt;|===|\[\]=|&gt;&gt;|&amp;&amp;|\*\*|\[\]|\|\||&gt;=|=~|!~|&lt;&lt;|&lt;=|!=|==|&lt;|/|=|-|\+|&gt;|\*|&amp;|%|\^|!|\||~)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern=":&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;]|\\[^&#39;\\]+)&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern=":&#34;">
+        <token type="LiteralStringSymbol"/>
+        <push state="simple-sym"/>
+      </rule>
+      <rule pattern="([a-zA-Z_]\w*)(:)(?!:)">
+        <bygroups>
+          <token type="LiteralStringSymbol"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="simple-string"/>
+      </rule>
+      <rule pattern="(?&lt;!\.)`">
+        <token type="LiteralStringBacktick"/>
+        <push state="simple-backtick"/>
+      </rule>
+      <rule pattern="%\{">
+        <token type="LiteralStringOther"/>
+        <push state="cb-intp-string"/>
+      </rule>
+      <rule pattern="%[wi]\{">
+        <token type="LiteralStringOther"/>
+        <push state="cb-string"/>
+      </rule>
+      <rule pattern="%r\{">
+        <token type="LiteralStringRegex"/>
+        <push state="cb-regex"/>
+      </rule>
+      <rule pattern="%\[">
+        <token type="LiteralStringOther"/>
+        <push state="sb-intp-string"/>
+      </rule>
+      <rule pattern="%[wi]\[">
+        <token type="LiteralStringOther"/>
+        <push state="sb-string"/>
+      </rule>
+      <rule pattern="%r\[">
+        <token type="LiteralStringRegex"/>
+        <push state="sb-regex"/>
+      </rule>
+      <rule pattern="%\(">
+        <token type="LiteralStringOther"/>
+        <push state="pa-intp-string"/>
+      </rule>
+      <rule pattern="%[wi]\(">
+        <token type="LiteralStringOther"/>
+        <push state="pa-string"/>
+      </rule>
+      <rule pattern="%r\(">
+        <token type="LiteralStringRegex"/>
+        <push state="pa-regex"/>
+      </rule>
+      <rule pattern="%&lt;">
+        <token type="LiteralStringOther"/>
+        <push state="ab-intp-string"/>
+      </rule>
+      <rule pattern="%[wi]&lt;">
+        <token type="LiteralStringOther"/>
+        <push state="ab-string"/>
+      </rule>
+      <rule pattern="%r&lt;">
+        <token type="LiteralStringRegex"/>
+        <push state="ab-regex"/>
+      </rule>
+      <rule pattern="(%r([\W_]))((?:\\\2|(?!\2).)*)(\2[imsx]*)">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="(%[wi]([\W_]))((?:\\\2|(?!\2).)*)(\2)">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="(?&lt;=[-+/*%=&lt;&gt;&amp;!^|~,(])(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="LiteralStringOther"/>
+          <token type="None"/>
+        </bygroups>
+      </rule>
+      <rule pattern="^(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="LiteralStringOther"/>
+          <token type="None"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(%([\[{(&lt;]))((?:\\\2|(?!\2).)*)(\2)">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="sb-string">
+      <rule pattern="\\[\\\[\]]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\[">
+        <token type="LiteralStringOther"/>
+        <push/>
+      </rule>
+      <rule pattern="\]">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[\\#\[\]]">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="[^\\#\[\]]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+    </state>
+    <state name="funcname">
+      <rule pattern="(?:([a-zA-Z_]\w*)(\.))?([a-zA-Z_]\w*[!?]?|\*\*?|[-+]@?|[/%&amp;|^`~]|\[\]=?|&lt;&lt;|&gt;&gt;|&lt;=?&gt;|&gt;=?|===?)">
+        <bygroups>
+          <token type="NameClass"/>
+          <token type="Operator"/>
+          <token type="NameFunction"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="simple-sym">
+      <rule>
+        <include state="string-escaped"/>
+      </rule>
+      <rule pattern="[^\\&#34;#]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="[\\#]">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringSymbol"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cython.xml

@@ -0,0 +1,372 @@
+<lexer>
+  <config>
+    <name>Cython</name>
+    <alias>cython</alias>
+    <alias>pyx</alias>
+    <alias>pyrex</alias>
+    <filename>*.pyx</filename>
+    <filename>*.pxd</filename>
+    <filename>*.pxi</filename>
+    <mime_type>text/x-cython</mime_type>
+    <mime_type>application/x-cython</mime_type>
+  </config>
+  <rules>
+    <state name="funcname">
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameFunction"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="^(\s*)(&#34;&#34;&#34;(?:.|\n)*?&#34;&#34;&#34;)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="LiteralStringDoc"/>
+        </bygroups>
+      </rule>
+      <rule pattern="^(\s*)(&#39;&#39;&#39;(?:.|\n)*?&#39;&#39;&#39;)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="LiteralStringDoc"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="#.*$">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="[]{}:(),;[]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\\">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(in|is|and|or|not)\b">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="(&lt;)([a-zA-Z0-9.?]+)(&gt;)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="KeywordType"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="!=|==|&lt;&lt;|&gt;&gt;|[-~+/*%=&lt;&gt;&amp;^|.?]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(from)(\d+)(&lt;=)(\s+)(&lt;)(\d+)(:)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="LiteralNumberInteger"/>
+          <token type="Operator"/>
+          <token type="Name"/>
+          <token type="Operator"/>
+          <token type="Name"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <include state="keywords"/>
+      </rule>
+      <rule pattern="(def|property)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="funcname"/>
+      </rule>
+      <rule pattern="(cp?def)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="cdef"/>
+      </rule>
+      <rule pattern="(cdef)(:)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(class|struct)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="classname"/>
+      </rule>
+      <rule pattern="(from)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="fromimport"/>
+      </rule>
+      <rule pattern="(c?import)(\s+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="import"/>
+      </rule>
+      <rule>
+        <include state="builtins"/>
+      </rule>
+      <rule>
+        <include state="backtick"/>
+      </rule>
+      <rule pattern="(?:[rR]|[uU][rR]|[rR][uU])&#34;&#34;&#34;">
+        <token type="LiteralString"/>
+        <push state="tdqs"/>
+      </rule>
+      <rule pattern="(?:[rR]|[uU][rR]|[rR][uU])&#39;&#39;&#39;">
+        <token type="LiteralString"/>
+        <push state="tsqs"/>
+      </rule>
+      <rule pattern="(?:[rR]|[uU][rR]|[rR][uU])&#34;">
+        <token type="LiteralString"/>
+        <push state="dqs"/>
+      </rule>
+      <rule pattern="(?:[rR]|[uU][rR]|[rR][uU])&#39;">
+        <token type="LiteralString"/>
+        <push state="sqs"/>
+      </rule>
+      <rule pattern="[uU]?&#34;&#34;&#34;">
+        <token type="LiteralString"/>
+        <combined state="stringescape" state="tdqs"/>
+      </rule>
+      <rule pattern="[uU]?&#39;&#39;&#39;">
+        <token type="LiteralString"/>
+        <combined state="stringescape" state="tsqs"/>
+      </rule>
+      <rule pattern="[uU]?&#34;">
+        <token type="LiteralString"/>
+        <combined state="stringescape" state="dqs"/>
+      </rule>
+      <rule pattern="[uU]?&#39;">
+        <token type="LiteralString"/>
+        <combined state="stringescape" state="sqs"/>
+      </rule>
+      <rule>
+        <include state="name"/>
+      </rule>
+      <rule>
+        <include state="numbers"/>
+      </rule>
+    </state>
+    <state name="stringescape">
+      <rule pattern="\\([\\abfnrtv&#34;\&#39;]|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})">
+        <token type="LiteralStringEscape"/>
+      </rule>
+    </state>
+    <state name="strings">
+      <rule pattern="%(\([a-zA-Z0-9]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]">
+        <token type="LiteralStringInterpol"/>
+      </rule>
+      <rule pattern="[^\\\&#39;&#34;%\n]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="[\&#39;&#34;\\]">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="%">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="backtick">
+      <rule pattern="`.*?`">
+        <token type="LiteralStringBacktick"/>
+      </rule>
+    </state>
+    <state name="numbers">
+      <rule pattern="(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0\d+">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0[xX][a-fA-F0-9]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\d+L">
+        <token type="LiteralNumberIntegerLong"/>
+      </rule>
+      <rule pattern="\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+    </state>
+    <state name="keywords">
+      <rule pattern="(continue|ctypedef|except\?|include|finally|global|return|lambda|assert|except|print|nogil|while|fused|yield|break|raise|exec|else|elif|pass|with|gil|for|try|del|by|as|if)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(DEF|IF|ELIF|ELSE)\b">
+        <token type="CommentPreproc"/>
+      </rule>
+    </state>
+    <state name="fromimport">
+      <rule pattern="(\s+)(c?import)\b">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[a-zA-Z_.][\w.]*">
+        <token type="NameNamespace"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="nl">
+      <rule pattern="\n">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="dqs">
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\\\|\\&#34;|\\\n">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+    </state>
+    <state name="tsqs">
+      <rule pattern="&#39;&#39;&#39;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+      <rule>
+        <include state="nl"/>
+      </rule>
+    </state>
+    <state name="import">
+      <rule pattern="(\s+)(as)(\s+)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[a-zA-Z_][\w.]*">
+        <token type="NameNamespace"/>
+      </rule>
+      <rule pattern="(\s*)(,)(\s*)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="Operator"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="name">
+      <rule pattern="@\w+">
+        <token type="NameDecorator"/>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="Name"/>
+      </rule>
+    </state>
+    <state name="cdef">
+      <rule pattern="(public|readonly|extern|api|inline)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="(struct|enum|union|class)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="([a-zA-Z_]\w*)(\s*)(?=[(:#=]|$)">
+        <bygroups>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="([a-zA-Z_]\w*)(\s*)(,)">
+        <bygroups>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="from\b">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="as\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern=":">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?=[&#34;\&#39;])">
+        <token type="Text"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="classname">
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="sqs">
+      <rule pattern="&#39;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\\\|\\&#39;|\\\n">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+    </state>
+    <state name="tdqs">
+      <rule pattern="&#34;&#34;&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="strings"/>
+      </rule>
+      <rule>
+        <include state="nl"/>
+      </rule>
+    </state>
+    <state name="builtins">
+      <rule pattern="(?&lt;!\.)(staticmethod|classmethod|__import__|issubclass|isinstance|basestring|bytearray|raw_input|frozenset|enumerate|property|unsigned|reversed|callable|execfile|hasattr|compile|complex|delattr|setattr|unicode|globals|getattr|reload|divmod|xrange|unichr|filter|reduce|buffer|intern|coerce|sorted|locals|object|round|input|range|super|tuple|bytes|float|slice|apply|bool|long|exit|vars|file|next|type|iter|open|dict|repr|hash|list|eval|oct|map|zip|int|hex|set|sum|chr|cmp|any|str|pow|ord|dir|len|min|all|abs|max|bin|id)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(?&lt;!\.)(self|None|Ellipsis|NotImplemented|False|True|NULL)\b">
+        <token type="NameBuiltinPseudo"/>
+      </rule>
+      <rule pattern="(?&lt;!\.)(PendingDeprecationWarning|UnicodeTranslateError|NotImplementedError|FloatingPointError|DeprecationWarning|UnicodeDecodeError|UnicodeEncodeError|UnboundLocalError|KeyboardInterrupt|ZeroDivisionError|IndentationError|EnvironmentError|OverflowWarning|ArithmeticError|RuntimeWarning|UnicodeWarning|AttributeError|AssertionError|NotImplemented|ReferenceError|StopIteration|SyntaxWarning|OverflowError|GeneratorExit|FutureWarning|BaseException|ImportWarning|StandardError|RuntimeError|UnicodeError|LookupError|ImportError|SyntaxError|MemoryError|SystemError|UserWarning|SystemExit|ValueError|IndexError|NameError|TypeError|Exception|KeyError|EOFError|TabError|OSError|Warning|IOError)\b">
+        <token type="NameException"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/d.xml

@@ -0,0 +1,133 @@
+<lexer>
+  <config>
+    <name>D</name>
+    <alias>d</alias>
+    <filename>*.d</filename>
+    <filename>*.di</filename>
+    <mime_type>text/x-d</mime_type>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/\+.*?\+/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="(asm|assert|body|break|case|cast|catch|continue|default|debug|delete|do|else|finally|for|foreach|foreach_reverse|goto|if|in|invariant|is|macro|mixin|new|out|pragma|return|super|switch|this|throw|try|typeid|typeof|version|while|with)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="__(FILE|FILE_FULL_PATH|MODULE|LINE|FUNCTION|PRETTY_FUNCTION|DATE|EOF|TIME|TIMESTAMP|VENDOR|VERSION)__\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="__(traits|vector|parameters)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="((?:(?:[^\W\d]|\$)[\w.\[\]$&lt;&gt;]*\s+)+?)((?:[^\W\d]|\$)[\w$]*)(\s*)(\()">
+        <bygroups>
+          <usingself state="root"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Operator"/>
+        </bygroups>
+      </rule>
+      <rule pattern="@[\w.]*">
+        <token type="NameDecorator"/>
+      </rule>
+      <rule pattern="(abstract|auto|alias|align|const|delegate|deprecated|enum|export|extern|final|function|immutable|inout|lazy|nothrow|override|package|private|protected|public|pure|ref|scope|shared|static|synchronized|template|unittest|__gshared)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(void|bool|byte|ubyte|short|ushort|int|uint|long|ulong|cent|ucent|float|double|real|ifloat|idouble|ireal|cfloat|cdouble|creal|char|wchar|dchar)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="(size_t|ptrdiff_t|noreturn|string|wstring|dstring|Object|Throwable|Exception|Error|imported)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(module)(\s+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="import"/>
+      </rule>
+      <rule pattern="(true|false|null)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(class|interface|struct|template|union)(\s+)">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="class"/>
+      </rule>
+      <rule pattern="(import)(\s+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="import"/>
+      </rule>
+      <rule pattern="[qr]?&#34;(\\\\|\\&#34;|[^&#34;])*&#34;[cwd]?">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="(`)([^`]*)(`)[cwd]?">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#39;\\.&#39;|&#39;[^\\]&#39;|&#39;\\u[0-9a-fA-F]{4}&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="(\.)((?:[^\W\d]|\$)[\w$]*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameAttribute"/>
+        </bygroups>
+      </rule>
+      <rule pattern="^\s*([^\W\d]|\$)[\w$]*:">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="([0-9][0-9_]*\.([0-9][0-9_]*)?|\.[0-9][0-9_]*)([eE][+\-]?[0-9][0-9_]*)?[fFL]?i?|[0-9][eE][+\-]?[0-9][0-9_]*[fFL]?|[0-9]([eE][+\-]?[0-9][0-9_]*)?[fFL]|0[xX]([0-9a-fA-F][0-9a-fA-F_]*\.?|([0-9a-fA-F][0-9a-fA-F_]*)?\.[0-9a-fA-F][0-9a-fA-F_]*)[pP][+\-]?[0-9][0-9_]*[fFL]?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="0[xX][0-9a-fA-F][0-9a-fA-F_]*[lL]?">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="0[bB][01][01_]*[lL]?">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="0[0-7_]+[lL]?">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0|[1-9][0-9_]*[lL]?">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="([~^*!%&amp;\[\](){}&lt;&gt;|+=:;,./?-]|q{)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="([^\W\d]|\$)[\w$]*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="class">
+      <rule pattern="([^\W\d]|\$)[\w$]*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="import">
+      <rule pattern="[\w.]+\*?">
+        <token type="NameNamespace"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dart.xml

@@ -0,0 +1,213 @@
+<lexer>
+  <config>
+    <name>Dart</name>
+    <alias>dart</alias>
+    <filename>*.dart</filename>
+    <mime_type>text/x-dart</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="string_double_multiline">
+      <rule pattern="&#34;&#34;&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^&#34;$\\]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule>
+        <include state="string_common"/>
+      </rule>
+      <rule pattern="(\$|\&#34;)+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+    </state>
+    <state name="class">
+      <rule pattern="[a-zA-Z_$]\w*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="import_decl">
+      <rule>
+        <include state="string_literal"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\b(as|show|hide)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="[a-zA-Z_$]\w*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="\,">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="\;">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="string_single_multiline">
+      <rule pattern="&#39;&#39;&#39;">
+        <token type="LiteralStringSingle"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^\&#39;$\\]+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule>
+        <include state="string_common"/>
+      </rule>
+      <rule pattern="(\$|\&#39;)+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="string_literal"/>
+      </rule>
+      <rule pattern="#!(.*?)$">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule pattern="\b(import|export)\b">
+        <token type="Keyword"/>
+        <push state="import_decl"/>
+      </rule>
+      <rule pattern="\b(library|source|part of|part)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="[^\S\n]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*.*?\*/">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="\b(class)\b(\s+)">
+        <bygroups>
+          <token type="KeywordDeclaration"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="class"/>
+      </rule>
+      <rule pattern="\b(assert|break|case|catch|continue|default|do|else|finally|for|if|in|is|new|return|super|switch|this|throw|try|while)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="\b(abstract|async|await|const|extends|factory|final|get|implements|native|operator|required|set|static|sync|typedef|var|with|yield)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="\b(bool|double|dynamic|int|num|Object|String|void)\b">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="\b(false|null|true)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="[~!%^&amp;*+=|?:&lt;&gt;/-]|as\b">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[a-zA-Z_$]\w*:">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="[a-zA-Z_$]\w*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[(){}\[\],.;]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="0[xX][0-9a-fA-F]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\d+(\.\d*)?([eE][+-]?\d+)?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\.\d+([eE][+-]?\d+)?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="string_literal">
+      <rule pattern="r&#34;&#34;&#34;([\w\W]*?)&#34;&#34;&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="r&#39;&#39;&#39;([\w\W]*?)&#39;&#39;&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="r&#34;(.*?)&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="r&#39;(.*?)&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="&#34;&#34;&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string_double_multiline"/>
+      </rule>
+      <rule pattern="&#39;&#39;&#39;">
+        <token type="LiteralStringSingle"/>
+        <push state="string_single_multiline"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string_double"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <push state="string_single"/>
+      </rule>
+    </state>
+    <state name="string_common">
+      <rule pattern="\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]*\}|[a-z&#39;\&#34;$\\])">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="(\$)([a-zA-Z_]\w*)">
+        <bygroups>
+          <token type="LiteralStringInterpol"/>
+          <token type="Name"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\$\{)(.*?)(\})">
+        <bygroups>
+          <token type="LiteralStringInterpol"/>
+          <usingself state="root"/>
+          <token type="LiteralStringInterpol"/>
+        </bygroups>
+      </rule>
+    </state>
+    <state name="string_double">
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^&#34;$\\\n]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule>
+        <include state="string_common"/>
+      </rule>
+      <rule pattern="\$+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+    </state>
+    <state name="string_single">
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^&#39;$\\\n]+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule>
+        <include state="string_common"/>
+      </rule>
+      <rule pattern="\$+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/diff.xml

@@ -0,0 +1,52 @@
+<lexer>
+  <config>
+    <name>Diff</name>
+    <alias>diff</alias>
+    <alias>udiff</alias>
+    <filename>*.diff</filename>
+    <filename>*.patch</filename>
+    <mime_type>text/x-diff</mime_type>
+    <mime_type>text/x-patch</mime_type>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern=" .*\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\d+(,\d+)?(a|c|d)\d+(,\d+)?\n">
+        <token type="GenericSubheading"/>
+      </rule>
+      <rule pattern="---\n">
+        <token type="GenericStrong"/>
+      </rule>
+      <rule pattern="&lt; .*\n">
+        <token type="GenericDeleted"/>
+      </rule>
+      <rule pattern="&gt; .*\n">
+        <token type="GenericInserted"/>
+      </rule>
+      <rule pattern="\+.*\n">
+        <token type="GenericInserted"/>
+      </rule>
+      <rule pattern="-.*\n">
+        <token type="GenericDeleted"/>
+      </rule>
+      <rule pattern="!.*\n">
+        <token type="GenericStrong"/>
+      </rule>
+      <rule pattern="@.*\n">
+        <token type="GenericSubheading"/>
+      </rule>
+      <rule pattern="([Ii]ndex|diff).*\n">
+        <token type="GenericHeading"/>
+      </rule>
+      <rule pattern="=.*\n">
+        <token type="GenericHeading"/>
+      </rule>
+      <rule pattern=".*\n">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/django_jinja.xml

@@ -0,0 +1,153 @@
+<lexer>
+  <config>
+    <name>Django/Jinja</name>
+    <alias>django</alias>
+    <alias>jinja</alias>
+    <mime_type>application/x-django-templating</mime_type>
+    <mime_type>application/x-jinja</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="var">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(-?)(\}\})">
+        <bygroups>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="varnames"/>
+      </rule>
+    </state>
+    <state name="block">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(-?)(%\})">
+        <bygroups>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="varnames"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="[^{]+">
+        <token type="Other"/>
+      </rule>
+      <rule pattern="\{\{">
+        <token type="CommentPreproc"/>
+        <push state="var"/>
+      </rule>
+      <rule pattern="\{[*#].*?[*#]\}">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="(\{%)(-?\s*)(comment)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endcomment)(\s*-?)(%\})">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+          <token type="Comment"/>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\{%)(-?\s*)(raw)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endraw)(\s*-?)(%\})">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="CommentPreproc"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\{%)(-?\s*)(filter)(\s+)([a-zA-Z_]\w*)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+        <push state="block"/>
+      </rule>
+      <rule pattern="(\{%)(-?\s*)([a-zA-Z_]\w*)">
+        <bygroups>
+          <token type="CommentPreproc"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+        </bygroups>
+        <push state="block"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Other"/>
+      </rule>
+    </state>
+    <state name="varnames">
+      <rule pattern="(\|)(\s*)([a-zA-Z_]\w*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(is)(\s+)(not)?(\s+)?([a-zA-Z_]\w*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(_|true|false|none|True|False|None)\b">
+        <token type="KeywordPseudo"/>
+      </rule>
+      <rule pattern="(in|as|reversed|recursive|not|and|or|is|if|else|import|with(?:(?:out)?\s*context)?|scoped|ignore\s+missing)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(loop|block|super|forloop)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="[a-zA-Z_][\w-]*">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="\.\w+">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern=":?&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern=":?&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="([{}()\[\]+\-*/,:~]|[&gt;&lt;=]=?)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?">
+        <token type="LiteralNumber"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dns.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0"?>
+<lexer>
+  <config>
+    <name>dns</name>
+    <alias>zone</alias>
+    <alias>bind</alias>
+    <filename>*.zone</filename>
+    <mime_type>text/dns</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\b(IN|A|AAAA|AFSDB|APL|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|HIP|IPSECKEY|KEY|KX|LOC|MX|NAPTR|NS|NSEC|NSEC3|NSEC3PARAM|PTR|RRSIG|RP|SIG|SOA|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern=";.*(\S|$)">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="\b((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3}))|:)))\b">
+        <token type="LiteralNumberIntegerLong"/>
+      </rule>
+      <rule pattern="\b((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\b">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="\b\d+[dhwm]?">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="\b([\w\d.-])+\.($|\s)">
+        <token type="NameProperty"/>
+      </rule>
+      <rule pattern="^(@|[\w\d-]+)">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="^\$(TTL|GENERATE|INCLUDE|ORIGIN)">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="\(|\)">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[\r\n\s\t]+">
+        <token type="TextWhitespace"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/docker.xml

@@ -0,0 +1,56 @@
+<lexer>
+  <config>
+    <name>Docker</name>
+    <alias>docker</alias>
+    <alias>dockerfile</alias>
+    <filename>Dockerfile</filename>
+    <filename>Dockerfile.*</filename>
+    <filename>*.docker</filename>
+    <mime_type>text/x-dockerfile-config</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="#.*">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="(ONBUILD)((?:\s*\\?\s*))">
+        <bygroups>
+          <token type="Keyword"/>
+          <using lexer="Bash"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(HEALTHCHECK)(((?:\s*\\?\s*)--\w+=\w+(?:\s*\\?\s*))*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <using lexer="Bash"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(VOLUME|ENTRYPOINT|CMD|SHELL)((?:\s*\\?\s*))(\[.*?\])">
+        <bygroups>
+          <token type="Keyword"/>
+          <using lexer="Bash"/>
+          <using lexer="JSON"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(LABEL|ENV|ARG)((?:(?:\s*\\?\s*)\w+=\w+(?:\s*\\?\s*))*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <using lexer="Bash"/>
+        </bygroups>
+      </rule>
+      <rule pattern="((?:FROM|MAINTAINER|EXPOSE|WORKDIR|USER|STOPSIGNAL)|VOLUME)\b(.*)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="LiteralString"/>
+        </bygroups>
+      </rule>
+      <rule pattern="((?:RUN|CMD|ENTRYPOINT|ENV|ARG|LABEL|ADD|COPY))">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(.*\\\n)*.+">
+        <using lexer="Bash"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dtd.xml

@@ -0,0 +1,168 @@
+<lexer>
+  <config>
+    <name>DTD</name>
+    <alias>dtd</alias>
+    <filename>*.dtd</filename>
+    <mime_type>application/xml-dtd</mime_type>
+    <dot_all>true</dot_all>
+  </config>
+  <rules>
+    <state name="common">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="(%|&amp;)[^;]*;">
+        <token type="NameEntity"/>
+      </rule>
+      <rule pattern="&lt;!--">
+        <token type="Comment"/>
+        <push state="comment"/>
+      </rule>
+      <rule pattern="[(|)*,?+]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="&#34;[^&#34;]*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="\&#39;[^\&#39;]*\&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+    </state>
+    <state name="comment">
+      <rule pattern="[^-]+">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="--&gt;">
+        <token type="Comment"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="-">
+        <token type="Comment"/>
+      </rule>
+    </state>
+    <state name="element">
+      <rule>
+        <include state="common"/>
+      </rule>
+      <rule pattern="EMPTY|ANY|#PCDATA">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="[^&gt;\s|()?+*,]+">
+        <token type="NameTag"/>
+      </rule>
+      <rule pattern="&gt;">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="attlist">
+      <rule>
+        <include state="common"/>
+      </rule>
+      <rule pattern="CDATA|IDREFS|IDREF|ID|NMTOKENS|NMTOKEN|ENTITIES|ENTITY|NOTATION">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="#REQUIRED|#IMPLIED|#FIXED">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="xml:space|xml:lang">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="[^&gt;\s|()?+*,]+">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="&gt;">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="entity">
+      <rule>
+        <include state="common"/>
+      </rule>
+      <rule pattern="SYSTEM|PUBLIC|NDATA">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="[^&gt;\s|()?+*,]+">
+        <token type="NameEntity"/>
+      </rule>
+      <rule pattern="&gt;">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="notation">
+      <rule>
+        <include state="common"/>
+      </rule>
+      <rule pattern="SYSTEM|PUBLIC">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="[^&gt;\s|()?+*,]+">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="&gt;">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="common"/>
+      </rule>
+      <rule pattern="(&lt;!ELEMENT)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameTag"/>
+        </bygroups>
+        <push state="element"/>
+      </rule>
+      <rule pattern="(&lt;!ATTLIST)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameTag"/>
+        </bygroups>
+        <push state="attlist"/>
+      </rule>
+      <rule pattern="(&lt;!ENTITY)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameEntity"/>
+        </bygroups>
+        <push state="entity"/>
+      </rule>
+      <rule pattern="(&lt;!NOTATION)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameTag"/>
+        </bygroups>
+        <push state="notation"/>
+      </rule>
+      <rule pattern="(&lt;!\[)([^\[\s]+)(\s*)(\[)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="NameEntity"/>
+          <token type="Text"/>
+          <token type="Keyword"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(&lt;!DOCTYPE)(\s+)([^&gt;\s]+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameTag"/>
+        </bygroups>
+      </rule>
+      <rule pattern="PUBLIC|SYSTEM">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="[\[\]&gt;]">
+        <token type="Keyword"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dylan.xml

@@ -0,0 +1,176 @@
+<lexer>
+  <config>
+    <name>Dylan</name>
+    <alias>dylan</alias>
+    <filename>*.dylan</filename>
+    <filename>*.dyl</filename>
+    <filename>*.intr</filename>
+    <mime_type>text/x-dylan</mime_type>
+    <case_insensitive>true</case_insensitive>
+  </config>
+  <rules>
+    <state name="string">
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\([\\abfnrtv&#34;\&#39;]|x[a-f0-9]{2,4}|[0-7]{1,3})">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="[^\\&#34;\n]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="([a-z0-9-]+:)([ \t]*)(.*(?:\n[ \t].+)*)">
+        <bygroups>
+          <token type="NameAttribute"/>
+          <token type="TextWhitespace"/>
+          <token type="LiteralString"/>
+        </bygroups>
+      </rule>
+      <rule>
+        <push state="code"/>
+      </rule>
+    </state>
+    <state name="code">
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push state="comment"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="&#39;(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\\&#39;\n])&#39;">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="#b[01]+">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="#o[0-7]+">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="[-+]?(\d*\.\d+([ed][-+]?\d+)?|\d+(\.\d*)?e[-+]?\d+)">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[-+]?\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="#x[0-9a-f]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="(\?\\?)([\w!&amp;*&lt;&gt;|^$%@+~?/=-]+)(:)(token|name|variable|expression|body|case-body|\*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameVariable"/>
+          <token type="Operator"/>
+          <token type="NameBuiltin"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\?)(:)(token|name|variable|expression|body|case-body|\*)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Operator"/>
+          <token type="NameVariable"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\?\\?)([\w!&amp;*&lt;&gt;|^$%@+~?/=-]+)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="NameVariable"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(=&gt;|::|#\(|#\[|##|\?\?|\?=|\?|[(){}\[\],.;])">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern=":=">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="#[tf]">
+        <token type="Literal"/>
+      </rule>
+      <rule pattern="#&#34;">
+        <token type="LiteralStringSymbol"/>
+        <push state="symbol"/>
+      </rule>
+      <rule pattern="#[a-z0-9-]+">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="#(all-keys|include|key|next|rest)">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="[\w!&amp;*&lt;&gt;|^$%@+~?/=-]+:">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="&lt;[\w!&amp;*&lt;&gt;|^$%@+~?/=-]+&gt;">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="\*[\w!&amp;*&lt;&gt;|^$%@+~?/=-]+\*">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="\$[\w!&amp;*&lt;&gt;|^$%@+~?/=-]+">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="(let|method|function)([ \t]+)([\w!&amp;*&lt;&gt;|^$%@+~?/=-]+)">
+        <bygroups>
+          <token type="NameBuiltin"/>
+          <token type="TextWhitespace"/>
+          <token type="NameVariable"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(error|signal|return|break)">
+        <token type="NameException"/>
+      </rule>
+      <rule pattern="(\\?)([\w!&amp;*&lt;&gt;|^$%@+~?/=-]+)">
+        <bygroups>
+          <token type="Operator"/>
+          <token type="Name"/>
+        </bygroups>
+      </rule>
+    </state>
+    <state name="comment">
+      <rule pattern="[^*/]">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[*/]">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="symbol">
+      <rule pattern="&#34;">
+        <token type="LiteralStringSymbol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^\\&#34;]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ebnf.xml

@@ -0,0 +1,90 @@
+<lexer>
+  <config>
+    <name>EBNF</name>
+    <alias>ebnf</alias>
+    <filename>*.ebnf</filename>
+    <mime_type>text/x-ebnf</mime_type>
+  </config>
+  <rules>
+    <state name="comment">
+      <rule pattern="[^*)]">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule>
+        <include state="comment_start"/>
+      </rule>
+      <rule pattern="\*\)">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[*)]">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="identifier">
+      <rule pattern="([a-zA-Z][\w \-]*)">
+        <token type="Keyword"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="comment_start"/>
+      </rule>
+      <rule>
+        <include state="identifier"/>
+      </rule>
+      <rule pattern="=">
+        <token type="Operator"/>
+        <push state="production"/>
+      </rule>
+    </state>
+    <state name="production">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule>
+        <include state="comment_start"/>
+      </rule>
+      <rule>
+        <include state="identifier"/>
+      </rule>
+      <rule pattern="&#34;[^&#34;]*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#39;[^&#39;]*&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="(\?[^?]*\?)">
+        <token type="NameEntity"/>
+      </rule>
+      <rule pattern="[\[\]{}(),|]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="-">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern=";">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\.">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="whitespace">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="comment_start">
+      <rule pattern="\(\*">
+        <token type="CommentMultiline"/>
+        <push state="comment"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/elixir.xml

@@ -0,0 +1,744 @@
+<lexer>
+  <config>
+    <name>Elixir</name>
+    <alias>elixir</alias>
+    <alias>ex</alias>
+    <alias>exs</alias>
+    <filename>*.ex</filename>
+    <filename>*.eex</filename>
+    <filename>*.exs</filename>
+    <mime_type>text/x-elixir</mime_type>
+  </config>
+  <rules>
+    <state name="cb-intp">
+      <rule pattern="[^#\}\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\}[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="triquot-end">
+      <rule pattern="[a-zA-Z]+">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="apos-no-intp">
+      <rule pattern="[^&#39;\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&#39;[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="slas-no-intp">
+      <rule pattern="[^/\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="/[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="pipe-no-intp">
+      <rule pattern="[^\|\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\|[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="apos-intp">
+      <rule pattern="[^#&#39;\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&#39;[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="cb-no-intp">
+      <rule pattern="[^\}\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\}[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="heredoc_double">
+      <rule pattern="^\s*&#34;&#34;&#34;">
+        <token type="LiteralStringHeredoc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="heredoc_interpol"/>
+      </rule>
+    </state>
+    <state name="triapos-end">
+      <rule pattern="[a-zA-Z]+">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="interpol_string">
+      <rule pattern="\}">
+        <token type="LiteralStringInterpol"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="root"/>
+      </rule>
+    </state>
+    <state name="triquot-intp">
+      <rule pattern="^\s*&#34;&#34;&#34;">
+        <token type="LiteralStringHeredoc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="heredoc_interpol"/>
+      </rule>
+    </state>
+    <state name="interpol">
+      <rule pattern="#\{">
+        <token type="LiteralStringInterpol"/>
+        <push state="interpol_string"/>
+      </rule>
+    </state>
+    <state name="pa-no-intp">
+      <rule pattern="[^\)\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\)[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="map_key">
+      <rule>
+        <include state="root"/>
+      </rule>
+      <rule pattern=":">
+        <token type="Punctuation"/>
+        <push state="map_val"/>
+      </rule>
+      <rule pattern="=&gt;">
+        <token type="Punctuation"/>
+        <push state="map_val"/>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="pa-intp">
+      <rule pattern="[^#\)\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\)[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="tuple">
+      <rule>
+        <include state="root"/>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="#.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="(\?)(\\x\{)([\da-fA-F]+)(\})">
+        <bygroups>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringEscape"/>
+          <token type="LiteralNumberHex"/>
+          <token type="LiteralStringEscape"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\?)(\\x[\da-fA-F]{1,2})">
+        <bygroups>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringEscape"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\?)(\\[abdefnrstv])">
+        <bygroups>
+          <token type="LiteralStringChar"/>
+          <token type="LiteralStringEscape"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\?\\?.">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern=":::">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="::">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern=":(?:\.\.\.|&lt;&lt;&gt;&gt;|%\{\}|%|\{\})">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern=":(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\&lt;\&lt;\&lt;|\&gt;\&gt;\&gt;|\|\|\||\&amp;\&amp;\&amp;|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\&gt;\&gt;|\&lt;\~\&gt;|\|\~\&gt;|\&lt;\|\&gt;|\=\=|\!\=|\&lt;\=|\&gt;\=|\&amp;\&amp;|\|\||\&lt;\&gt;|\+\+|\-\-|\|\&gt;|\=\~|\-\&gt;|\&lt;\-|\||\.|\=|\~\&gt;|\&lt;\~|\&lt;|\&gt;|\+|\-|\*|\/|\!|\^|\&amp;))">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern=":&#34;">
+        <token type="LiteralStringSymbol"/>
+        <push state="string_double_atom"/>
+      </rule>
+      <rule pattern=":&#39;">
+        <token type="LiteralStringSymbol"/>
+        <push state="string_single_atom"/>
+      </rule>
+      <rule pattern="((?:\.\.\.|&lt;&lt;&gt;&gt;|%\{\}|%|\{\})|(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\&lt;\&lt;\&lt;|\&gt;\&gt;\&gt;|\|\|\||\&amp;\&amp;\&amp;|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\&gt;\&gt;|\&lt;\~\&gt;|\|\~\&gt;|\&lt;\|\&gt;|\=\=|\!\=|\&lt;\=|\&gt;\=|\&amp;\&amp;|\|\||\&lt;\&gt;|\+\+|\-\-|\|\&gt;|\=\~|\-\&gt;|\&lt;\-|\||\.|\=|\~\&gt;|\&lt;\~|\&lt;|\&gt;|\+|\-|\*|\/|\!|\^|\&amp;)))(:)(?=\s|\n)">
+        <bygroups>
+          <token type="LiteralStringSymbol"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(fn|do|end|after|else|rescue|catch)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(not|and|or|when|in)\b">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="(case|cond|for|if|unless|try|receive|raise|quote|unquote|unquote_splicing|throw|super|while)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(def|defp|defmodule|defprotocol|defmacro|defmacrop|defdelegate|defexception|defstruct|defimpl|defcallback)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(import|require|use|alias)\b">
+        <token type="KeywordNamespace"/>
+      </rule>
+      <rule pattern="(nil|true|false)\b">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="(_|__MODULE__|__DIR__|__ENV__|__CALLER__)\b">
+        <token type="NamePseudo"/>
+      </rule>
+      <rule pattern="@(?:\.\.\.|[a-z_]\w*[!?]?)">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="(?:\.\.\.|[a-z_]\w*[!?]?)">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="(%?)([A-Z]\w*(?:\.[A-Z]\w*)*)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\&lt;\&lt;\&lt;|\&gt;\&gt;\&gt;|\|\|\||\&amp;\&amp;\&amp;|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\&gt;\&gt;|\&lt;\~\&gt;|\|\~\&gt;|\&lt;\|\&gt;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\=\=|\!\=|\&lt;\=|\&gt;\=|\&amp;\&amp;|\|\||\&lt;\&gt;|\+\+|\-\-|\|\&gt;|\=\~|\-\&gt;|\&lt;\-|\||\.|\=|\~\&gt;|\&lt;\~">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="\\\\|\&lt;\&lt;|\&gt;\&gt;|\=\&gt;|\(|\)|\:|\;|\,|\[|\]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="&amp;\d">
+        <token type="NameEntity"/>
+      </rule>
+      <rule pattern="\&lt;|\&gt;|\+|\-|\*|\/|\!|\^|\&amp;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="0b[01](_?[01])*">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="0o[0-7](_?[0-7])*">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="0x[\da-fA-F](_?[\dA-Fa-f])*">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\d(_?\d)*\.\d(_?\d)*([eE][-+]?\d(_?\d)*)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="\d(_?\d)*">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;&#34;&#34;\s*">
+        <token type="LiteralStringHeredoc"/>
+        <push state="heredoc_double"/>
+      </rule>
+      <rule pattern="&#39;&#39;&#39;\s*$">
+        <token type="LiteralStringHeredoc"/>
+        <push state="heredoc_single"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="string_double"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <push state="string_single"/>
+      </rule>
+      <rule>
+        <include state="sigils"/>
+      </rule>
+      <rule pattern="%\{">
+        <token type="Punctuation"/>
+        <push state="map_key"/>
+      </rule>
+      <rule pattern="\{">
+        <token type="Punctuation"/>
+        <push state="tuple"/>
+      </rule>
+    </state>
+    <state name="sigils">
+      <rule pattern="(~[a-z])(&#34;&#34;&#34;)">
+        <bygroups>
+          <token type="LiteralStringOther"/>
+          <token type="LiteralStringHeredoc"/>
+        </bygroups>
+        <push state="triquot-end" state="triquot-intp"/>
+      </rule>
+      <rule pattern="(~[A-Z])(&#34;&#34;&#34;)">
+        <bygroups>
+          <token type="LiteralStringOther"/>
+          <token type="LiteralStringHeredoc"/>
+        </bygroups>
+        <push state="triquot-end" state="triquot-no-intp"/>
+      </rule>
+      <rule pattern="(~[a-z])(&#39;&#39;&#39;)">
+        <bygroups>
+          <token type="LiteralStringOther"/>
+          <token type="LiteralStringHeredoc"/>
+        </bygroups>
+        <push state="triapos-end" state="triapos-intp"/>
+      </rule>
+      <rule pattern="(~[A-Z])(&#39;&#39;&#39;)">
+        <bygroups>
+          <token type="LiteralStringOther"/>
+          <token type="LiteralStringHeredoc"/>
+        </bygroups>
+        <push state="triapos-end" state="triapos-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]\{">
+        <token type="LiteralStringOther"/>
+        <push state="cb-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]\{">
+        <token type="LiteralStringOther"/>
+        <push state="cb-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]\[">
+        <token type="LiteralStringOther"/>
+        <push state="sb-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]\[">
+        <token type="LiteralStringOther"/>
+        <push state="sb-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]\(">
+        <token type="LiteralStringOther"/>
+        <push state="pa-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]\(">
+        <token type="LiteralStringOther"/>
+        <push state="pa-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]&lt;">
+        <token type="LiteralStringOther"/>
+        <push state="ab-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]&lt;">
+        <token type="LiteralStringOther"/>
+        <push state="ab-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]/">
+        <token type="LiteralStringOther"/>
+        <push state="slas-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]/">
+        <token type="LiteralStringOther"/>
+        <push state="slas-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]\|">
+        <token type="LiteralStringOther"/>
+        <push state="pipe-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]\|">
+        <token type="LiteralStringOther"/>
+        <push state="pipe-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]&#34;">
+        <token type="LiteralStringOther"/>
+        <push state="quot-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]&#34;">
+        <token type="LiteralStringOther"/>
+        <push state="quot-no-intp"/>
+      </rule>
+      <rule pattern="~[a-z]&#39;">
+        <token type="LiteralStringOther"/>
+        <push state="apos-intp"/>
+      </rule>
+      <rule pattern="~[A-Z]&#39;">
+        <token type="LiteralStringOther"/>
+        <push state="apos-no-intp"/>
+      </rule>
+    </state>
+    <state name="triapos-intp">
+      <rule pattern="^\s*&#39;&#39;&#39;">
+        <token type="LiteralStringHeredoc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="heredoc_interpol"/>
+      </rule>
+    </state>
+    <state name="string_single_atom">
+      <rule pattern="[^#&#39;\\]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="(&#39;)">
+        <bygroups>
+          <token type="LiteralStringSymbol"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="quot-intp">
+      <rule pattern="[^#&#34;\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&#34;[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="sb-no-intp">
+      <rule pattern="[^\]\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\][a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="slas-intp">
+      <rule pattern="[^#/\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="/[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="sb-intp">
+      <rule pattern="[^#\]\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\][a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="heredoc_no_interpol">
+      <rule pattern="[^\\\n]+">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule pattern="\n+">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+    </state>
+    <state name="pipe-intp">
+      <rule pattern="[^#\|\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\|[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="map_val">
+      <rule>
+        <include state="root"/>
+      </rule>
+      <rule pattern=",">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?=\})">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="heredoc_single">
+      <rule pattern="^\s*&#39;&#39;&#39;">
+        <token type="LiteralStringHeredoc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="heredoc_interpol"/>
+      </rule>
+    </state>
+    <state name="heredoc_interpol">
+      <rule pattern="[^#\\\n]+">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule pattern="\n+">
+        <token type="LiteralStringHeredoc"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="string_single">
+      <rule pattern="[^#&#39;\\]+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="(&#39;)">
+        <bygroups>
+          <token type="LiteralStringSingle"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="string_double_atom">
+      <rule pattern="[^#&#34;\\]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="(&#34;)">
+        <bygroups>
+          <token type="LiteralStringSymbol"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="ab-no-intp">
+      <rule pattern="[^&gt;\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&gt;[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="ab-intp">
+      <rule pattern="[^#&gt;\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&gt;[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="quot-no-intp">
+      <rule pattern="[^&#34;\\]+">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringOther"/>
+      </rule>
+      <rule pattern="&#34;[a-zA-Z]*">
+        <token type="LiteralStringOther"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="triapos-no-intp">
+      <rule pattern="^\s*&#39;&#39;&#39;">
+        <token type="LiteralStringHeredoc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="heredoc_no_interpol"/>
+      </rule>
+    </state>
+    <state name="string_double">
+      <rule pattern="[^#&#34;\\]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule>
+        <include state="escapes"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="(&#34;)">
+        <bygroups>
+          <token type="LiteralStringDouble"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="interpol"/>
+      </rule>
+    </state>
+    <state name="escapes">
+      <rule pattern="(\\x\{)([\da-fA-F]+)(\})">
+        <bygroups>
+          <token type="LiteralStringEscape"/>
+          <token type="LiteralNumberHex"/>
+          <token type="LiteralStringEscape"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(\\x[\da-fA-F]{1,2})">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="(\\[abdefnrstv])">
+        <token type="LiteralStringEscape"/>
+      </rule>
+    </state>
+    <state name="triquot-no-intp">
+      <rule pattern="^\s*&#34;&#34;&#34;">
+        <token type="LiteralStringHeredoc"/>
+        <pop depth="1"/>
+      </rule>
+      <rule>
+        <include state="heredoc_no_interpol"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/elm.xml

@@ -0,0 +1,119 @@
+<lexer>
+  <config>
+    <name>Elm</name>
+    <alias>elm</alias>
+    <filename>*.elm</filename>
+    <mime_type>text/x-elm</mime_type>
+  </config>
+  <rules>
+    <state name="shader">
+      <rule pattern="\|(?!\])">
+        <token type="NameEntity"/>
+      </rule>
+      <rule pattern="\|\]">
+        <token type="NameEntity"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern=".*\n">
+        <token type="NameEntity"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="\{-">
+        <token type="CommentMultiline"/>
+        <push state="comment"/>
+      </rule>
+      <rule pattern="--.*">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="doublequote"/>
+      </rule>
+      <rule pattern="^\s*module\s*">
+        <token type="KeywordNamespace"/>
+        <push state="imports"/>
+      </rule>
+      <rule pattern="^\s*import\s*">
+        <token type="KeywordNamespace"/>
+        <push state="imports"/>
+      </rule>
+      <rule pattern="\[glsl\|.*">
+        <token type="NameEntity"/>
+        <push state="shader"/>
+      </rule>
+      <rule pattern="(import|module|alias|where|port|else|type|case|then|let|as|of|if|in)\b">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="[A-Z]\w*">
+        <token type="KeywordType"/>
+      </rule>
+      <rule pattern="^main ">
+        <token type="KeywordReserved"/>
+      </rule>
+      <rule pattern="\((&lt;-|\|\||\|&gt;|&amp;&amp;|\+\+|-&gt;|\.\.|//|&gt;&gt;|&gt;=|/=|==|::|&lt;~|&lt;\||&lt;=|&lt;&lt;|~|&lt;|=|:|&gt;|&#39;|/|\\|\.|\^|-|`|\+|\*|\||%)\)">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(&lt;-|\|\||\|&gt;|&amp;&amp;|\+\+|-&gt;|\.\.|//|&gt;&gt;|&gt;=|/=|==|::|&lt;~|&lt;\||&lt;=|&lt;&lt;|~|&lt;|=|:|&gt;|&#39;|/|\\|\.|\^|-|`|\+|\*|\||%)">
+        <token type="NameFunction"/>
+      </rule>
+      <rule>
+        <include state="numbers"/>
+      </rule>
+      <rule pattern="[a-z_][a-zA-Z_\&#39;]*">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="[,()\[\]{}]">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+    <state name="comment">
+      <rule pattern="-(?!\})">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="\{-">
+        <token type="CommentMultiline"/>
+        <push state="comment"/>
+      </rule>
+      <rule pattern="[^-}]">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="-\}">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="doublequote">
+      <rule pattern="\\u[0-9a-fA-F]{4}">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="\\[nrfvb\\&#34;]">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="[^&#34;]">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="imports">
+      <rule pattern="\w+(\.\w+)*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="numbers">
+      <rule pattern="_?\d+\.(?=\d+)">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="_?\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/emacslisp.xml

@@ -0,0 +1,132 @@
+<lexer>
+  <config>
+    <name>EmacsLisp</name>
+    <alias>emacs</alias>
+    <alias>elisp</alias>
+    <alias>emacs-lisp</alias>
+    <filename>*.el</filename>
+    <mime_type>text/x-elisp</mime_type>
+    <mime_type>application/x-elisp</mime_type>
+  </config>
+  <rules>
+    <state name="string">
+      <rule pattern="[^&#34;\\`]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="`((?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|]|[#.:])*)\&#39;">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="`">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\.">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\\n">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <push state="body"/>
+      </rule>
+    </state>
+    <state name="body">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="\?([^\\]|\\.)">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern=":((?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|]|[#.:])*)">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="::((?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="&#39;((?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="`">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[-+]?\d+\.?(?=[ &#34;()\]\&#39;\n,;`])">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[-+]?\d+/\d+(?=[ &#34;()\]\&#39;\n,;`])">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[-+]?(\d*\.\d+([defls][-+]?\d+)?|\d+(\.\d*)?[defls][-+]?\d+)(?=[ &#34;()\]\&#39;\n,;`])">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="\[|\]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="#:((?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|]|[#.:])*)">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="#\^\^?">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="#\&#39;">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="#[bB][+-]?[01]+(/[01]+)?">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="#[oO][+-]?[0-7]+(/[0-7]+)?">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="#[xX][+-]?[0-9a-fA-F]+(/[0-9a-fA-F]+)?">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="#\d+r[+-]?[0-9a-zA-Z]+(/[0-9a-zA-Z]+)?">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="#\d+=">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="#\d+#">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(,@|,|\.|:)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(t|nil)(?=[ &#34;()\]\&#39;\n,;`])">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="\*((?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|]|[#.:])*)\*">
+        <token type="NameVariableGlobal"/>
+      </rule>
+      <rule pattern="((?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|])(?:\\.|[\w!$%&amp;*+-/&lt;=&gt;?@^{}~|]|[#.:])*)">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="#\(">
+        <token type="Operator"/>
+        <push state="body"/>
+      </rule>
+      <rule pattern="\(">
+        <token type="Punctuation"/>
+        <push state="body"/>
+      </rule>
+      <rule pattern="\)">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/erlang.xml

@@ -0,0 +1,166 @@
+<lexer>
+  <config>
+    <name>Erlang</name>
+    <alias>erlang</alias>
+    <filename>*.erl</filename>
+    <filename>*.hrl</filename>
+    <filename>*.es</filename>
+    <filename>*.escript</filename>
+    <mime_type>text/x-erlang</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="%.*\n">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="(receive|after|begin|catch|query|case|cond|when|let|fun|end|try|of|if)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(localtime_to_universaltime|universaltime_to_localtime|list_to_existing_atom|check_process_code|bitstring_to_list|list_to_bitstring|function_exported|is_process_alive|iolist_to_binary|bump_reductions|garbage_collect|process_display|suspend_process|list_to_integer|disconnect_node|integer_to_list|trace_delivered|send_nosuspend|list_to_binary|system_profile|binary_to_term|binary_to_list|resume_process|append_element|term_to_binary|system_monitor|list_to_tuple|spawn_monitor|delete_module|trace_pattern|tuple_to_list|list_to_float|float_to_list|module_loaded|port_connect|is_bitstring|port_to_list|monitor_node|process_info|port_control|split_binary|cancel_timer|purge_module|group_leader|list_to_atom|atom_to_list|port_command|is_reference|process_flag|pid_to_list|system_info|start_timer|iolist_size|fun_to_list|load_module|is_function|ref_to_list|list_to_pid|system_flag|make_tuple|is_builtin|unregister|is_boolean|set_cookie|md5_update|spawn_link|setelement|trace_info|read_timer|statistics|send_after|port_close|is_integer|tuple_size|spawn_opt|open_port|is_record|is_binary|md5_final|port_call|port_info|is_number|byte_size|demonitor|register|is_float|bit_size|fun_info|get_keys|is_tuple|is_atom|element|is_list|is_port|monitor|display|whereis|is_pid|memory|unlink|phash2|length|spawn|nodes|trace|round|apply|erase|phash|trunc|float|size|link|node|exit|hash|send|get|md5|put|abs|hd|tl)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(andalso|orelse|bxor|band|bnot|and|bsr|bsl|div|not|rem|bor|xor|or)\b">
+        <token type="OperatorWord"/>
+      </rule>
+      <rule pattern="^-">
+        <token type="Punctuation"/>
+        <push state="directive"/>
+      </rule>
+      <rule pattern="(\+\+?|--?|\*|/|&lt;|&gt;|/=|=:=|=/=|=&lt;|&gt;=|==?|&lt;-|!|\?)">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="&lt;&lt;">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="&gt;&gt;">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="((?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;))(:)">
+        <bygroups>
+          <token type="NameNamespace"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(?:^|(?&lt;=:))((?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;))(\s*)(\()">
+        <bygroups>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="[+-]?(?:[2-9]|[12][0-9]|3[0-6])#[0-9a-zA-Z]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[+-]?\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[+-]?\d+.\d+">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[]\[:_@\&#34;.{}()|;,]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(?:[A-Z_]\w*)">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="(?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;)">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="\?(?:(?:[A-Z_]\w*)|(?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;))">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="\$(?:(?:\\(?:[bdefnrstv\&#39;&#34;\\]|[0-7][0-7]?[0-7]?|(?:x[0-9a-fA-F]{2}|x\{[0-9a-fA-F]+\})|\^[a-zA-Z]))|\\[ %]|[^\\])">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="#(?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;)(:?\.(?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;))?">
+        <token type="NameLabel"/>
+      </rule>
+      <rule pattern="\A#!.+\n">
+        <token type="CommentHashbang"/>
+      </rule>
+      <rule pattern="#\{">
+        <token type="Punctuation"/>
+        <push state="map_key"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="(?:\\(?:[bdefnrstv\&#39;&#34;\\]|[0-7][0-7]?[0-7]?|(?:x[0-9a-fA-F]{2}|x\{[0-9a-fA-F]+\})|\^[a-zA-Z]))">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="~[0-9.*]*[~#+BPWXb-ginpswx]">
+        <token type="LiteralStringInterpol"/>
+      </rule>
+      <rule pattern="[^&#34;\\~]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="~">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+    <state name="directive">
+      <rule pattern="(define)(\s*)(\()((?:(?:[A-Z_]\w*)|(?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;)))">
+        <bygroups>
+          <token type="NameEntity"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="NameConstant"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(record)(\s*)(\()((?:(?:[A-Z_]\w*)|(?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;)))">
+        <bygroups>
+          <token type="NameEntity"/>
+          <token type="Text"/>
+          <token type="Punctuation"/>
+          <token type="NameLabel"/>
+        </bygroups>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?:[a-z]\w*|&#39;[^\n&#39;]*[^\\]&#39;)">
+        <token type="NameEntity"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="map_key">
+      <rule>
+        <include state="root"/>
+      </rule>
+      <rule pattern="=&gt;">
+        <token type="Punctuation"/>
+        <push state="map_val"/>
+      </rule>
+      <rule pattern=":=">
+        <token type="Punctuation"/>
+        <push state="map_val"/>
+      </rule>
+      <rule pattern="\}">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="map_val">
+      <rule>
+        <include state="root"/>
+      </rule>
+      <rule pattern=",">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(?=\})">
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/factor.xml

@@ -0,0 +1,412 @@
+<lexer>
+  <config>
+    <name>Factor</name>
+    <alias>factor</alias>
+    <filename>*.factor</filename>
+    <mime_type>text/x-factor</mime_type>
+  </config>
+  <rules>
+    <state name="base">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="((?:MACRO|MEMO|TYPED)?:[:]?)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(M:[:]?)(\s+)(\S+)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(C:)(\s+)(\S+)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(GENERIC:)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\(\s">
+        <token type="NameFunction"/>
+        <push state="stackeffect"/>
+      </rule>
+      <rule pattern=";\s">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(USING:)(\s+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="vocabs"/>
+      </rule>
+      <rule pattern="(USE:|UNUSE:|IN:|QUALIFIED:)(\s+)(\S+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(QUALIFIED-WITH:)(\s+)(\S+)(\s+)(\S+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(FROM:|EXCLUDE:)(\s+)(\S+)(\s+=&gt;\s)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="words"/>
+      </rule>
+      <rule pattern="(RENAME:)(\s+)(\S+)(\s+)(\S+)(\s+=&gt;\s+)(\S+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="NameNamespace"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(ALIAS:|TYPEDEF:)(\s+)(\S+)(\s+)(\S+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(DEFER:|FORGET:|POSTPONE:)(\s+)(\S+)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(TUPLE:|ERROR:)(\s+)(\S+)(\s+&lt;\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+        <push state="slots"/>
+      </rule>
+      <rule pattern="(TUPLE:|ERROR:|BUILTIN:)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+        <push state="slots"/>
+      </rule>
+      <rule pattern="(MIXIN:|UNION:|INTERSECTION:)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(PREDICATE:)(\s+)(\S+)(\s+&lt;\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(C:)(\s+)(\S+)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(INSTANCE:)(\s+)(\S+)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(SLOT:)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(SINGLETON:)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="SINGLETONS:">
+        <token type="Keyword"/>
+        <push state="classes"/>
+      </rule>
+      <rule pattern="(CONSTANT:|SYMBOL:|MAIN:|HELP:)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+        </bygroups>
+      </rule>
+      <rule pattern="SYMBOLS:\s">
+        <token type="Keyword"/>
+        <push state="words"/>
+      </rule>
+      <rule pattern="SYNTAX:\s">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="ALIEN:\s">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(STRUCT:)(\s+)(\S+)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="NameClass"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(FUNCTION:)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(FUNCTION-ALIAS:)(\s+)(\S+)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)">
+        <bygroups>
+          <token type="KeywordNamespace"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+          <token type="NameFunction"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="(?:&lt;PRIVATE|PRIVATE&gt;)\s">
+        <token type="KeywordNamespace"/>
+      </rule>
+      <rule pattern="&#34;&#34;&#34;\s+(?:.|\n)*?\s+&#34;&#34;&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#34;(?:\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\S+&#34;\s+(?:\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="CHAR:\s+(?:\\[\\abfnrstv]|[^\\]\S*)\s">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="!\s+.*$">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="#!\s+.*$">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="/\*\s+(?:.|\n)*?\s\*/\s">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="[tf]\s">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="[\\$]\s+\S+">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="M\\\s+\S+\s+\S+">
+        <token type="NameConstant"/>
+      </rule>
+      <rule pattern="[+-]?(?:[\d,]*\d)?\.(?:\d([\d,]*\d)?)?(?:[eE][+-]?\d+)?\s">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="[+-]?\d(?:[\d,]*\d)?(?:[eE][+-]?\d+)?\s">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="0x[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\s">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="NAN:\s+[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\s">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="0b[01]+\s">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="0o[0-7]+\s">
+        <token type="LiteralNumberOct"/>
+      </rule>
+      <rule pattern="(?:\d([\d,]*\d)?)?\+\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\s">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="(?:\-\d([\d,]*\d)?)?\-\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\s">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="(?:deprecated|final|foldable|flushable|inline|recursive)\s">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(identity-hashcode|callstack&gt;array|identity-tuple\?|identity-tuple|retainstack|callstack\?|tri-curry\*|tri-curry@|tri-curry|&lt;wrapper&gt;|datastack|bi-curry@|bi-curry\*|hashcode\*|callstack|\?execute|hashcode|boolean\?|compose\?|&gt;boolean|wrapper\?|bi-curry|unless\*|boolean|assert\?|\(clone\)|either\?|prepose|assert=|execute|wrapper|compose|3curry|assert|2curry|curry\?|object|equal\?|tuple\?|unless|build|3drop|same\?|2tri\*|2tri@|both\?|3keep|4drop|throw|2over|swapd|clear|2keep|2drop|until|curry|4keep|clone|while|tuple|when\*|-rot|tri@|dupd|drop|tri\*|call|when|with|4dup|4dip|3tri|3dup|3dip|2tri|keep|loop|most|2nip|swap|2dup|null|2dip|2bi\*|2bi@|pick|over|and|rot|not|nip|new|if\*|tri|2bi|boa|eq\?|dup|3bi|dip|die|bi\*|bi@|\?if|xor|bi|do|if|or|\?|=)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(assoc-clone-like|assoc-filter-as|assoc-partition|assoc-intersect|assoc-hashcode|assoc-combine|assoc-filter!|assoc-subset\?|assoc-union!|maybe-set-at|extract-keys|assoc-map-as|assoc-differ|assoc-refine|assoc-empty\?|assoc-filter|assoc-diff!|sift-values|assoc-union|assoc-stack|clear-assoc|assoc-all\?|delete-at\*|assoc-find|substitute|assoc-each|assoc-size|assoc-diff|assoc-any\?|assoc-like|rename-at|sift-keys|new-assoc|map&gt;assoc|value-at\*|assoc-map|delete-at|change-at|assoc&gt;map|value-at|push-at|assoc=|values|set-at|&lt;enum&gt;|inc-at|2cache|value\?|assoc\?|&gt;alist|cache|enum\?|assoc|unzip|key\?|enum|keys|\?at|\?of|zip|at\+|at\*|at|of)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(shallow-spread&gt;quot|recursive-hashcode|linear-case-quot|deep-spread&gt;quot|to-fixed-point|execute-effect|wrong-values\?|4cleave&gt;quot|2cleave&gt;quot|wrong-values|3cleave&gt;quot|cleave&gt;quot|call-effect|alist&gt;quot|case&gt;quot|case-find|cond&gt;quot|no-case\?|no-cond\?|no-case|no-cond|4cleave|3cleave|2cleave|cleave|spread|cond|case)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(log2-expects-positive\?|integer&gt;fixnum-strict|log2-expects-positive|out-of-fixnum-range\?|out-of-fixnum-range|find-last-integer|next-power-of-2|\(all-integers\?\)|integer&gt;fixnum|\(find-integer\)|\(each-integer\)|imaginary-part|fp-nan-payload|all-integers\?|find-integer|each-integer|fp-infinity\?|fp-special\?|fp-bitwise=|bits&gt;double|double&gt;bits|power-of-2\?|unless-zero|denominator|next-float|bits&gt;float|float&gt;bits|prev-float|unordered\?|real-part|when-zero|numerator|rational\?|&gt;integer|rational|complex\?|&lt;fp-nan&gt;|fp-qnan\?|fp-snan\?|integer\?|number=|bignum\?|integer|&gt;fixnum|fp-sign|fp-nan\?|fixnum\?|number\?|complex|if-zero|&gt;bignum|bignum|number|fixnum|float\?|bitxor|ratio\?|bitnot|bitand|&gt;float|real\?|bitor|zero\?|even\?|times|shift|float|recip|align|ratio|neg\?|real|log2|bit\?|odd\?|/mod|\?1\+|mod|rem|neg|sgn|u&lt;=|u&gt;=|abs|u&gt;|2/|2\^|/i|/f|sq|&lt;=|u&lt;|&gt;=|-|\+|&lt;|\*|/|&gt;)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(non-negative-integer-expected\?|non-negative-integer-expected|immutable-sequence\?|immutable-sequence|virtual-sequence\?|sequence-hashcode|cartesian-product|check-slice-error|unclip-last-slice|assert-sequence=|assert-sequence\?|virtual-exemplar|virtual-sequence|assert-sequence|trim-head-slice|last-index-from|find-index-from|trim-tail-slice|find-last-from|cartesian-each|collapse-slice|but-last-slice|map-find-last|cartesian-map|collector-for|bounds-error\?|accumulate-as|replace-slice|bounds-check\?|binary-reduce|new-resizable|unless-empty|delete-slice|replicate-as|map-integers|selector-for|bounds-check|reduce-index|bounds-error|unclip-slice|new-sequence|&lt;repetition&gt;|slice-error\?|slice-error|unclip-last|drop-prefix|supremum-by|push-either|2map-reduce|accumulate!|tail-slice\*|repetition\?|check-slice|iota-tuple\?|remove-nth!|sum-lengths|head-slice\*|find-index|clone-like|delete-all|change-nth|prepend-as|member-eq\?|max-length|each-index|map-reduce|iota-tuple|produce-as|snip-slice|accumulate|remove-eq!|last-index|min-length|remove-nth|&lt;reversed&gt;|repetition|tail-slice|3append-as|when-empty|interleave|insert-nth|infimum-by|index-from|set-second|immutable\?|rest-slice|set-fourth|head-slice|trim-slice|set-length|set-third|concat-as|immutable|trim-tail|cut-slice|collector|set-first|sequence\?|sequence=|midpoint@|trim-head|each-from|reversed\?|map-index|partition|find-last|2selector|2sequence|replicate|find-from|filter-as|3sequence|append-as|4sequence|remove-eq|1sequence|virtual@|push-all|lengthen|shorter\?|map-find|reverse!|reversed|exchange|pad-tail|pad-head|surround|selector|shortest|sequence|set-last|mismatch|supremum|new-like|if-empty|but-last|\?set-nth|filter!|harvest|member\?|map-sum|indices|padding|set-nth|2map-as|shorter|shorten|prepend|infimum|2reduce|append!|product|subseq\?|longest|longer\?|push-if|suffix!|reverse|join-as|remove!|3append|\?second|3map-as|&lt;slice&gt;|produce|length|\?first|start\*|longer|remove|subseq|unclip|first2|first3|reduce|second|follow|filter|slice\?|map-as|empty\?|fourth|suffix|halves|concat|first4|prefix|append|index|short|2all\?|count|2each|third|tail\*|slice|first|tail\?|head\*|3each|head\?|start|\?last|join|iota|last|like|snip|map!|head|glue|move|tail|2map|find|sift|flip|nths|trim|each|cut\*|3map|pop\*|copy|any\?|all\?|\?nth|push|rest|sum|nth|pop|map|cut)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(init-namespaces|with-variables|with-variable|set-namestack|change-global|with-global|initialize|get-global|set-global|with-scope|make-assoc|is-global|namespace|namestack|counter|change|toggle|global|set|get|dec|off|inc|on|\+@)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(resize-array|&lt;array&gt;|1array|2array|3array|4array|&gt;array|array\?|array|pair\?|pair)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(\(stream-contents-by-length-or-block\)|with-input-output\+error-streams\*|with-input-output\+error-streams|\(stream-contents-by-element\)|\(stream-contents-by-length\)|stream-read-partial-unsafe|\(stream-contents-by-block\)|with-output\+error-stream\*|\(each-stream-block-slice\)|stream-read-partial-into|with-output\+error-stream|each-stream-block-slice|invalid-read-buffer\?|stream-read-partial|stream-element-type|\(each-stream-block\)|with-output-stream\*|invalid-read-buffer|with-output-stream|with-input-stream\*|stream-read-unsafe|with-error-stream\*|with-error-stream|stream-read-until|each-stream-block|with-output&gt;error|with-input-stream|with-error&gt;output|read-partial-into|stream-contents\*|each-stream-line|stream-seekable\?|stream-read-into|each-block-slice|each-block-size|stream-contents|bad-seek-type\?|seek-absolute\?|output-stream\?|seek-relative\?|stream-write1|with-streams\*|output-stream|stream-length|bad-seek-type|seek-absolute|input-stream\?|stream-readln|seek-relative|with-streams|read-partial|stream-copy\*|stream-flush|stream-read1|stream-lines|stream-write|stream-print|error-stream|input-stream|stream-tell|\+character\+|stream-copy|each-morsel|seek-output|stream-read|tell-output|stream-seek|read-until|seek-input|each-block|tell-input|each-line|seek-end\?|read-into|stream-nl|stream-bl|contents|seek-end|write1|\+byte\+|readln|write|read1|print|flush|lines|read|nl|bl)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(resize-string|&lt;string&gt;|1string|&gt;string|string\?|string)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(&lt;vector&gt;|1vector|&gt;vector|vector\?|vector|\?push)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(current-continuation|return-continuation|callback-error-hook|error-continuation|attempt-all-error\?|thread-error-hook|attempt-all-error|rethrow-restarts|continue-restart|compute-restarts|error-in-thread|throw-continue|throw-restarts|with-datastack|&lt;continuation&gt;|original-error|ignore-errors|continue-with|continuation\?|in-callback\?|continuation|error-thread|attempt-all|&lt;condition&gt;|with-return|condition\?|&lt;restart&gt;|condition|continue|restart\?|restarts|rethrow|callcc0|recover|restart|cleanup|callcc1|return|error|ifcc)\s">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="\S+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="stackeffect">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\(\s+">
+        <token type="NameFunction"/>
+        <push state="stackeffect"/>
+      </rule>
+      <rule pattern="\)\s">
+        <token type="NameFunction"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="--\s">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="\S+">
+        <token type="NameVariable"/>
+      </rule>
+    </state>
+    <state name="slots">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";\s">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="(\{\s+)(\S+)(\s+[^}]+\s+\}\s)">
+        <bygroups>
+          <token type="Text"/>
+          <token type="NameVariable"/>
+          <token type="Text"/>
+        </bygroups>
+      </rule>
+      <rule pattern="\S+">
+        <token type="NameVariable"/>
+      </rule>
+    </state>
+    <state name="vocabs">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";\s">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\S+">
+        <token type="NameNamespace"/>
+      </rule>
+    </state>
+    <state name="classes">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";\s">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\S+">
+        <token type="NameClass"/>
+      </rule>
+    </state>
+    <state name="words">
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=";\s">
+        <token type="Keyword"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\S+">
+        <token type="NameFunction"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule pattern="#!.*$">
+        <token type="CommentPreproc"/>
+      </rule>
+      <rule>
+        <push state="base"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>

vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fennel.xml

@@ -0,0 +1,68 @@
+<lexer>
+  <config>
+    <name>Fennel</name>
+    <alias>fennel</alias>
+    <alias>fnl</alias>
+    <filename>*.fennel</filename>
+    <mime_type>text/x-fennel</mime_type>
+    <mime_type>application/x-fennel</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern=";.*$">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="-?\d+\.\d+">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="-?\d+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="0x-?[abcdef\d]+">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="&#39;(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="\\(.|[a-z]+)">
+        <token type="LiteralStringChar"/>
+      </rule>
+      <rule pattern="::?#?(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="LiteralStringSymbol"/>
+      </rule>
+      <rule pattern="~@|[`\&#39;#^~&amp;@]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="(require-macros|set-forcibly!|import-macros|eval-compiler|pick-values|accumulate|macrodebug|pick-args|with-open|icollect|partial|comment|include|collect|hashfn|rshift|values|length|lshift|quote|match|while|doto|band|when|bnot|bxor|not=|tset|-\?&gt;&gt;|each|-&gt;&gt;|let|doc|for|and|set|not|-\?&gt;|bor|lua|\?\.|do|&gt;=|&lt;=|//|\.\.|-&gt;|or|if|~=|\^|&gt;|=|&lt;|:|/|\.|-|\+|\*|%|#) ">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(global|lambda|macros|local|macro|var|fn|λ) ">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(debug\.setuservalue|debug\.getmetatable|debug\.getuservalue|package\.searchpath|debug\.setmetatable|debug\.upvaluejoin|debug\.getregistry|coroutine\.running|coroutine\.create|debug\.setupvalue|debug\.getupvalue|coroutine\.status|coroutine\.resume|debug\.upvalueid|package\.loadlib|debug\.traceback|math\.randomseed|coroutine\.yield|collectgarbage|debug\.getlocal|package\.seeall|string\.reverse|coroutine\.wrap|debug\.setlocal|bit32\.replace|bit32\.lrotate|debug\.gethook|debug\.getinfo|bit32\.extract|string\.gmatch|string\.format|bit32\.arshift|bit32\.rrotate|debug\.sethook|table\.concat|os\.setlocale|table\.remove|string\.lower|bit32\.rshift|bit32\.lshift|string\.match|table\.unpack|setmetatable|getmetatable|table\.insert|string\.upper|string\.byte|debug\.debug|string\.gsub|bit32\.btest|math\.random|string\.find|string\.dump|os\.difftime|string\.char|table\.sort|loadstring|io\.tmpfile|bit32\.band|bit32\.bnot|string\.sub|os\.execute|os\.tmpname|table\.maxn|math\.log10|math\.atan2|table\.pack|math\.frexp|math\.ldexp|bit32\.bxor|string\.len|math\.floor|string\.rep|coroutine|math\.cosh|math\.ceil|math\.atan|math\.asin|math\.acos|math\.modf|os\.rename|os\.remove|io\.output|os\.getenv|bit32\.bor|math\.sinh|math\.fmod|math\.tanh|math\.sqrt|math\.cos|math\.tan|io\.lines|os\.clock|tostring|io\.input|math\.sin|tonumber|loadfile|math\.rad|math\.pow|io\.flush|math\.abs|math\.min|rawequal|math\.max|math\.log|io\.close|io\.popen|math\.exp|math\.deg|io\.write|os\.time|io\.read|io\.open|require|os\.exit|os\.date|package|io\.type|module|select|rawset|rawlen|rawget|unpack|assert|dofile|ipairs|string|xpcall|table|pcall|bit32|print|debug|error|pairs|math|type|next|load|arg|io|os|_G) ">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="(?&lt;=\()(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="NameFunction"/>
+      </rule>
+      <rule pattern="(?!#)[\w!$%*+&lt;=&gt;?/.#-]+">
+        <token type="NameVariable"/>
+      </rule>
+      <rule pattern="(\[|\])">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(\{|\})">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="(\(|\))">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>