@@ -20,7 +20,7 @@ require ( | |||
github.com/BurntSushi/toml v0.3.1 | |||
github.com/PuerkitoBio/goquery v1.5.1 | |||
github.com/RoaringBitmap/roaring v0.4.23 // indirect | |||
github.com/alecthomas/chroma v0.7.3 | |||
github.com/alecthomas/chroma v0.8.0 | |||
github.com/bgentry/speakeasy v0.1.0 // indirect | |||
github.com/blevesearch/bleve v1.0.7 | |||
github.com/couchbase/gomemcached v0.0.0-20191004160342-7b5da2ec40b2 // indirect |
@@ -69,8 +69,8 @@ github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/g | |||
github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38 h1:smF2tmSOzy2Mm+0dGI2AIUHY+w0BUc+4tn40djz7+6U= | |||
github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38/go.mod h1:r7bzyVFMNntcxPZXK3/+KdruV1H5KSlyVY0gc+NgInI= | |||
github.com/alecthomas/chroma v0.7.2-0.20200305040604-4f3623dce67a/go.mod h1:fv5SzZPFJbwp2NXJWpFIX7DZS4HgV1K4ew4Pc2OZD9s= | |||
github.com/alecthomas/chroma v0.7.3 h1:NfdAERMy+esYQs8OXk0I868/qDxxCEo7FMz1WIqMAeI= | |||
github.com/alecthomas/chroma v0.7.3/go.mod h1:sko8vR34/90zvl5QdcUdvzL3J8NKjAUx9va9jPuFNoM= | |||
github.com/alecthomas/chroma v0.8.0 h1:HS+HE97sgcqjQGu5uVr8jIE55Mmh5UeQ7kckAhHg2pY= | |||
github.com/alecthomas/chroma v0.8.0/go.mod h1:sko8vR34/90zvl5QdcUdvzL3J8NKjAUx9va9jPuFNoM= | |||
github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721 h1:JHZL0hZKJ1VENNfmXvHbgYlbUOvpzYzvy2aZU5gXVeo= | |||
github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721/go.mod h1:QO9JBoKquHd+jz9nshCh40fOfO+JzsoXy8qTHF68zU0= | |||
github.com/alecthomas/kong v0.1.17-0.20190424132513-439c674f7ae0/go.mod h1:+inYUSluD+p4L8KdviBSgzcqEjUQOfC5fQDRFuc36lI= |
@@ -20,6 +20,11 @@ linters: | |||
- wsl | |||
- gomnd | |||
- gocognit | |||
- goerr113 | |||
- nolintlint | |||
- testpackage | |||
- godot | |||
- nestif | |||
linters-settings: | |||
govet: |
@@ -4,7 +4,7 @@ go: | |||
- "1.13.x" | |||
script: | |||
- go test -v ./... | |||
- curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s v1.22.2 | |||
- curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s v1.26.0 | |||
- ./bin/golangci-lint run | |||
- git clean -fdx . | |||
after_success: |
@@ -36,7 +36,7 @@ var Bash = internal.Register(MustNewLexer( | |||
{`\b(if|fi|else|while|do|done|for|then|return|function|case|select|continue|until|esac|elif)(\s*)\b`, ByGroups(Keyword, Text), nil}, | |||
{"\\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)`])", NameBuiltin, nil}, | |||
{`\A#!.+\n`, CommentPreproc, nil}, | |||
{`#.*\S`, CommentSingle, nil}, | |||
{`#.*(\S|$)`, CommentSingle, nil}, | |||
{`\\[\w\W]`, LiteralStringEscape, nil}, | |||
{`(\b\w+)(\s*)(\+?=)`, ByGroups(NameVariable, Text, Operator), nil}, | |||
{`[\[\]{}()=]`, Operator, nil}, |
@@ -0,0 +1,206 @@ | |||
package c | |||
import ( | |||
. "github.com/alecthomas/chroma" // nolint | |||
"github.com/alecthomas/chroma/lexers/internal" | |||
) | |||
// caddyfileCommon are the rules common to both of the lexer variants | |||
var caddyfileCommon = 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 = internal.Register(MustNewLexer( | |||
&Config{ | |||
Name: "Caddyfile", | |||
Aliases: []string{"caddyfile", "caddy"}, | |||
Filenames: []string{"Caddyfile*"}, | |||
MimeTypes: []string{}, | |||
}, | |||
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(caddyfileCommon), | |||
)) | |||
// Caddyfile directive-only lexer. | |||
var CaddyfileDirectives = internal.Register(MustNewLexer( | |||
&Config{ | |||
Name: "Caddyfile Directives", | |||
Aliases: []string{"caddyfile-directives", "caddyfile-d", "caddy-d"}, | |||
Filenames: []string{}, | |||
MimeTypes: []string{}, | |||
}, | |||
Rules{ | |||
// Same as "site_block" in Caddyfile | |||
"root": { | |||
Include("site_block_common"), | |||
}, | |||
}.Merge(caddyfileCommon), | |||
)) |
@@ -1,15 +1,12 @@ | |||
package circular | |||
import ( | |||
"strings" | |||
. "github.com/alecthomas/chroma" // nolint | |||
"github.com/alecthomas/chroma/lexers/h" | |||
"github.com/alecthomas/chroma/lexers/internal" | |||
) | |||
// PHP lexer. | |||
var PHP = internal.Register(DelegatingLexer(h.HTML, MustNewLexer( | |||
// PHP lexer for pure PHP code (not embedded in HTML). | |||
var PHP = internal.Register(MustNewLexer( | |||
&Config{ | |||
Name: "PHP", | |||
Aliases: []string{"php", "php3", "php4", "php5"}, | |||
@@ -19,73 +16,65 @@ var PHP = internal.Register(DelegatingLexer(h.HTML, MustNewLexer( | |||
CaseInsensitive: true, | |||
EnsureNL: true, | |||
}, | |||
Rules{ | |||
"root": { | |||
{`<\?(php)?`, CommentPreproc, Push("php")}, | |||
{`[^<]+`, Other, nil}, | |||
{`<`, Other, nil}, | |||
}, | |||
"php": { | |||
{`\?>`, CommentPreproc, Pop(1)}, | |||
{`(<<<)([\'"]?)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)(\2\n.*?\n\s*)(\3)(;?)(\n)`, ByGroups(LiteralString, LiteralString, LiteralStringDelimiter, LiteralString, LiteralStringDelimiter, Punctuation, Text), nil}, | |||
{`\s+`, Text, nil}, | |||
{`#.*?\n`, CommentSingle, nil}, | |||
{`//.*?\n`, CommentSingle, nil}, | |||
{`/\*\*/`, CommentMultiline, nil}, | |||
{`/\*\*.*?\*/`, LiteralStringDoc, nil}, | |||
{`/\*.*?\*/`, CommentMultiline, nil}, | |||
{`(->|::)(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Operator, Text, NameAttribute), nil}, | |||
{`[~!%^&*+=|:.<>/@-]+`, Operator, nil}, | |||
{`\?`, Operator, nil}, | |||
{`[\[\]{}();,]+`, Punctuation, nil}, | |||
{`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")}, | |||
{`(function)(\s*)(?=\()`, ByGroups(Keyword, Text), nil}, | |||
{`(function)(\s+)(&?)(\s*)`, ByGroups(Keyword, Text, Operator, Text), Push("functionname")}, | |||
{`(const)(\s+)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Keyword, Text, NameConstant), nil}, | |||
{`(and|E_PARSE|old_function|E_ERROR|or|as|E_WARNING|parent|eval|PHP_OS|break|exit|case|extends|PHP_VERSION|cfunction|FALSE|print|for|require|continue|foreach|require_once|declare|return|default|static|do|switch|die|stdClass|echo|else|TRUE|elseif|var|empty|if|xor|enddeclare|include|virtual|endfor|include_once|while|endforeach|global|endif|list|endswitch|new|endwhile|not|array|E_ALL|NULL|final|php_user_filter|interface|implements|public|private|protected|abstract|clone|try|catch|throw|this|use|namespace|trait|yield|finally)\b`, Keyword, nil}, | |||
{`(true|false|null)\b`, KeywordConstant, nil}, | |||
Include("magicconstants"), | |||
{`\$\{\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*\}`, NameVariable, nil}, | |||
{`\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameVariable, nil}, | |||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameOther, nil}, | |||
{`(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, | |||
{`\d+e[+-]?[0-9]+`, LiteralNumberFloat, nil}, | |||
{`0[0-7]+`, LiteralNumberOct, nil}, | |||
{`0x[a-f0-9]+`, LiteralNumberHex, nil}, | |||
{`\d+`, LiteralNumberInteger, nil}, | |||
{`0b[01]+`, LiteralNumberBin, nil}, | |||
{`'([^'\\]*(?:\\.[^'\\]*)*)'`, LiteralStringSingle, nil}, | |||
{"`([^`\\\\]*(?:\\\\.[^`\\\\]*)*)`", LiteralStringBacktick, nil}, | |||
{`"`, LiteralStringDouble, Push("string")}, | |||
}, | |||
"magicfuncs": { | |||
{Words(``, `\b`, `__construct`, `__destruct`, `__call`, `__callStatic`, `__get`, `__set`, `__isset`, `__unset`, `__sleep`, `__wakeup`, `__toString`, `__invoke`, `__set_state`, `__clone`, `__debugInfo`), NameFunctionMagic, nil}, | |||
}, | |||
"magicconstants": { | |||
{Words(``, `\b`, `__LINE__`, `__FILE__`, `__DIR__`, `__FUNCTION__`, `__CLASS__`, `__TRAIT__`, `__METHOD__`, `__NAMESPACE__`), NameConstant, nil}, | |||
}, | |||
"classname": { | |||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameClass, Pop(1)}, | |||
}, | |||
"functionname": { | |||
Include("magicfuncs"), | |||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameFunction, Pop(1)}, | |||
Default(Pop(1)), | |||
}, | |||
"string": { | |||
{`"`, LiteralStringDouble, Pop(1)}, | |||
{`[^{$"\\]+`, LiteralStringDouble, nil}, | |||
{`\\([nrt"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})`, LiteralStringEscape, nil}, | |||
{`\$(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*(\[\S+?\]|->(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)?`, LiteralStringInterpol, nil}, | |||
{`(\{\$\{)(.*?)(\}\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil}, | |||
{`(\{)(\$.*?)(\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil}, | |||
{`(\$\{)(\S+)(\})`, ByGroups(LiteralStringInterpol, NameVariable, LiteralStringInterpol), nil}, | |||
{`[${\\]`, LiteralStringDouble, nil}, | |||
}, | |||
phpCommonRules.Rename("php", "root"), | |||
)) | |||
var phpCommonRules = Rules{ | |||
"php": { | |||
{`\?>`, CommentPreproc, Pop(1)}, | |||
{`(<<<)([\'"]?)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)(\2\n.*?\n\s*)(\3)(;?)(\n)`, ByGroups(LiteralString, LiteralString, LiteralStringDelimiter, LiteralString, LiteralStringDelimiter, Punctuation, Text), nil}, | |||
{`\s+`, Text, nil}, | |||
{`#.*?\n`, CommentSingle, nil}, | |||
{`//.*?\n`, CommentSingle, nil}, | |||
{`/\*\*/`, CommentMultiline, nil}, | |||
{`/\*\*.*?\*/`, LiteralStringDoc, nil}, | |||
{`/\*.*?\*/`, CommentMultiline, nil}, | |||
{`(->|::)(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Operator, Text, NameAttribute), nil}, | |||
{`[~!%^&*+=|:.<>/@-]+`, Operator, nil}, | |||
{`\?`, Operator, nil}, | |||
{`[\[\]{}();,]+`, Punctuation, nil}, | |||
{`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")}, | |||
{`(function)(\s*)(?=\()`, ByGroups(Keyword, Text), nil}, | |||
{`(function)(\s+)(&?)(\s*)`, ByGroups(Keyword, Text, Operator, Text), Push("functionname")}, | |||
{`(const)(\s+)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Keyword, Text, NameConstant), nil}, | |||
{`(and|E_PARSE|old_function|E_ERROR|or|as|E_WARNING|parent|eval|PHP_OS|break|exit|case|extends|PHP_VERSION|cfunction|FALSE|print|for|require|continue|foreach|require_once|declare|return|default|static|do|switch|die|stdClass|echo|else|TRUE|elseif|var|empty|if|xor|enddeclare|include|virtual|endfor|include_once|while|endforeach|global|endif|list|endswitch|new|endwhile|not|array|E_ALL|NULL|final|php_user_filter|interface|implements|public|private|protected|abstract|clone|try|catch|throw|this|use|namespace|trait|yield|finally)\b`, Keyword, nil}, | |||
{`(true|false|null)\b`, KeywordConstant, nil}, | |||
Include("magicconstants"), | |||
{`\$\{\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*\}`, NameVariable, nil}, | |||
{`\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameVariable, nil}, | |||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameOther, nil}, | |||
{`(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, | |||
{`\d+e[+-]?[0-9]+`, LiteralNumberFloat, nil}, | |||
{`0[0-7]+`, LiteralNumberOct, nil}, | |||
{`0x[a-f0-9]+`, LiteralNumberHex, nil}, | |||
{`\d+`, LiteralNumberInteger, nil}, | |||
{`0b[01]+`, LiteralNumberBin, nil}, | |||
{`'([^'\\]*(?:\\.[^'\\]*)*)'`, LiteralStringSingle, nil}, | |||
{"`([^`\\\\]*(?:\\\\.[^`\\\\]*)*)`", LiteralStringBacktick, nil}, | |||
{`"`, LiteralStringDouble, Push("string")}, | |||
}, | |||
"magicfuncs": { | |||
{Words(``, `\b`, `__construct`, `__destruct`, `__call`, `__callStatic`, `__get`, `__set`, `__isset`, `__unset`, `__sleep`, `__wakeup`, `__toString`, `__invoke`, `__set_state`, `__clone`, `__debugInfo`), NameFunctionMagic, nil}, | |||
}, | |||
"magicconstants": { | |||
{Words(``, `\b`, `__LINE__`, `__FILE__`, `__DIR__`, `__FUNCTION__`, `__CLASS__`, `__TRAIT__`, `__METHOD__`, `__NAMESPACE__`), NameConstant, nil}, | |||
}, | |||
"classname": { | |||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameClass, Pop(1)}, | |||
}, | |||
"functionname": { | |||
Include("magicfuncs"), | |||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameFunction, Pop(1)}, | |||
Default(Pop(1)), | |||
}, | |||
"string": { | |||
{`"`, LiteralStringDouble, Pop(1)}, | |||
{`[^{$"\\]+`, LiteralStringDouble, nil}, | |||
{`\\([nrt"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})`, LiteralStringEscape, nil}, | |||
{`\$(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*(\[\S+?\]|->(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)?`, LiteralStringInterpol, nil}, | |||
{`(\{\$\{)(.*?)(\}\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil}, | |||
{`(\{)(\$.*?)(\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil}, | |||
{`(\$\{)(\S+)(\})`, ByGroups(LiteralStringInterpol, NameVariable, LiteralStringInterpol), nil}, | |||
{`[${\\]`, LiteralStringDouble, nil}, | |||
}, | |||
).SetAnalyser(func(text string) float32 { | |||
if strings.Contains(text, "<?php") { | |||
return 0.5 | |||
} | |||
return 0.0 | |||
}))) | |||
} |
@@ -0,0 +1,34 @@ | |||
package circular | |||
import ( | |||
"strings" | |||
. "github.com/alecthomas/chroma" // nolint | |||
"github.com/alecthomas/chroma/lexers/h" | |||
"github.com/alecthomas/chroma/lexers/internal" | |||
) | |||
// PHTML lexer is PHP in HTML. | |||
var PHTML = internal.Register(DelegatingLexer(h.HTML, MustNewLexer( | |||
&Config{ | |||
Name: "PHTML", | |||
Aliases: []string{"phtml"}, | |||
Filenames: []string{"*.phtml"}, | |||
MimeTypes: []string{"application/x-php", "application/x-httpd-php", "application/x-httpd-php3", "application/x-httpd-php4", "application/x-httpd-php5"}, | |||
DotAll: true, | |||
CaseInsensitive: true, | |||
EnsureNL: true, | |||
}, | |||
Rules{ | |||
"root": { | |||
{`<\?(php)?`, CommentPreproc, Push("php")}, | |||
{`[^<]+`, Other, nil}, | |||
{`<`, Other, nil}, | |||
}, | |||
}.Merge(phpCommonRules), | |||
).SetAnalyser(func(text string) float32 { | |||
if strings.Contains(text, "<?php") { | |||
return 0.5 | |||
} | |||
return 0.0 | |||
}))) |
@@ -15,6 +15,7 @@ var Go = internal.Register(MustNewLexer( | |||
Aliases: []string{"go", "golang"}, | |||
Filenames: []string{"*.go"}, | |||
MimeTypes: []string{"text/x-gosrc"}, | |||
EnsureNL: true, | |||
}, | |||
Rules{ | |||
"root": { |
@@ -19,8 +19,8 @@ var HTTP = internal.Register(httpBodyContentTypeLexer(MustNewLexer( | |||
}, | |||
Rules{ | |||
"root": { | |||
{`(GET|POST|PUT|DELETE|HEAD|OPTIONS|TRACE|PATCH|CONNECT)( +)([^ ]+)( +)(HTTP)(/)(1\.[01])(\r?\n|\Z)`, ByGroups(NameFunction, Text, NameNamespace, Text, KeywordReserved, Operator, LiteralNumber, Text), Push("headers")}, | |||
{`(HTTP)(/)(1\.[01])( +)(\d{3})( +)([^\r\n]+)(\r?\n|\Z)`, ByGroups(KeywordReserved, Operator, LiteralNumber, Text, LiteralNumber, Text, NameException, Text), Push("headers")}, | |||
{`(GET|POST|PUT|DELETE|HEAD|OPTIONS|TRACE|PATCH|CONNECT)( +)([^ ]+)( +)(HTTP)(/)([12]\.[01])(\r?\n|\Z)`, ByGroups(NameFunction, Text, NameNamespace, Text, KeywordReserved, Operator, LiteralNumber, Text), Push("headers")}, | |||
{`(HTTP)(/)([12]\.[01])( +)(\d{3})( +)([^\r\n]+)(\r?\n|\Z)`, ByGroups(KeywordReserved, Operator, LiteralNumber, Text, LiteralNumber, Text, NameException, Text), Push("headers")}, | |||
}, | |||
"headers": { | |||
{`([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|\Z)`, EmitterFunc(httpHeaderBlock), nil}, |
@@ -10,7 +10,7 @@ var Ini = internal.Register(MustNewLexer( | |||
&Config{ | |||
Name: "INI", | |||
Aliases: []string{"ini", "cfg", "dosini"}, | |||
Filenames: []string{"*.ini", "*.cfg", "*.inf", ".gitconfig"}, | |||
Filenames: []string{"*.ini", "*.cfg", "*.inf", ".gitconfig", ".editorconfig"}, | |||
MimeTypes: []string{"text/x-ini", "text/inf"}, | |||
}, | |||
Rules{ |
@@ -32,6 +32,7 @@ import ( | |||
_ "github.com/alecthomas/chroma/lexers/w" | |||
_ "github.com/alecthomas/chroma/lexers/x" | |||
_ "github.com/alecthomas/chroma/lexers/y" | |||
_ "github.com/alecthomas/chroma/lexers/z" | |||
) | |||
// Registry of Lexers. |
@@ -0,0 +1,59 @@ | |||
package p | |||
import ( | |||
. "github.com/alecthomas/chroma" // nolint | |||
"github.com/alecthomas/chroma/lexers/internal" | |||
) | |||
// Pony lexer. | |||
var Pony = internal.Register(MustNewLexer( | |||
&Config{ | |||
Name: "Pony", | |||
Aliases: []string{"pony"}, | |||
Filenames: []string{"*.pony"}, | |||
MimeTypes: []string{}, | |||
}, | |||
Rules{ | |||
"root": { | |||
{`\n`, Text, nil}, | |||
{`[^\S\n]+`, Text, nil}, | |||
{`//.*\n`, CommentSingle, nil}, | |||
{`/\*`, CommentMultiline, Push("nested_comment")}, | |||
{`"""(?:.|\n)*?"""`, LiteralStringDoc, nil}, | |||
{`"`, LiteralString, Push("string")}, | |||
{`\'.*\'`, LiteralStringChar, nil}, | |||
{`=>|[]{}:().~;,|&!^?[]`, Punctuation, nil}, | |||
{Words(``, `\b`, `addressof`, `and`, `as`, `consume`, `digestof`, `is`, `isnt`, `not`, `or`), OperatorWord, nil}, | |||
{`!=|==|<<|>>|[-+/*%=<>]`, Operator, nil}, | |||
{Words(``, `\b`, `box`, `break`, `compile_error`, `compile_intrinsic`, `continue`, `do`, `else`, `elseif`, `embed`, `end`, `error`, `for`, `if`, `ifdef`, `in`, `iso`, `lambda`, `let`, `match`, `object`, `recover`, `ref`, `repeat`, `return`, `tag`, `then`, `this`, `trn`, `try`, `until`, `use`, `var`, `val`, `where`, `while`, `with`, `#any`, `#read`, `#send`, `#share`), Keyword, nil}, | |||
{`(actor|class|struct|primitive|interface|trait|type)((?:\s)+)`, ByGroups(Keyword, Text), Push("typename")}, | |||
{`(new|fun|be)((?:\s)+)`, ByGroups(Keyword, Text), Push("methodname")}, | |||
{Words(``, `\b`, `U8`, `U16`, `U32`, `U64`, `ULong`, `USize`, `U128`, `Unsigned`, `Stringable`, `String`, `StringBytes`, `StringRunes`, `InputNotify`, `InputStream`, `Stdin`, `ByteSeq`, `ByteSeqIter`, `OutStream`, `StdStream`, `SourceLoc`, `I8`, `I16`, `I32`, `I64`, `ILong`, `ISize`, `I128`, `Signed`, `Seq`, `RuntimeOptions`, `Real`, `Integer`, `SignedInteger`, `UnsignedInteger`, `FloatingPoint`, `Number`, `Int`, `ReadSeq`, `ReadElement`, `Pointer`, `Platform`, `NullablePointer`, `None`, `Iterator`, `F32`, `F64`, `Float`, `Env`, `DoNotOptimise`, `DisposableActor`, `Less`, `Equal`, `Greater`, `Compare`, `HasEq`, `Equatable`, `Comparable`, `Bool`, `AsioEventID`, `AsioEventNotify`, `AsioEvent`, `Array`, `ArrayKeys`, `ArrayValues`, `ArrayPairs`, `Any`, `AmbientAuth`), KeywordType, nil}, | |||
{`_?[A-Z]\w*`, NameClass, nil}, | |||
{`string\(\)`, NameOther, nil}, | |||
{`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+`, LiteralNumberFloat, nil}, | |||
{`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, | |||
{`\d+`, LiteralNumberInteger, nil}, | |||
{`(true|false)\b`, Keyword, nil}, | |||
{`_\d*`, Name, nil}, | |||
{`_?[a-z][\w\'_]*`, Name, nil}, | |||
}, | |||
"typename": { | |||
{`(iso|trn|ref|val|box|tag)?((?:\s)*)(_?[A-Z]\w*)`, ByGroups(Keyword, Text, NameClass), Pop(1)}, | |||
}, | |||
"methodname": { | |||
{`(iso|trn|ref|val|box|tag)?((?:\s)*)(_?[a-z]\w*)`, ByGroups(Keyword, Text, NameFunction), Pop(1)}, | |||
}, | |||
"nested_comment": { | |||
{`[^*/]+`, CommentMultiline, nil}, | |||
{`/\*`, CommentMultiline, Push()}, | |||
{`\*/`, CommentMultiline, Pop(1)}, | |||
{`[*/]`, CommentMultiline, nil}, | |||
}, | |||
"string": { | |||
{`"`, LiteralString, Pop(1)}, | |||
{`\\"`, LiteralString, nil}, | |||
{`[^\\"]+`, LiteralString, nil}, | |||
}, | |||
}, | |||
)) |
@@ -22,7 +22,7 @@ var TOML = internal.Register(MustNewLexer( | |||
{`[+-]?[0-9](_?\d)*`, LiteralNumberInteger, nil}, | |||
{`"(\\\\|\\"|[^"])*"`, StringDouble, nil}, | |||
{`'(\\\\|\\'|[^'])*'`, StringSingle, nil}, | |||
{`[.,=\[\]]`, Punctuation, nil}, | |||
{`[.,=\[\]{}]`, Punctuation, nil}, | |||
{`[^\W\d]\w*`, NameOther, nil}, | |||
}, | |||
}, |
@@ -38,14 +38,14 @@ var TypeScript = internal.Register(MustNewLexer( | |||
{`\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?`, Operator, Push("slashstartsregex")}, | |||
{`[{(\[;,]`, Punctuation, Push("slashstartsregex")}, | |||
{`[})\].]`, Punctuation, nil}, | |||
{`(for|in|while|do|break|return|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|void|this)\b`, Keyword, Push("slashstartsregex")}, | |||
{`(for|in|of|while|do|break|return|yield|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|keyof|asserts|is|infer|await|void|this)\b`, Keyword, Push("slashstartsregex")}, | |||
{`(var|let|with|function)\b`, KeywordDeclaration, Push("slashstartsregex")}, | |||
{`(abstract|boolean|byte|char|class|const|debugger|double|enum|export|extends|final|float|goto|implements|import|int|interface|long|native|package|private|protected|public|short|static|super|synchronized|throws|transient|volatile)\b`, KeywordReserved, nil}, | |||
{`(abstract|async|boolean|class|const|debugger|enum|export|extends|from|get|global|goto|implements|import|interface|namespace|package|private|protected|public|readonly|require|set|static|super|type)\b`, KeywordReserved, nil}, | |||
{`(true|false|null|NaN|Infinity|undefined)\b`, KeywordConstant, nil}, | |||
{`(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\b`, NameBuiltin, nil}, | |||
{`(Array|Boolean|Date|Error|Function|Math|Number|Object|Packages|RegExp|String|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\b`, NameBuiltin, nil}, | |||
{`\b(module)(\s*)(\s*[\w?.$][\w?.$]*)(\s*)`, ByGroups(KeywordReserved, Text, NameOther, Text), Push("slashstartsregex")}, | |||
{`\b(string|bool|number)\b`, KeywordType, nil}, | |||
{`\b(constructor|declare|interface|as|AS)\b`, KeywordReserved, nil}, | |||
{`\b(string|bool|number|any|never|object|symbol|unique|unknown|bigint)\b`, KeywordType, nil}, | |||
{`\b(constructor|declare|interface|as)\b`, KeywordReserved, nil}, | |||
{`(super)(\s*)(\([\w,?.$\s]+\s*\))`, ByGroups(KeywordReserved, Text), Push("slashstartsregex")}, | |||
{`([a-zA-Z_?.$][\w?.$]*)\(\) \{`, NameOther, Push("slashstartsregex")}, | |||
{`([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)`, ByGroups(NameOther, Text, KeywordType), nil}, |
@@ -15,32 +15,35 @@ var YAML = internal.Register(MustNewLexer( | |||
Rules{ | |||
"root": { | |||
Include("whitespace"), | |||
{`^---`, Text, nil}, | |||
{`^---`, NameNamespace, nil}, | |||
{`^\.\.\.`, NameNamespace, nil}, | |||
{`[\n?]?\s*- `, Text, nil}, | |||
{`#.*$`, Comment, nil}, | |||
{`!![^\s]+`, CommentPreproc, nil}, | |||
{`&[^\s]+`, CommentPreproc, nil}, | |||
{`\*[^\s]+`, CommentPreproc, nil}, | |||
{`^%include\s+[^\n\r]+`, CommentPreproc, nil}, | |||
{`([>|+-]\s+)(\s+)((?:(?:.*?$)(?:[\n\r]*?)?)*)`, ByGroups(StringDoc, StringDoc, StringDoc), nil}, | |||
{`[>|](?:[+-])?\s(?:^(?:[ \n]{1})+.*\n?)*$`, StringDoc, nil}, | |||
Include("key"), | |||
Include("value"), | |||
{`[?:,\[\]]`, Punctuation, nil}, | |||
{`.`, Text, nil}, | |||
}, | |||
"value": { | |||
{Words(``, `\b`, "true", "false", "null"), KeywordConstant, nil}, | |||
{Words(``, `\b`, "true", "True", "TRUE", "false", "False", "FALSE", "null", | |||
"y", "Y", "yes", "Yes", "YES", "n", "N", "no", "No", "NO", | |||
"on", "On", "ON", "off", "Off", "OFF"), KeywordConstant, nil}, | |||
{`"(?:\\.|[^"])*"`, StringDouble, nil}, | |||
{`'(?:\\.|[^'])*'`, StringSingle, nil}, | |||
{`\d\d\d\d-\d\d-\d\d([T ]\d\d:\d\d:\d\d(\.\d+)?(Z|\s+[-+]\d+)?)?`, LiteralDate, nil}, | |||
{`\b[+\-]?(0x[\da-f]+|0o[0-7]+|(\d+\.?\d*|\.?\d+)(e[\+\-]?\d+)?|\.inf|\.nan)\b`, Number, nil}, | |||
{`\b[\w]+\b`, Text, nil}, | |||
{`[^\{\}\[\]\?,\:\!\-\*&\@].*`, Literal, nil}, | |||
}, | |||
"key": { | |||
{`"[^"\n].*": `, Keyword, nil}, | |||
{`(-)( )([^"\n{]*)(:)( )`, ByGroups(Punctuation, Whitespace, Keyword, Punctuation, Whitespace), nil}, | |||
{`([^"\n{]*)(:)( )`, ByGroups(Keyword, Punctuation, Whitespace), nil}, | |||
{`([^"\n{]*)(:)(\n)`, ByGroups(Keyword, Punctuation, Whitespace), nil}, | |||
{`"[^"\n].*": `, NameTag, nil}, | |||
{`(-)( )([^"\n{]*)(:)( )`, ByGroups(Punctuation, Whitespace, NameTag, Punctuation, Whitespace), nil}, | |||
{`([^"\n{]*)(:)( )`, ByGroups(NameTag, Punctuation, Whitespace), nil}, | |||
{`([^"\n{]*)(:)(\n)`, ByGroups(NameTag, Punctuation, Whitespace), nil}, | |||
}, | |||
"whitespace": { | |||
{`\s+`, Whitespace, nil}, |
@@ -0,0 +1,54 @@ | |||
package z | |||
import ( | |||
. "github.com/alecthomas/chroma" // nolint | |||
"github.com/alecthomas/chroma/lexers/internal" | |||
) | |||
// Zig lexer. | |||
var Zig = internal.Register(MustNewLexer( | |||
&Config{ | |||
Name: "Zig", | |||
Aliases: []string{"zig"}, | |||
Filenames: []string{"*.zig"}, | |||
MimeTypes: []string{"text/zig"}, | |||
}, | |||
Rules{ | |||
"root": { | |||
{`\n`, TextWhitespace, nil}, | |||
{`\s+`, TextWhitespace, nil}, | |||
{`//.*?\n`, CommentSingle, nil}, | |||
{Words(``, `\b`, `break`, `return`, `continue`, `asm`, `defer`, `errdefer`, `unreachable`, `try`, `catch`, `async`, `await`, `suspend`, `resume`, `cancel`), Keyword, nil}, | |||
{Words(``, `\b`, `const`, `var`, `extern`, `packed`, `export`, `pub`, `noalias`, `inline`, `comptime`, `nakedcc`, `stdcallcc`, `volatile`, `allowzero`, `align`, `linksection`, `threadlocal`), KeywordReserved, nil}, | |||
{Words(``, `\b`, `struct`, `enum`, `union`, `error`), Keyword, nil}, | |||
{Words(``, `\b`, `while`, `for`), Keyword, nil}, | |||
{Words(``, `\b`, `bool`, `f16`, `f32`, `f64`, `f128`, `void`, `noreturn`, `type`, `anyerror`, `promise`, `i0`, `u0`, `isize`, `usize`, `comptime_int`, `comptime_float`, `c_short`, `c_ushort`, `c_int`, `c_uint`, `c_long`, `c_ulong`, `c_longlong`, `c_ulonglong`, `c_longdouble`, `c_voidi8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`), KeywordType, nil}, | |||
{Words(``, `\b`, `true`, `false`, `null`, `undefined`), KeywordConstant, nil}, | |||
{Words(``, `\b`, `if`, `else`, `switch`, `and`, `or`, `orelse`), Keyword, nil}, | |||
{Words(``, `\b`, `fn`, `usingnamespace`, `test`), Keyword, nil}, | |||
{`0x[0-9a-fA-F]+\.[0-9a-fA-F]+([pP][\-+]?[0-9a-fA-F]+)?`, LiteralNumberFloat, nil}, | |||
{`0x[0-9a-fA-F]+\.?[pP][\-+]?[0-9a-fA-F]+`, LiteralNumberFloat, nil}, | |||
{`[0-9]+\.[0-9]+([eE][-+]?[0-9]+)?`, LiteralNumberFloat, nil}, | |||
{`[0-9]+\.?[eE][-+]?[0-9]+`, LiteralNumberFloat, nil}, | |||
{`0b[01]+`, LiteralNumberBin, nil}, | |||
{`0o[0-7]+`, LiteralNumberOct, nil}, | |||
{`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, | |||
{`[0-9]+`, LiteralNumberInteger, nil}, | |||
{`@[a-zA-Z_]\w*`, NameBuiltin, nil}, | |||
{`[a-zA-Z_]\w*`, Name, nil}, | |||
{`\'\\\'\'`, LiteralStringEscape, nil}, | |||
{`\'\\(|x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])\'`, LiteralStringEscape, nil}, | |||
{`\'[^\\\']\'`, LiteralString, nil}, | |||
{`\\\\[^\n]*`, LiteralStringHeredoc, nil}, | |||
{`c\\\\[^\n]*`, LiteralStringHeredoc, nil}, | |||
{`c?"`, LiteralString, Push("string")}, | |||
{`[+%=><|^!?/\-*&~:]`, Operator, nil}, | |||
{`[{}()\[\],.;]`, Punctuation, nil}, | |||
}, | |||
"string": { | |||
{`\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])`, LiteralStringEscape, nil}, | |||
{`[^\\"\n]+`, LiteralString, nil}, | |||
{`"`, LiteralString, Pop(1)}, | |||
}, | |||
}, | |||
)) |
@@ -6,6 +6,7 @@ import ( | |||
"regexp" | |||
"strings" | |||
"sync" | |||
"time" | |||
"unicode/utf8" | |||
"github.com/dlclark/regexp2" | |||
@@ -160,6 +161,14 @@ func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, erro | |||
// Rules maps from state to a sequence of Rules. | |||
type Rules map[string][]Rule | |||
// Rename clones rules then a rule. | |||
func (r Rules) Rename(old, new string) Rules { | |||
r = r.Clone() | |||
r[new] = r[old] | |||
delete(r, old) | |||
return r | |||
} | |||
// Clone returns a clone of the Rules. | |||
func (r Rules) Clone() Rules { | |||
out := map[string][]Rule{} | |||
@@ -170,6 +179,15 @@ func (r Rules) Clone() Rules { | |||
return out | |||
} | |||
// Merge creates a clone of "r" then merges "rules" into the clone. | |||
func (r Rules) Merge(rules Rules) Rules { | |||
out := r.Clone() | |||
for k, v := range rules.Clone() { | |||
out[k] = v | |||
} | |||
return out | |||
} | |||
// MustNewLexer creates a new Lexer or panics. | |||
func MustNewLexer(config *Config, rules Rules) *RegexLexer { | |||
lexer, err := NewLexer(config, rules) | |||
@@ -376,6 +394,7 @@ func (r *RegexLexer) maybeCompile() (err error) { | |||
if err != nil { | |||
return fmt.Errorf("failed to compile rule %s.%d: %s", state, i, err) | |||
} | |||
rule.Regexp.MatchTimeout = time.Millisecond * 250 | |||
} | |||
} | |||
} |
@@ -62,7 +62,7 @@ github.com/PuerkitoBio/urlesc | |||
# github.com/RoaringBitmap/roaring v0.4.23 | |||
## explicit | |||
github.com/RoaringBitmap/roaring | |||
# github.com/alecthomas/chroma v0.7.3 | |||
# github.com/alecthomas/chroma v0.8.0 | |||
## explicit | |||
github.com/alecthomas/chroma | |||
github.com/alecthomas/chroma/formatters/html | |||
@@ -93,6 +93,7 @@ github.com/alecthomas/chroma/lexers/v | |||
github.com/alecthomas/chroma/lexers/w | |||
github.com/alecthomas/chroma/lexers/x | |||
github.com/alecthomas/chroma/lexers/y | |||
github.com/alecthomas/chroma/lexers/z | |||
github.com/alecthomas/chroma/styles | |||
# github.com/andybalholm/brotli v0.0.0-20190621154722-5f990b63d2d6 | |||
github.com/andybalholm/brotli |