Server-side syntax highlighting for all code (#12047)

* Server-side syntax hilighting for all code This PR does a few things: * Remove all traces of highlight.js * Use chroma library to provide fast syntax hilighting directly on the server * Provide syntax hilighting for diffs * Re-style both unified and split diffs views * Add custom syntax hilighting styling for both regular and arc-green Fixes #7729 Fixes #10157 Fixes #11825 Fixes #7728 Fixes #3872 Fixes #3682 And perhaps gets closer to #9553 * fix line marker * fix repo search * Fix single line select * properly load settings * npm uninstall highlight.js * review suggestion * code review * forgot to call function * fix test * Apply suggestions from code review suggestions from @silverwind thanks Co-authored-by: silverwind <me@silverwind.io> * code review * copy/paste error * Use const for highlight size limit * Update web_src/less/_repository.less Co-authored-by: Lauris BH <lauris@nix.lv> * update size limit to 1MB and other styling tweaks * fix highlighting for certain diff sections * fix test * add worker back as suggested Co-authored-by: silverwind <me@silverwind.io> Co-authored-by: Lauris BH <lauris@nix.lv>
2020-06-30 17:34:03 -04:00 · 2020-06-30 17:34:03 -04:00 · af7ffaa279
commit af7ffaa279
parent ce5f2b9845
336 changed files with 37293 additions and 769 deletions
--- a/vendor/github.com/alecthomas/chroma/lexers/m/make.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/make.go
@ -0,0 +1,54 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma"          // nolint
+	. "github.com/alecthomas/chroma/lexers/b" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// Makefile lexer.
+var Makefile = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "Base Makefile",
+		Aliases:   []string{"make", "makefile", "mf", "bsdmake"},
+		Filenames: []string{"*.mak", "*.mk", "Makefile", "makefile", "Makefile.*", "GNUmakefile"},
+		MimeTypes: []string{"text/x-makefile"},
+		EnsureNL:  true,
+	},
+	Rules{
+		"root": {
+			{`^(?:[\t ]+.*\n|\n)+`, Using(Bash), nil},
+			{`\$[<@$+%?|*]`, Keyword, nil},
+			{`\s+`, Text, nil},
+			{`#.*?\n`, Comment, nil},
+			{`(export)(\s+)(?=[\w${}\t -]+\n)`, ByGroups(Keyword, Text), Push("export")},
+			{`export\s+`, Keyword, nil},
+			{`([\w${}().-]+)(\s*)([!?:+]?=)([ \t]*)((?:.*\\\n)+|.*\n)`, ByGroups(NameVariable, Text, Operator, Text, Using(Bash)), nil},
+			{`(?s)"(\\\\|\\.|[^"\\])*"`, LiteralStringDouble, nil},
+			{`(?s)'(\\\\|\\.|[^'\\])*'`, LiteralStringSingle, nil},
+			{`([^\n:]+)(:+)([ \t]*)`, ByGroups(NameFunction, Operator, Text), Push("block-header")},
+			{`\$\(`, Keyword, Push("expansion")},
+		},
+		"expansion": {
+			{`[^$a-zA-Z_()]+`, Text, nil},
+			{`[a-zA-Z_]+`, NameVariable, nil},
+			{`\$`, Keyword, nil},
+			{`\(`, Keyword, Push()},
+			{`\)`, Keyword, Pop(1)},
+		},
+		"export": {
+			{`[\w${}-]+`, NameVariable, nil},
+			{`\n`, Text, Pop(1)},
+			{`\s+`, Text, nil},
+		},
+		"block-header": {
+			{`[,|]`, Punctuation, nil},
+			{`#.*?\n`, Comment, Pop(1)},
+			{`\\\n`, Text, nil},
+			{`\$\(`, Keyword, Push("expansion")},
+			{`[a-zA-Z_]+`, Name, nil},
+			{`\n`, Text, Pop(1)},
+			{`.`, Text, nil},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/mako.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/mako.go
@ -0,0 +1,60 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+	. "github.com/alecthomas/chroma/lexers/p" // nolint
+)
+
+// Mako lexer.
+var Mako = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "Mako",
+		Aliases:   []string{"mako"},
+		Filenames: []string{"*.mao"},
+		MimeTypes: []string{"application/x-mako"},
+	},
+	Rules{
+		"root": {
+			{`(\s*)(%)(\s*end(?:\w+))(\n|\Z)`, ByGroups(Text, CommentPreproc, Keyword, Other), nil},
+			{`(\s*)(%)([^\n]*)(\n|\Z)`, ByGroups(Text, CommentPreproc, Using(Python), Other), nil},
+			{`(\s*)(##[^\n]*)(\n|\Z)`, ByGroups(Text, CommentPreproc, Other), nil},
+			{`(?s)<%doc>.*?</%doc>`, CommentPreproc, nil},
+			{`(<%)([\w.:]+)`, ByGroups(CommentPreproc, NameBuiltin), Push("tag")},
+			{`(</%)([\w.:]+)(>)`, ByGroups(CommentPreproc, NameBuiltin, CommentPreproc), nil},
+			{`<%(?=([\w.:]+))`, CommentPreproc, Push("ondeftags")},
+			{`(<%(?:!?))(.*?)(%>)(?s)`, ByGroups(CommentPreproc, Using(Python), CommentPreproc), nil},
+			{`(\$\{)(.*?)(\})`, ByGroups(CommentPreproc, Using(Python), CommentPreproc), nil},
+			{`(?sx)
+                (.+?)                # anything, followed by:
+                (?:
+                 (?<=\n)(?=%|\#\#) | # an eval or comment line
+                 (?=\#\*) |          # multiline comment
+                 (?=</?%) |          # a python block
+                                     # call start or end
+                 (?=\$\{) |          # a substitution
+                 (?<=\n)(?=\s*%) |
+                                     # - don't consume
+                 (\\\n) |            # an escaped newline
+                 \Z                  # end of string
+                )
+            `, ByGroups(Other, Operator), nil},
+			{`\s+`, Text, nil},
+		},
+		"ondeftags": {
+			{`<%`, CommentPreproc, nil},
+			{`(?<=<%)(include|inherit|namespace|page)`, NameBuiltin, nil},
+			Include("tag"),
+		},
+		"tag": {
+			{`((?:\w+)\s*=)(\s*)(".*?")`, ByGroups(NameAttribute, Text, LiteralString), nil},
+			{`/?\s*>`, CommentPreproc, Pop(1)},
+			{`\s+`, Text, nil},
+		},
+		"attr": {
+			{`".*?"`, LiteralString, Pop(1)},
+			{`'.*?'`, LiteralString, Pop(1)},
+			{`[^\s>]+`, LiteralString, Pop(1)},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/markdown.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/markdown.go
@ -0,0 +1,48 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/h"
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// Markdown lexer.
+var Markdown = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
+	&Config{
+		Name:      "markdown",
+		Aliases:   []string{"md", "mkd"},
+		Filenames: []string{"*.md", "*.mkd", "*.markdown"},
+		MimeTypes: []string{"text/x-markdown"},
+	},
+	Rules{
+		"root": {
+			{`^(#[^#].+\n)`, ByGroups(GenericHeading), nil},
+			{`^(#{2,6}.+\n)`, ByGroups(GenericSubheading), nil},
+			{`^(\s*)([*-] )(\[[ xX]\])( .+\n)`, ByGroups(Text, Keyword, Keyword, UsingSelf("inline")), nil},
+			{`^(\s*)([*-])(\s)(.+\n)`, ByGroups(Text, Keyword, Text, UsingSelf("inline")), nil},
+			{`^(\s*)([0-9]+\.)( .+\n)`, ByGroups(Text, Keyword, UsingSelf("inline")), nil},
+			{`^(\s*>\s)(.+\n)`, ByGroups(Keyword, GenericEmph), nil},
+			{"^(```\\n)([\\w\\W]*?)(^```$)", ByGroups(String, Text, String), nil},
+			{"^(```)(\\w+)(\\n)([\\w\\W]*?)(^```$)",
+				UsingByGroup(
+					internal.Get,
+					2, 4,
+					String, String, String, Text, String,
+				),
+				nil,
+			},
+			Include("inline"),
+		},
+		"inline": {
+			{`\\.`, Text, nil},
+			{`(\s)([*_][^*_]+[*_])(\W|\n)`, ByGroups(Text, GenericEmph, Text), nil},
+			{`(\s)((\*\*|__).*?)\3((?=\W|\n))`, ByGroups(Text, GenericStrong, GenericStrong, Text), nil},
+			{`(\s)(~~[^~]+~~)((?=\W|\n))`, ByGroups(Text, GenericDeleted, Text), nil},
+			{"`[^`]+`", LiteralStringBacktick, nil},
+			{`[@#][\w/:]+`, NameEntity, nil},
+			{`(!?\[)([^]]+)(\])(\()([^)]+)(\))`, ByGroups(Text, NameTag, Text, Text, NameAttribute, Text), nil},
+			{`[^\\\s]+`, Other, nil},
+			{`.|\n`, Other, nil},
+		},
+	},
+)))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/mason.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/mason.go
@ -0,0 +1,43 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma"          // nolint
+	. "github.com/alecthomas/chroma/lexers/h" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+	. "github.com/alecthomas/chroma/lexers/p" // nolint
+)
+
+// Mason lexer.
+var Mason = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "Mason",
+		Aliases:   []string{"mason"},
+		Filenames: []string{"*.m", "*.mhtml", "*.mc", "*.mi", "autohandler", "dhandler"},
+		MimeTypes: []string{"application/x-mason"},
+		Priority:  0.1,
+	},
+	Rules{
+		"root": {
+			{`\s+`, Text, nil},
+			{`(<%doc>)(.*?)(</%doc>)(?s)`, ByGroups(NameTag, CommentMultiline, NameTag), nil},
+			{`(<%(?:def|method))(\s*)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, Text, NameFunction, NameTag, UsingSelf("root"), NameTag), nil},
+			{`(<%\w+)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, NameFunction, NameTag, Using(Perl), NameTag), nil},
+			{`(<&[^|])(.*?)(,.*?)?(&>)(?s)`, ByGroups(NameTag, NameFunction, Using(Perl), NameTag), nil},
+			{`(<&\|)(.*?)(,.*?)?(&>)(?s)`, ByGroups(NameTag, NameFunction, Using(Perl), NameTag), nil},
+			{`</&>`, NameTag, nil},
+			{`(<%!?)(.*?)(%>)(?s)`, ByGroups(NameTag, Using(Perl), NameTag), nil},
+			{`(?<=^)#[^\n]*(\n|\Z)`, Comment, nil},
+			{`(?<=^)(%)([^\n]*)(\n|\Z)`, ByGroups(NameTag, Using(Perl), Other), nil},
+			{`(?sx)
+                 (.+?)               # anything, followed by:
+                 (?:
+                  (?<=\n)(?=[%#]) |  # an eval or comment line
+                  (?=</?[%&]) |      # a substitution or block or
+                                     # call start or end
+                                     # - don't consume
+                  (\\\n) |           # an escaped newline
+                  \Z                 # end of string
+                 )`, ByGroups(Using(HTML), Operator), nil},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/mathematica.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/mathematica.go
@ -0,0 +1,32 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// Mathematica lexer.
+var Mathematica = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "Mathematica",
+		Aliases:   []string{"mathematica", "mma", "nb"},
+		Filenames: []string{"*.nb", "*.cdf", "*.nbp", "*.ma"},
+		MimeTypes: []string{"application/mathematica", "application/vnd.wolfram.mathematica", "application/vnd.wolfram.mathematica.package", "application/vnd.wolfram.cdf"},
+	},
+	Rules{
+		"root": {
+			{`(?s)\(\*.*?\*\)`, Comment, nil},
+			{"([a-zA-Z]+[A-Za-z0-9]*`)", NameNamespace, nil},
+			{`([A-Za-z0-9]*_+[A-Za-z0-9]*)`, NameVariable, nil},
+			{`#\d*`, NameVariable, nil},
+			{`([a-zA-Z]+[a-zA-Z0-9]*)`, Name, nil},
+			{`-?\d+\.\d*`, LiteralNumberFloat, nil},
+			{`-?\d*\.\d+`, LiteralNumberFloat, nil},
+			{`-?\d+`, LiteralNumberInteger, nil},
+			{Words(``, ``, `;;`, `=`, `=.`, `!===`, `:=`, `->`, `:>`, `/.`, `+`, `-`, `*`, `/`, `^`, `&&`, `||`, `!`, `<>`, `|`, `/;`, `?`, `@`, `//`, `/@`, `@@`, `@@@`, `~~`, `===`, `&`, `<`, `>`, `<=`, `>=`), Operator, nil},
+			{Words(``, ``, `,`, `;`, `(`, `)`, `[`, `]`, `{`, `}`), Punctuation, nil},
+			{`".*?"`, LiteralString, nil},
+			{`\s+`, TextWhitespace, nil},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/matlab.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/matlab.go
@ -0,0 +1,51 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// Matlab lexer.
+var Matlab = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "Matlab",
+		Aliases:   []string{"matlab"},
+		Filenames: []string{"*.m"},
+		MimeTypes: []string{"text/matlab"},
+	},
+	Rules{
+		"root": {
+			{`\n`, Text, nil},
+			{`^!.*`, LiteralStringOther, nil},
+			{`%\{\s*\n`, CommentMultiline, Push("blockcomment")},
+			{`%.*$`, Comment, nil},
+			{`^\s*function`, Keyword, Push("deffunc")},
+			{Words(``, `\b`, `break`, `case`, `catch`, `classdef`, `continue`, `else`, `elseif`, `end`, `enumerated`, `events`, `for`, `function`, `global`, `if`, `methods`, `otherwise`, `parfor`, `persistent`, `properties`, `return`, `spmd`, `switch`, `try`, `while`), Keyword, nil},
+			{`(sin|sind|sinh|asin|asind|asinh|cos|cosd|cosh|acos|acosd|acosh|tan|tand|tanh|atan|atand|atan2|atanh|sec|secd|sech|asec|asecd|asech|csc|cscd|csch|acsc|acscd|acsch|cot|cotd|coth|acot|acotd|acoth|hypot|exp|expm1|log|log1p|log10|log2|pow2|realpow|reallog|realsqrt|sqrt|nthroot|nextpow2|abs|angle|complex|conj|imag|real|unwrap|isreal|cplxpair|fix|floor|ceil|round|mod|rem|sign|airy|besselj|bessely|besselh|besseli|besselk|beta|betainc|betaln|ellipj|ellipke|erf|erfc|erfcx|erfinv|expint|gamma|gammainc|gammaln|psi|legendre|cross|dot|factor|isprime|primes|gcd|lcm|rat|rats|perms|nchoosek|factorial|cart2sph|cart2pol|pol2cart|sph2cart|hsv2rgb|rgb2hsv|zeros|ones|eye|repmat|rand|randn|linspace|logspace|freqspace|meshgrid|accumarray|size|length|ndims|numel|disp|isempty|isequal|isequalwithequalnans|cat|reshape|diag|blkdiag|tril|triu|fliplr|flipud|flipdim|rot90|find|end|sub2ind|ind2sub|bsxfun|ndgrid|permute|ipermute|shiftdim|circshift|squeeze|isscalar|isvector|ans|eps|realmax|realmin|pi|i|inf|nan|isnan|isinf|isfinite|j|why|compan|gallery|hadamard|hankel|hilb|invhilb|magic|pascal|rosser|toeplitz|vander|wilkinson)\b`, NameBuiltin, nil},
+			{`\.\.\..*$`, Comment, nil},
+			{`-|==|~=|<|>|<=|>=|&&|&|~|\|\|?`, Operator, nil},
+			{`\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\`, Operator, nil},
+			{`\[|\]|\(|\)|\{|\}|:|@|\.|,`, Punctuation, nil},
+			{`=|:|;`, Punctuation, nil},
+			{`(?<=[\w)\].])\'+`, Operator, nil},
+			{`(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?`, LiteralNumberFloat, nil},
+			{`\d+[eEf][+-]?[0-9]+`, LiteralNumberFloat, nil},
+			{`\d+`, LiteralNumberInteger, nil},
+			{`(?<![\w)\].])\'`, LiteralString, Push("string")},
+			{`[a-zA-Z_]\w*`, Name, nil},
+			{`.`, Text, nil},
+		},
+		"string": {
+			{`[^\']*\'`, LiteralString, Pop(1)},
+		},
+		"blockcomment": {
+			{`^\s*%\}`, CommentMultiline, Pop(1)},
+			{`^.*\n`, CommentMultiline, nil},
+			{`.`, CommentMultiline, nil},
+		},
+		"deffunc": {
+			{`(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)`, ByGroups(TextWhitespace, Text, TextWhitespace, Punctuation, TextWhitespace, NameFunction, Punctuation, Text, Punctuation, TextWhitespace), Pop(1)},
+			{`(\s*)([a-zA-Z_]\w*)`, ByGroups(Text, NameFunction), Pop(1)},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/minizinc.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/minizinc.go
@ -0,0 +1,41 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// MiniZinc lexer.
+var MZN = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "MiniZinc",
+		Aliases:   []string{"minizinc", "MZN", "mzn"},
+		Filenames: []string{"*.mzn", "*.dzn", "*.fzn"},
+		MimeTypes: []string{"text/minizinc"},
+	},
+	Rules{
+		"root": {
+			{`\n`, Text, nil},
+			{`\s+`, Text, nil},
+			{`\\\n`, Text, nil},
+			{`\%(.*?)\n`, CommentSingle, nil},
+			{`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil},
+			{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
+			{Words(`\b`, `\b`, `ann`, `annotation`, `any`, `constraint`, `function`, `include`, `list`, `of`, `op`, `output`, `minimize`, `maximize`, `par`, `predicate`, `record`, `satisfy`, `solve`, `test`, `type`, `var`), Keyword, nil},
+			{Words(`\b`, `\b`, `array`, `set`, `bool`, `enum`, `float`, `int`, `string`, `tuple`), KeywordType, nil},
+			{Words(`\b`, `\b`, `for`, `forall`, `if`, `then`, `else`, `endif`, `where`), Keyword, nil},
+			{Words(`\b`, `\b`, `abort`, `abs`, `acosh`, `array_intersect`, `array_union`, `array1d`, `array2d`, `array3d`, `array4d`, `array5d`, `array6d`, `asin`, `assert`, `atan`, `bool2int`, `card`, `ceil`, `concat`, `cos`, `cosh`, `dom`, `dom_array`, `dom_size`, `fix`, `exp`, `floor`, `index_set`, `index_set_1of2`, `index_set_2of2`, `index_set_1of3`, `index_set_2of3`, `index_set_3of3`, `int2float`, `is_fixed`, `join`, `lb`, `lb_array`, `length`, `ln`, `log`, `log2`, `log10`, `min`, `max`, `pow`, `product`, `round`, `set2array`, `show`, `show_int`, `show_float`, `sin`, `sinh`, `sqrt`, `sum`, `tan`, `tanh`, `trace`, `ub`, `ub_array`), NameBuiltin, nil},
+			{`(not|<->|->|<-|\\/|xor|/\\)`, Operator, nil},
+			{`(<|>|<=|>=|==|=|!=)`, Operator, nil},
+			{`(\+|-|\*|/|div|mod)`, Operator, nil},
+			{Words(`\b`, `\b`, `in`, `subset`, `superset`, `union`, `diff`, `symdiff`, `intersect`), Operator, nil},
+			{`(\\|\.\.|\+\+)`, Operator, nil},
+			{`[|()\[\]{},:;]`, Punctuation, nil},
+			{`(true|false)\b`, KeywordConstant, nil},
+			{`([+-]?)\d+(\.(?!\.)\d*)?([eE][-+]?\d+)?`, LiteralNumber, nil},
+			{`::\s*([^\W\d]\w*)(\s*\([^\)]*\))?`, NameDecorator, nil},
+			{`\b([^\W\d]\w*)\b(\()`, ByGroups(NameFunction, Punctuation), nil},
+			{`[^\W\d]\w*`, NameOther, nil},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/mlir.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/mlir.go
@ -0,0 +1,43 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// MLIR lexer.
+var Mlir = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "MLIR",
+		Aliases:   []string{"mlir"},
+		Filenames: []string{"*.mlir"},
+		MimeTypes: []string{"text/x-mlir"},
+	},
+	Rules{
+		"root": {
+			Include("whitespace"),
+			{`c?"[^"]*?"`, LiteralString, nil},
+			{`\^([-a-zA-Z$._][\w\-$.0-9]*)\s*`, NameLabel, nil},
+			{`([\w\d_$.]+)\s*=`, NameLabel, nil},
+			Include("keyword"),
+			{`->`, Punctuation, nil},
+			{`@([\w_][\w\d_$.]*)`, NameFunction, nil},
+			{`[%#][\w\d_$.]+`, NameVariable, nil},
+			{`([1-9?][\d?]*\s*x)+`, LiteralNumber, nil},
+			{`0[xX][a-fA-F0-9]+`, LiteralNumber, nil},
+			{`-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?`, LiteralNumber, nil},
+			{`[=<>{}\[\]()*.,!:]|x\b`, Punctuation, nil},
+			{`[\w\d]+`, Text, nil},
+		},
+		"whitespace": {
+			{`(\n|\s)+`, Text, nil},
+			{`//.*?\n`, Comment, nil},
+		},
+		"keyword": {
+			{Words(``, ``, `constant`, `return`), KeywordType, nil},
+			{Words(``, ``, `func`, `loc`, `memref`, `tensor`, `vector`), KeywordType, nil},
+			{`bf16|f16|f32|f64|index`, Keyword, nil},
+			{`i[1-9]\d*`, Keyword, nil},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/modula2.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/modula2.go
@ -0,0 +1,115 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// Modula-2 lexer.
+var Modula2 = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "Modula-2",
+		Aliases:   []string{"modula2", "m2"},
+		Filenames: []string{"*.def", "*.mod"},
+		MimeTypes: []string{"text/x-modula2"},
+		DotAll:    true,
+	},
+	Rules{
+		"whitespace": {
+			{`\n+`, Text, nil},
+			{`\s+`, Text, nil},
+		},
+		"dialecttags": {
+			{`\(\*!m2pim\*\)`, CommentSpecial, nil},
+			{`\(\*!m2iso\*\)`, CommentSpecial, nil},
+			{`\(\*!m2r10\*\)`, CommentSpecial, nil},
+			{`\(\*!objm2\*\)`, CommentSpecial, nil},
+			{`\(\*!m2iso\+aglet\*\)`, CommentSpecial, nil},
+			{`\(\*!m2pim\+gm2\*\)`, CommentSpecial, nil},
+			{`\(\*!m2iso\+p1\*\)`, CommentSpecial, nil},
+			{`\(\*!m2iso\+xds\*\)`, CommentSpecial, nil},
+		},
+		"identifiers": {
+			{`([a-zA-Z_$][\w$]*)`, Name, nil},
+		},
+		"prefixed_number_literals": {
+			{`0b[01]+(\'[01]+)*`, LiteralNumberBin, nil},
+			{`0[ux][0-9A-F]+(\'[0-9A-F]+)*`, LiteralNumberHex, nil},
+		},
+		"plain_number_literals": {
+			{`[0-9]+(\'[0-9]+)*\.[0-9]+(\'[0-9]+)*[eE][+-]?[0-9]+(\'[0-9]+)*`, LiteralNumberFloat, nil},
+			{`[0-9]+(\'[0-9]+)*\.[0-9]+(\'[0-9]+)*`, LiteralNumberFloat, nil},
+			{`[0-9]+(\'[0-9]+)*`, LiteralNumberInteger, nil},
+		},
+		"suffixed_number_literals": {
+			{`[0-7]+B`, LiteralNumberOct, nil},
+			{`[0-7]+C`, LiteralNumberOct, nil},
+			{`[0-9A-F]+H`, LiteralNumberHex, nil},
+		},
+		"string_literals": {
+			{`'(\\\\|\\'|[^'])*'`, LiteralString, nil},
+			{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
+		},
+		"digraph_operators": {
+			{`\*\.`, Operator, nil},
+			{`\+>`, Operator, nil},
+			{`<>`, Operator, nil},
+			{`<=`, Operator, nil},
+			{`>=`, Operator, nil},
+			{`==`, Operator, nil},
+			{`::`, Operator, nil},
+			{`:=`, Operator, nil},
+			{`\+\+`, Operator, nil},
+			{`--`, Operator, nil},
+		},
+		"unigraph_operators": {
+			{`[+-]`, Operator, nil},
+			{`[*/]`, Operator, nil},
+			{`\\`, Operator, nil},
+			{`[=#<>]`, Operator, nil},
+			{`\^`, Operator, nil},
+			{`@`, Operator, nil},
+			{`&`, Operator, nil},
+			{`~`, Operator, nil},
+			{"`", Operator, nil},
+		},
+		"digraph_punctuation": {
+			{`\.\.`, Punctuation, nil},
+			{`<<`, Punctuation, nil},
+			{`>>`, Punctuation, nil},
+			{`->`, Punctuation, nil},
+			{`\|#`, Punctuation, nil},
+			{`##`, Punctuation, nil},
+			{`\|\*`, Punctuation, nil},
+		},
+		"unigraph_punctuation": {
+			{`[()\[\]{},.:;|]`, Punctuation, nil},
+			{`!`, Punctuation, nil},
+			{`\?`, Punctuation, nil},
+		},
+		"comments": {
+			{`^//.*?\n`, CommentSingle, nil},
+			{`\(\*([^$].*?)\*\)`, CommentMultiline, nil},
+			{`/\*(.*?)\*/`, CommentMultiline, nil},
+		},
+		"pragmas": {
+			{`<\*.*?\*>`, CommentPreproc, nil},
+			{`\(\*\$.*?\*\)`, CommentPreproc, nil},
+		},
+		"root": {
+			Include("whitespace"),
+			Include("dialecttags"),
+			Include("pragmas"),
+			Include("comments"),
+			Include("identifiers"),
+			Include("suffixed_number_literals"),
+			Include("prefixed_number_literals"),
+			Include("plain_number_literals"),
+			Include("string_literals"),
+			Include("digraph_punctuation"),
+			Include("digraph_operators"),
+			Include("unigraph_punctuation"),
+			Include("unigraph_operators"),
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/monkeyc.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/monkeyc.go
@ -0,0 +1,62 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+var MonkeyC = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "MonkeyC",
+		Aliases:   []string{"monkeyc"},
+		Filenames: []string{"*.mc"},
+		MimeTypes: []string{"text/x-monkeyc"},
+	},
+	Rules{
+		"root": {
+			{`[^\S\n]+`, Text, nil},
+			{`\n`, Text, nil},
+			{`//(\n|[\w\W]*?[^\\]\n)`, CommentSingle, nil},
+			{`/(\\\n)?[*][\w\W]*?[*](\\\n)?/`, CommentMultiline, nil},
+			{`/(\\\n)?[*][\w\W]*`, CommentMultiline, nil},
+			{`:[a-zA-Z_][\w_\.]*`, StringSymbol, nil},
+			{`[{}\[\]\(\),;:\.]`, Punctuation, nil},
+			{`[&~\|\^!+\-*\/%=?]`, Operator, nil},
+			{`=>|[+-]=|&&|\|\||>>|<<|[<>]=?|[!=]=`, Operator, nil},
+			{`\b(and|or|instanceof|has|extends|new)`, OperatorWord, nil},
+			{Words(``, `\b`, `NaN`, `null`, `true`, `false`), KeywordConstant, nil},
+			{`(using)((?:\s|\\\\s)+)`, ByGroups(KeywordNamespace, Text), Push("import")},
+			{`(class)((?:\s|\\\\s)+)`, ByGroups(KeywordDeclaration, Text), Push("class")},
+			{`(function)((?:\s|\\\\s)+)`, ByGroups(KeywordDeclaration, Text), Push("function")},
+			{`(module)((?:\s|\\\\s)+)`, ByGroups(KeywordDeclaration, Text), Push("module")},
+			{`\b(if|else|for|switch|case|while|break|continue|default|do|try|catch|finally|return|throw|extends|function)\b`, Keyword, nil},
+			{`\b(const|enum|hidden|public|protected|private|static)\b`, KeywordType, nil},
+			{`\bvar\b`, KeywordDeclaration, nil},
+			{`\b(Activity(Monitor|Recording)?|Ant(Plus)?|Application|Attention|Background|Communications|Cryptography|FitContributor|Graphics|Gregorian|Lang|Math|Media|Persisted(Content|Locations)|Position|Properties|Sensor(History|Logging)?|Storage|StringUtil|System|Test|Time(r)?|Toybox|UserProfile|WatchUi|Rez|Drawables|Strings|Fonts|method)\b`, NameBuiltin, nil},
+			{`\b(me|self|\$)\b`, NameBuiltinPseudo, nil},
+			{`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil},
+			{`'(\\\\|\\'|[^''])*'`, LiteralStringSingle, nil},
+			{`-?(0x[0-9a-fA-F]+l?)`, NumberHex, nil},
+			{`-?([0-9]+(\.[0-9]+[df]?|[df]))\b`, NumberFloat, nil},
+			{`-?([0-9]+l?)`, NumberInteger, nil},
+			{`[a-zA-Z_]\w*`, Name, nil},
+		},
+		"import": {
+			{`([a-zA-Z_][\w_\.]*)(?:(\s+)(as)(\s+)([a-zA-Z_][\w_]*))?`, ByGroups(NameNamespace, Text, KeywordNamespace, Text, NameNamespace), nil},
+			Default(Pop(1)),
+		},
+		"class": {
+			{`([a-zA-Z_][\w_\.]*)(?:(\s+)(extends)(\s+)([a-zA-Z_][\w_\.]*))?`, ByGroups(NameClass, Text, KeywordDeclaration, Text, NameClass), nil},
+			Default(Pop(1)),
+		},
+		"function": {
+			{`initialize`, NameFunctionMagic, nil},
+			{`[a-zA-Z_][\w_\.]*`, NameFunction, nil},
+			Default(Pop(1)),
+		},
+		"module": {
+			{`[a-zA-Z_][\w_\.]*`, NameNamespace, nil},
+			Default(Pop(1)),
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/mwscript.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/mwscript.go
--- a/vendor/github.com/alecthomas/chroma/lexers/m/myghty.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/myghty.go
@ -0,0 +1,40 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+	. "github.com/alecthomas/chroma/lexers/p" // nolint
+)
+
+// Myghty lexer.
+var Myghty = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "Myghty",
+		Aliases:   []string{"myghty"},
+		Filenames: []string{"*.myt", "autodelegate"},
+		MimeTypes: []string{"application/x-myghty"},
+	},
+	Rules{
+		"root": {
+			{`\s+`, Text, nil},
+			{`(<%(?:def|method))(\s*)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, Text, NameFunction, NameTag, UsingSelf("root"), NameTag), nil},
+			{`(<%\w+)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, NameFunction, NameTag, Using(Python), NameTag), nil},
+			{`(<&[^|])(.*?)(,.*?)?(&>)`, ByGroups(NameTag, NameFunction, Using(Python), NameTag), nil},
+			{`(<&\|)(.*?)(,.*?)?(&>)(?s)`, ByGroups(NameTag, NameFunction, Using(Python), NameTag), nil},
+			{`</&>`, NameTag, nil},
+			{`(<%!?)(.*?)(%>)(?s)`, ByGroups(NameTag, Using(Python), NameTag), nil},
+			{`(?<=^)#[^\n]*(\n|\Z)`, Comment, nil},
+			{`(?<=^)(%)([^\n]*)(\n|\Z)`, ByGroups(NameTag, Using(Python), Other), nil},
+			{`(?sx)
+                 (.+?)               # anything, followed by:
+                 (?:
+                  (?<=\n)(?=[%#]) |  # an eval or comment line
+                  (?=</?[%&]) |      # a substitution or block or
+                                     # call start or end
+                                     # - don't consume
+                  (\\\n) |           # an escaped newline
+                  \Z                 # end of string
+                 )`, ByGroups(Other, Operator), nil},
+		},
+	},
+))
--- a/vendor/github.com/alecthomas/chroma/lexers/m/mysql.go
+++ b/vendor/github.com/alecthomas/chroma/lexers/m/mysql.go
@ -0,0 +1,54 @@
+package m
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// MySQL lexer.
+var MySQL = internal.Register(MustNewLexer(
+	&Config{
+		Name:            "MySQL",
+		Aliases:         []string{"mysql"},
+		Filenames:       []string{"*.sql"},
+		MimeTypes:       []string{"text/x-mysql"},
+		NotMultiline:    true,
+		CaseInsensitive: true,
+	},
+	Rules{
+		"root": {
+			{`\s+`, Text, nil},
+			{`(#|--\s+).*\n?`, CommentSingle, nil},
+			{`/\*`, CommentMultiline, Push("multiline-comments")},
+			{`[0-9]+`, LiteralNumberInteger, nil},
+			{`[0-9]*\.[0-9]+(e[+-][0-9]+)`, LiteralNumberFloat, nil},
+			{`((?:_[a-z0-9]+)?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("string")},
+			{`((?:_[a-z0-9]+)?)(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("double-string")},
+			{"[+*/<>=~!@#%^&|`?-]", Operator, nil},
+			{`\b(tinyint|smallint|mediumint|int|integer|bigint|date|datetime|time|bit|bool|tinytext|mediumtext|longtext|text|tinyblob|mediumblob|longblob|blob|float|double|double\s+precision|real|numeric|dec|decimal|timestamp|year|char|varchar|varbinary|varcharacter|enum|set)(\b\s*)(\()?`, ByGroups(KeywordType, Text, Punctuation), nil},
+			{`\b(add|all|alter|analyze|and|as|asc|asensitive|before|between|bigint|binary|blob|both|by|call|cascade|case|change|char|character|check|collate|column|condition|constraint|continue|convert|create|cross|current_date|current_time|current_timestamp|current_user|cursor|database|databases|day_hour|day_microsecond|day_minute|day_second|dec|decimal|declare|default|delayed|delete|desc|describe|deterministic|distinct|distinctrow|div|double|drop|dual|each|else|elseif|enclosed|escaped|exists|exit|explain|fetch|flush|float|float4|float8|for|force|foreign|from|fulltext|grant|group|having|high_priority|hour_microsecond|hour_minute|hour_second|identified|if|ignore|in|index|infile|inner|inout|insensitive|insert|int|int1|int2|int3|int4|int8|integer|interval|into|is|iterate|join|key|keys|kill|leading|leave|left|like|limit|lines|load|localtime|localtimestamp|lock|long|loop|low_priority|match|minute_microsecond|minute_second|mod|modifies|natural|no_write_to_binlog|not|numeric|on|optimize|option|optionally|or|order|out|outer|outfile|precision|primary|privileges|procedure|purge|raid0|read|reads|real|references|regexp|release|rename|repeat|replace|require|restrict|return|revoke|right|rlike|schema|schemas|second_microsecond|select|sensitive|separator|set|show|smallint|soname|spatial|specific|sql|sql_big_result|sql_calc_found_rows|sql_small_result|sqlexception|sqlstate|sqlwarning|ssl|starting|straight_join|table|terminated|then|to|trailing|trigger|undo|union|unique|unlock|unsigned|update|usage|use|user|using|utc_date|utc_time|utc_timestamp|values|varying|when|where|while|with|write|x509|xor|year_month|zerofill)\b`, Keyword, nil},
+			{`\b(auto_increment|engine|charset|tables)\b`, KeywordPseudo, nil},
+			{`(true|false|null)`, NameConstant, nil},
+			{`([a-z_]\w*)(\s*)(\()`, ByGroups(NameFunction, Text, Punctuation), nil},
+			{`[a-z_]\w*`, Name, nil},
+			{`@[a-z0-9]*[._]*[a-z0-9]*`, NameVariable, nil},
+			{`[;:()\[\],.]`, Punctuation, nil},
+		},
+		"multiline-comments": {
+			{`/\*`, CommentMultiline, Push("multiline-comments")},
+			{`\*/`, CommentMultiline, Pop(1)},
+			{`[^/*]+`, CommentMultiline, nil},
+			{`[/*]`, CommentMultiline, nil},
+		},
+		"string": {
+			{`[^']+`, LiteralStringSingle, nil},
+			{`''`, LiteralStringSingle, nil},
+			{`'`, LiteralStringSingle, Pop(1)},
+		},
+		"double-string": {
+			{`[^"]+`, LiteralStringDouble, nil},
+			{`""`, LiteralStringDouble, nil},
+			{`"`, LiteralStringDouble, Pop(1)},
+		},
+	},
+))