diff options
Diffstat (limited to 'vendor/github.com/alecthomas/chroma/v2')
292 files changed, 42287 insertions, 0 deletions
diff --git a/vendor/github.com/alecthomas/chroma/v2/.gitignore b/vendor/github.com/alecthomas/chroma/v2/.gitignore new file mode 100644 index 0000000..ccacd12 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/.gitignore @@ -0,0 +1,19 @@ +# Binaries for programs and plugins +*.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/ diff --git a/vendor/github.com/alecthomas/chroma/v2/.golangci.yml b/vendor/github.com/alecthomas/chroma/v2/.golangci.yml new file mode 100644 index 0000000..a06e95e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/.golangci.yml @@ -0,0 +1,78 @@ +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 + +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' diff --git a/vendor/github.com/alecthomas/chroma/v2/.goreleaser.yml b/vendor/github.com/alecthomas/chroma/v2/.goreleaser.yml new file mode 100644 index 0000000..8cd7592 --- /dev/null +++ b/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' diff --git a/vendor/github.com/alecthomas/chroma/v2/COPYING b/vendor/github.com/alecthomas/chroma/v2/COPYING new file mode 100644 index 0000000..92dc39f --- /dev/null +++ b/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. diff --git a/vendor/github.com/alecthomas/chroma/v2/Makefile b/vendor/github.com/alecthomas/chroma/v2/Makefile new file mode 100644 index 0000000..34e3c41 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/Makefile @@ -0,0 +1,19 @@ +.PHONY: chromad upload all + +VERSION ?= $(shell git describe --tags --dirty --always) + +all: README.md tokentype_string.go + +README.md: lexers/*/*.go + ./table.py + +tokentype_string.go: types.go + go generate + +chromad: + rm -f chromad + (export CGOENABLED=0 GOOS=linux GOARCH=amd64; cd ./cmd/chromad && go build -ldflags="-X 'main.version=$(VERSION)'" -o ../../chromad .) + +upload: chromad + scp chromad root@swapoff.org: && \ + ssh root@swapoff.org 'install -m755 ./chromad /srv/http/swapoff.org/bin && service chromad restart' diff --git a/vendor/github.com/alecthomas/chroma/v2/README.md b/vendor/github.com/alecthomas/chroma/v2/README.md new file mode 100644 index 0000000..445fb96 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/README.md @@ -0,0 +1,285 @@ +# Chroma — A general purpose syntax highlighter in pure Go +[](https://godoc.org/github.com/alecthomas/chroma) [](https://github.com/alecthomas/chroma/actions/workflows/ci.yml) [](https://invite.slack.golangbridge.org/) + +> **NOTE:** As Chroma has just been released, its API is still in flux. That said, the high-level interface should not change significantly. + +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. [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, Angular2, ANTLR, ApacheConf, APL, AppleScript, Arduino, Awk +B | Ballerina, Base Makefile, Bash, Batchfile, BibTeX, Bicep, BlitzBasic, BNF, Brainfuck +C | C, C#, C++, Caddyfile, Caddyfile Directives, Cap'n Proto, Cassandra CQL, Ceylon, CFEngine3, cfstatement, ChaiScript, Cheetah, Clojure, CMake, COBOL, CoffeeScript, Common Lisp, Coq, Crystal, CSS, Cython +D | D, Dart, Diff, Django/Jinja, Docker, DTD, Dylan +E | EBNF, Elixir, Elm, EmacsLisp, Erlang +F | Factor, Fish, Forth, Fortran, 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, HTML, HTTP, Hy +I | Idris, Igor, INI, Io +J | J, Java, JavaScript, JSON, Julia, Jungle +K | Kotlin +L | Lighttpd configuration file, LLVM, Lua +M | Mako, markdown, Mason, Mathematica, Matlab, MiniZinc, MLIR, Modula-2, MonkeyC, MorrowindScript, Myghty, MySQL +N | NASM, Newspeak, Nginx configuration file, Nim, Nix +O | Objective-C, OCaml, Octave, OnesEnterprise, OpenEdge ABL, OpenSCAD, Org Mode +P | PacmanConf, Perl, PHP, PHTML, Pig, PkgConfig, PL/pgSQL, plaintext, Pony, PostgreSQL SQL dialect, PostScript, POVRay, PowerShell, Prolog, PromQL, Protocol Buffer, Puppet, Python 2, Python +Q | QBasic +R | R, Racket, Ragel, Raku, react, ReasonML, reg, reStructuredText, Rexx, Ruby, Rust +S | SAS, Sass, Scala, Scheme, Scilab, SCSS, Smalltalk, Smarty, Snobol, Solidity, SPARQL, SQL, SquidConf, Standard ML, Stylus, Svelte, Swift, SYSTEMD, systemverilog +T | TableGen, TASM, Tcl, Tcsh, Termcap, Terminfo, Terraform, TeX, Thrift, TOML, TradingView, Transact-SQL, Turing, Turtle, Twig, TypeScript, TypoScript, TypoScriptCssData, TypoScriptHtmlData +V | VB.net, verilog, VHDL, VimL, vue +W | WDTE +X | XML, Xorg +Y | YAML, YANG +Z | 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") + ``` + +3. 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`). +- `LinkableLineNumbers()` - 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.py`. I use something like +the following: + +```sh +python3 _tools/pygments2chroma.py \ + pygments.lexers.jvm.KotlinLexer \ + > lexers/k/kotlin.go \ + && gofmt -s -w lexers/k/kotlin.go +``` + +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 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 `chroma.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: + +~~~go +chroma.Background: "#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> +## 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. diff --git a/vendor/github.com/alecthomas/chroma/v2/coalesce.go b/vendor/github.com/alecthomas/chroma/v2/coalesce.go new file mode 100644 index 0000000..f504895 --- /dev/null +++ b/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 +} diff --git a/vendor/github.com/alecthomas/chroma/v2/colour.go b/vendor/github.com/alecthomas/chroma/v2/colour.go new file mode 100644 index 0000000..15d794c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/colour.go @@ -0,0 +1,164 @@ +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 brighteness 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) +} + +// 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 +} diff --git a/vendor/github.com/alecthomas/chroma/v2/delegate.go b/vendor/github.com/alecthomas/chroma/v2/delegate.go new file mode 100644 index 0000000..f848194 --- /dev/null +++ b/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 +} diff --git a/vendor/github.com/alecthomas/chroma/v2/doc.go b/vendor/github.com/alecthomas/chroma/v2/doc.go new file mode 100644 index 0000000..4dde77c --- /dev/null +++ b/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 diff --git a/vendor/github.com/alecthomas/chroma/v2/emitters.go b/vendor/github.com/alecthomas/chroma/v2/emitters.go new file mode 100644 index 0000000..67b80a8 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/emitters.go @@ -0,0 +1,221 @@ +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. +// +// The sublexer will be retrieved using sublexerGetFunc (typically +// internal.Get), using the captured value from the matched sublexerNameGroup. +// +// If sublexerGetFunc returns a non-nil lexer for the captured sublexerNameGroup, +// then tokens for the matched codeGroup will be emitted using the retrieved +// lexer. Otherwise, if the sublexer is nil, 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( +// internal.Get, +// 2, 4, +// String, String, String, Text, String, +// ), +// nil, +// }, +// }, +// }, +// )) +// +// See the lexers/m/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} +} diff --git a/vendor/github.com/alecthomas/chroma/v2/formatter.go b/vendor/github.com/alecthomas/chroma/v2/formatter.go new file mode 100644 index 0000000..00dd5d8 --- /dev/null +++ b/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} } diff --git a/vendor/github.com/alecthomas/chroma/v2/formatters/html/html.go b/vendor/github.com/alecthomas/chroma/v2/formatters/html/html.go new file mode 100644 index 0000000..0a45d87 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/formatters/html/html.go @@ -0,0 +1,563 @@ +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 + } +} + +// LinkableLineNumbers decorates the line numbers HTML elements with an "id" +// attribute so they can be linked. +func LinkableLineNumbers(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 tabindex="0"%s><code>`, styleAttr) + } + + return fmt.Sprintf(`<pre tabindex="0"%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(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(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(lineDigits, line int) string { + title := fmt.Sprintf("%*d", lineDigits, line) + if !f.linkableLineNumbers { + return title + } + return fmt.Sprintf("<a style=\"outline: none; text-decoration:none; color:inherit\" href=\"#%s\">%s</a>", 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; 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] + 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, ";") +} diff --git a/vendor/github.com/alecthomas/chroma/v2/iterator.go b/vendor/github.com/alecthomas/chroma/v2/iterator.go new file mode 100644 index 0000000..d5175de --- /dev/null +++ b/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 +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexer.go b/vendor/github.com/alecthomas/chroma/v2/lexer.go new file mode 100644 index 0000000..4a1bd0f --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexer.go @@ -0,0 +1,142 @@ +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"` +} + +// 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 +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/README.md b/vendor/github.com/alecthomas/chroma/v2/lexers/README.md new file mode 100644 index 0000000..b4ed292 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/README.md @@ -0,0 +1,40 @@ +# 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>.exported`. + +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 tests ./lexers`. + +Chroma will now regenerate the test files and print its results to the console window. diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/bash.go b/vendor/github.com/alecthomas/chroma/v2/lexers/bash.go new file mode 100644 index 0000000..1ea30f2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/bash.go @@ -0,0 +1,17 @@ +package lexers + +import ( + "regexp" +) + +// TODO(moorereason): can this be factored away? +var bashAnalyserRe = regexp.MustCompile(`(?m)^#!.*/bin/(?:env |)(?:bash|zsh|sh|ksh)`) + +func init() { // nolint: gochecknoinits + Get("bash").SetAnalyser(func(text string) float32 { + if bashAnalyserRe.FindString(text) != "" { + return 1.0 + } + return 0.0 + }) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/bashsession.go b/vendor/github.com/alecthomas/chroma/v2/lexers/bashsession.go new file mode 100644 index 0000000..bea9393 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/bashsession.go @@ -0,0 +1,26 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// BashSession lexer. +var BashSession = Register(MustNewLexer( + &Config{ + Name: "BashSession", + Aliases: []string{"bash-session", "console", "shell-session"}, + Filenames: []string{".sh-session"}, + MimeTypes: []string{"text/x-sh"}, + EnsureNL: true, + }, + bashsessionRules, +)) + +func bashsessionRules() Rules { + return Rules{ + "root": { + {`^((?:\[[^]]+@[^]]+\]\s?)?[#$%>])(\s*)(.*\n?)`, ByGroups(GenericPrompt, Text, Using("Bash")), nil}, + {`^.+\n?`, GenericOutput, nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/caddyfile.go b/vendor/github.com/alecthomas/chroma/v2/lexers/caddyfile.go new file mode 100644 index 0000000..9100efa --- /dev/null +++ b/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()) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/cheetah.go b/vendor/github.com/alecthomas/chroma/v2/lexers/cheetah.go new file mode 100644 index 0000000..7eea429 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/cheetah.go @@ -0,0 +1,39 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Cheetah lexer. +var Cheetah = Register(MustNewLexer( + &Config{ + Name: "Cheetah", + Aliases: []string{"cheetah", "spitfire"}, + Filenames: []string{"*.tmpl", "*.spt"}, + MimeTypes: []string{"application/x-cheetah", "application/x-spitfire"}, + }, + cheetahRules, +)) + +func cheetahRules() Rules { + return Rules{ + "root": { + {`(##[^\n]*)$`, ByGroups(Comment), nil}, + {`#[*](.|\n)*?[*]#`, Comment, nil}, + {`#end[^#\n]*(?:#|$)`, CommentPreproc, nil}, + {`#slurp$`, CommentPreproc, nil}, + {`(#[a-zA-Z]+)([^#\n]*)(#|$)`, ByGroups(CommentPreproc, Using("Python"), CommentPreproc), nil}, + {`(\$)([a-zA-Z_][\w.]*\w)`, ByGroups(CommentPreproc, Using("Python")), nil}, + {`(\$\{!?)(.*?)(\})(?s)`, ByGroups(CommentPreproc, Using("Python"), CommentPreproc), nil}, + {`(?sx) + (.+?) # anything, followed by: + (?: + (?=\#[#a-zA-Z]*) | # an eval comment + (?=\$[a-zA-Z_{]) | # a substitution + \Z # end of string + ) + `, Other, nil}, + {`\s+`, Text, nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/cl.go b/vendor/github.com/alecthomas/chroma/v2/lexers/cl.go new file mode 100644 index 0000000..3eb0c23 --- /dev/null +++ b/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}, +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/cql.go b/vendor/github.com/alecthomas/chroma/v2/lexers/cql.go new file mode 100644 index 0000000..32f7a28 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/cql.go @@ -0,0 +1,70 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// CassandraCQL lexer. +var CassandraCQL = Register(MustNewLexer( + &Config{ + Name: "Cassandra CQL", + Aliases: []string{"cassandra", "cql"}, + Filenames: []string{"*.cql"}, + MimeTypes: []string{"text/x-cql"}, + NotMultiline: true, + CaseInsensitive: true, + }, + cassandraCQLRules, +)) + +func cassandraCQLRules() Rules { + return Rules{ + "root": { + {`\s+`, TextWhitespace, nil}, + {`(--|\/\/).*\n?`, CommentSingle, nil}, + {`/\*`, CommentMultiline, Push("multiline-comments")}, + {`(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`, NameBuiltin, nil}, + {Words(``, `\b`, `ADD`, `AGGREGATE`, `ALL`, `ALLOW`, `ALTER`, `AND`, `ANY`, `APPLY`, `AS`, `ASC`, `AUTHORIZE`, `BATCH`, `BEGIN`, `BY`, `CLUSTERING`, `COLUMNFAMILY`, `COMPACT`, `CONSISTENCY`, `COUNT`, `CREATE`, `CUSTOM`, `DELETE`, `DESC`, `DISTINCT`, `DROP`, `EACH_QUORUM`, `ENTRIES`, `EXISTS`, `FILTERING`, `FROM`, `FULL`, `GRANT`, `IF`, `IN`, `INDEX`, `INFINITY`, `INSERT`, `INTO`, `KEY`, `KEYS`, `KEYSPACE`, `KEYSPACES`, `LEVEL`, `LIMIT`, `LOCAL_ONE`, `LOCAL_QUORUM`, `MATERIALIZED`, `MODIFY`, `NAN`, `NORECURSIVE`, `NOSUPERUSER`, `NOT`, `OF`, `ON`, `ONE`, `ORDER`, `PARTITION`, `PASSWORD`, `PER`, `PERMISSION`, `PERMISSIONS`, `PRIMARY`, `QUORUM`, `RENAME`, `REVOKE`, `SCHEMA`, `SELECT`, `STATIC`, `STORAGE`, `SUPERUSER`, `TABLE`, `THREE`, `TO`, `TOKEN`, `TRUNCATE`, `TTL`, `TWO`, `TYPE`, `UNLOGGED`, `UPDATE`, `USE`, `USER`, `USERS`, `USING`, `VALUES`, `VIEW`, `WHERE`, `WITH`, `WRITETIME`, `REPLICATION`, `OR`, `REPLACE`, `FUNCTION`, `CALLED`, `INPUT`, `RETURNS`, `LANGUAGE`, `ROLE`, `ROLES`, `TRIGGER`, `DURABLE_WRITES`, `LOGIN`, `OPTIONS`, `LOGGED`, `SFUNC`, `STYPE`, `FINALFUNC`, `INITCOND`, `IS`, `CONTAINS`, `JSON`, `PAGING`, `OFF`), Keyword, nil}, + {"[+*/<>=~!@#%^&|`?-]+", Operator, nil}, + { + `(?s)(java|javascript)(\s+)(AS)(\s+)('|\$\$)(.*?)(\5)`, + UsingByGroup(1, 6, + NameBuiltin, TextWhitespace, Keyword, TextWhitespace, + LiteralStringHeredoc, LiteralStringHeredoc, LiteralStringHeredoc), + nil, + }, + {`(true|false|null)\b`, KeywordConstant, nil}, + {`0x[0-9a-f]+`, LiteralNumberHex, nil}, + {`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`, LiteralNumberHex, nil}, + {`\.[0-9]+(e[+-]?[0-9]+)?`, Error, nil}, + {`-?[0-9]+(\.[0-9])?(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, + {`[0-9]+`, LiteralNumberInteger, nil}, + {`'`, LiteralStringSingle, Push("string")}, + {`"`, LiteralStringName, Push("quoted-ident")}, + {`\$\$`, LiteralStringHeredoc, Push("dollar-string")}, + {`[a-z_]\w*`, Name, nil}, + {`:(['"]?)[a-z]\w*\b\1`, 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)}, + }, + "quoted-ident": { + {`[^"]+`, LiteralStringName, nil}, + {`""`, LiteralStringName, nil}, + {`"`, LiteralStringName, Pop(1)}, + }, + "dollar-string": { + {`[^\$]+`, LiteralStringHeredoc, nil}, + {`\$\$`, LiteralStringHeredoc, Pop(1)}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/docker.go b/vendor/github.com/alecthomas/chroma/v2/lexers/docker.go new file mode 100644 index 0000000..e14654a --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/docker.go @@ -0,0 +1,32 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Docker lexer. +var Docker = Register(MustNewLexer( + &Config{ + Name: "Docker", + Aliases: []string{"docker", "dockerfile"}, + Filenames: []string{"Dockerfile", "*.docker"}, + MimeTypes: []string{"text/x-dockerfile-config"}, + CaseInsensitive: true, + }, + dockerRules, +)) + +func dockerRules() Rules { + return Rules{ + "root": { + {`#.*`, Comment, nil}, + {`(ONBUILD)((?:\s*\\?\s*))`, ByGroups(Keyword, Using("Bash")), nil}, + {`(HEALTHCHECK)(((?:\s*\\?\s*)--\w+=\w+(?:\s*\\?\s*))*)`, ByGroups(Keyword, Using("Bash")), nil}, + {`(VOLUME|ENTRYPOINT|CMD|SHELL)((?:\s*\\?\s*))(\[.*?\])`, ByGroups(Keyword, Using("Bash"), Using("JSON")), nil}, + {`(LABEL|ENV|ARG)((?:(?:\s*\\?\s*)\w+=\w+(?:\s*\\?\s*))*)`, ByGroups(Keyword, Using("Bash")), nil}, + {`((?:FROM|MAINTAINER|EXPOSE|WORKDIR|USER|STOPSIGNAL)|VOLUME)\b(.*)`, ByGroups(Keyword, LiteralString), nil}, + {`((?:RUN|CMD|ENTRYPOINT|ENV|ARG|LABEL|ADD|COPY))`, Keyword, nil}, + {`(.*\\\n)*.+`, Using("Bash"), nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/emacs.go b/vendor/github.com/alecthomas/chroma/v2/lexers/emacs.go new file mode 100644 index 0000000..869b0f3 --- /dev/null +++ b/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}, +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/abap.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/abap.xml new file mode 100644 index 0000000..e8140b7 --- /dev/null +++ b/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="\".*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="##\w+"> + <token type="CommentSpecial"/> + </rule> + </state> + <state name="variable-names"> + <rule pattern="<\S+>"> + <token type="NameVariable"/> + </rule> + <rule pattern="\w[\w~]*(?:(\[\])|->\*)?"> + <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\-]+)([=\-]>)([\w\-~]+)"> + <bygroups> + <token type="Text"/> + <token type="NameVariable"/> + <token type="Operator"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="(?<=(=|-)>)([\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="(?<![-\>])(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="(^|(?<=(\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="&[0-9]"> + <token type="Name"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(?<=(\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="[?*<>=\-+&]"> + <token type="Operator"/> + </rule> + <rule pattern="'(''|[^'])*'"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/abnf.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/abnf.xml new file mode 100644 index 0000000..3ffd51c --- /dev/null +++ b/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])?"[^"]*""> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/actionscript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/actionscript.xml new file mode 100644 index 0000000..d6727a1 --- /dev/null +++ b/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="[~^*!%&<>|+=:;,/?\\-]+"> + <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=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/actionscript_3.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/actionscript_3.xml new file mode 100644 index 0000000..e5f6538 --- /dev/null +++ b/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*(?:\.<\w+>)?|\*)(\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*(?:\.<\w+>)?|\*)"> + <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*(?:\.<\w+>)?)"> + <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*(?:\.<\w+>)?)(\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=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[~^*!%&<>|+=:;,/?\\{}\[\]().-]+"> + <token type="Operator"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ada.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ada.xml new file mode 100644 index 0000000..5854a20 --- /dev/null +++ b/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=""[^"]+"|[\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="("[^"]+"|\w+)(\s+)(=>)"> + <bygroups> + <token type="NameVariable"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="[\w.\'"]"> + <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=""[^"]+"|\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="(')(\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="<<\w+>>"> + <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=""[^"]*""> + <token type="LiteralString"/> + </rule> + <rule> + <include state="attribute"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule pattern="'[^']'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="(\w+)(\s*|[(,])"> + <bygroups> + <token type="Name"/> + <usingself state="root"/> + </bygroups> + </rule> + <rule pattern="(<>|=>|:=|[()|:;,.'])"> + <token type="Punctuation"/> + </rule> + <rule pattern="[*<>+=/&-]"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/al.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/al.xml new file mode 100644 index 0000000..30bad5a --- /dev/null +++ b/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="\"([^\"])*\""> + <token type="Text"/> + </rule> + <rule pattern="'([^'])*'"> + <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([<>]=|<>|<|>)\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*[(\.\.)&\|]\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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/angular2.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/angular2.xml new file mode 100644 index 0000000..84fe20b --- /dev/null +++ b/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="".*?""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="'.*?'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\s>]+"> + <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=":?"(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=":?'(\\\\|\\'|[^'])*'"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/antlr.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/antlr.xml new file mode 100644 index 0000000..e57edd4 --- /dev/null +++ b/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="([^$\[\]\'"/]+|"(\\\\|\\"|[^"])*"|'(\\\\|\\'|[^'])*'|//.*$\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*)(\'(?:\\\\|\\\'|[^\']*)\')?(\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*|\'(?:\\\\|\\\'|[^\']*)\'|[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="'(\\\\|\\'|[^'])*'"> + <token type="LiteralString"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="<<([^>]|>[^>])>>"> + <token type="LiteralString"/> + </rule> + <rule pattern="\$?[A-Z_]\w*"> + <token type="NameConstant"/> + </rule> + <rule pattern="\$?[a-z_]\w*"> + <token type="NameVariable"/> + </rule> + <rule pattern="(\+|\||->|=>|=|\(|\)|\.\.|\.|\?|\*|\^|!|\#|~)"> + <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="([^${}\'"/\\]+|"(\\\\|\\"|[^"])*"|'(\\\\|\\'|[^'])*'|//.*$\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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/apacheconf.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/apacheconf.xml new file mode 100644 index 0000000..7643541 --- /dev/null +++ b/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="(<[^\s>]+)(?:(\s+)(.*?))?(>)"> + <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=""([^"\\]*(?:\\.[^"\\]*)*)""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[^\s"\\]+"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/apl.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/apl.xml new file mode 100644 index 0000000..959448c --- /dev/null +++ b/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="\'((\'\')|[^\'])*\'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern=""(("")|[^"])*""> + <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="[+\-×÷⌈⌊∣|⍳?*⍟○!⌹<≤=>≥≠≡≢∊⍷∪∩~∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⌷⍋⍒⊤⊥⍕⍎⊣⊢⍁⍂≈⌸⍯↗⊆⍸]"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/applescript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/applescript.xml new file mode 100644 index 0000000..1de6c67 --- /dev/null +++ b/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="'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="(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|/|÷|\^)"> + <token type="Operator"/> + </rule> + <rule pattern="\b(and|or|is equal|equals|(is )?equal to|is not|isn't|isn't equal( to)?|is not equal( to)?|doesn't equal|does not equal|(is )?greater than|comes after|is not less than or equal( to)?|isn't less than or equal( to)?|(is )?less than|comes before|is not greater than or equal( to)?|isn't greater than or equal( to)?|(is )?greater than or equal( to)?|is not less than|isn't less than|does not come before|doesn't come before|(is )?less than or equal( to)?|is not greater than|isn't greater than|does not come after|doesn't come after|starts? with|begins? with|ends? with|contains?|does not contain|doesn't contain|is in|is contained by|is not in|is not contained by|isn'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=""(\\\\|\\"|[^"])*""> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/arduino.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/arduino.xml new file mode 100644 index 0000000..00399c2 --- /dev/null +++ b/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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|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="[^\\"\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="(?<=\\)\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)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")"> + <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)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="(L?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')"> + <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="[~!%^&*+=|?:<>/-]"> + <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.*?(?<!\\)\n"> + <token type="CommentPreproc"/> + <push/> + </rule> + <rule pattern="^\s*#el(?:se|if).*\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="^\s*#endif.*?(?<!\\)\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*(?=>)"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/armasm.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/armasm.xml new file mode 100644 index 0000000..e5966cf --- /dev/null +++ b/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="(")(.+)(")"> + <bygroups> + <token type="Punctuation"/> + <token type="LiteralStringDouble"/> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(')(.{1}|\\.{1})(')"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/awk.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/awk.xml new file mode 100644 index 0000000..07476ff --- /dev/null +++ b/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="\+\+|--|\|\||&&|in\b|\$|!?~|\|&|(\*\*|[-<>+*%\^/!=|])=?"> + <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=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ballerina.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ballerina.xml new file mode 100644 index 0000000..d13c123 --- /dev/null +++ b/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.\[\]$<>]*\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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'"> + <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="[~^*!%&\[\](){}<>|+=:;,./?-]"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bash.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bash.xml new file mode 100644 index 0000000..10c8dbe --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bash.xml @@ -0,0 +1,217 @@ +<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> + </config> + <rules> + <state name="data"> + <rule pattern="(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\$])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="(?s)\$'(\\\\|\\[0-7]+|\\.|[^'\\])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="(?s)'.*?'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + </rule> + <rule pattern="&"> + <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\[\]{}()$"\'`\\<&|;]+"> + <token type="Text"/> + </rule> + <rule pattern="<"> + <token type="Text"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="(?s)(\\\\|\\[0-7]+|\\.|[^"\\$])+"> + <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="[-+*/%^|&]|\*\*|\|\|"> + <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="<<<"> + <token type="Operator"/> + </rule> + <rule pattern="<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2"> + <token type="LiteralString"/> + </rule> + <rule pattern="&&|\|\|"> + <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="[^}:"\'`$\\]+"> + <token type="Punctuation"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/batchfile.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/batchfile.xml new file mode 100644 index 0000000..d3e0627 --- /dev/null +++ b/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="((?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^()=+\-*/!~%^"\n\x1a&<>|\t\v\f\r ,;=\xa0]|\^[\n\x1a\t\v\f\r ,;=\xa0]?[\w\W])+"> + <usingself state="variable"/> + </rule> + <rule pattern="(?=[\x00|&])"> + <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]|[&<>|\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]|[&<>|\n\x1a]))(?:(?:[^\n\x1a^]|\^[\n\x1a]?[\w\W])*)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(?=((?:(?<=^[^:])|^[^:]?)[\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]?)?/)|(?:(?!\^)|(?<=m))(?:(?=\()|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a]))))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:(?:(?:\^[\n\x1a]?)?[^"\n\x1a&<>|\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&<>|(]))((?:(?:"[^\n\x1a"]*(?:"|(?=[\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&<>|])*(?:\^[\n\x1a]?)?/(?:\^[\n\x1a]?)?\?(?:(?:"[^\n\x1a"]*(?:"|(?=[\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&<>|])*)"> + <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&<>|(])"> + <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&<>|(])"> + <token type="Keyword"/> + </rule> + <rule pattern="(for(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a])(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/f(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\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]|[&<>|\n\x1a])(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/l(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\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]|[&<>|\n\x1a])(?!\^)"> + <token type="Keyword"/> + <push state="for2" state="for"/> + </rule> + <rule pattern="(goto(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(]))((?:(?:(?:\^[\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]|[&<>|\n\x1a]))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:/i(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a]))?)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:not(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\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]|[&<>|\n\x1a]))(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\t\v\f\r ,;=\xa0])+))+)?.*|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(])(?:(?:[^\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&<>|(]))((?:(?:\^[\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&<>|(]))((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:/p)?)((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:(?:(?:\^[\n\x1a]?)?[^"\n\x1a&<>|^=]|\^[\n\x1a]?[^"=])+)?)((?:(?:\^[\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="((?:(?<=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:)([\t\v\f\r ,;=\xa0]*)((?:(?:[^\n\x1a&<>|\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="\|\|?|&&?"> + <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]|[&<>|\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&<>|\t\v\f\r ,;=\xa0+:^)]|\^[\n\x1a]?[^)])*)?)((?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?[^)]|[^"%^\n\x1a&<>|)])*)"> + <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="((?:(?<=[\n\x1a\t\v\f\r ,;=\xa0])\d)?)(>>?&|<&)([\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="((?:(?<=[\n\x1a\t\v\f\r ,;=\xa0])(?<!\^[\n\x1a])\d)?)(>>?|<)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\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]|[&<>|\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]|[&<>|\n\x1a]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))((?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\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]|[&<>|\n\x1a]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\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]|[&<>|\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]|[&<>|\n\x1a])))"> + <bygroups> + <usingself state="arithmetic"/> + <token type="OperatorWord"/> + <usingself state="arithmetic"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\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="(?=((?:(?<=^[^:])|^[^:]?)[\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]?)?/)|(?:(?!\^)|(?<=m))(?:(?=\()|(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a])))))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:(?:(?:\^[\n\x1a]?)?[^"\n\x1a&<>|\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&<>|(])))((?:(?:"[^\n\x1a"]*(?:"|(?=[\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&<>|)])*(?:\^[\n\x1a]?)?/(?:\^[\n\x1a]?)?\?(?:(?:"[^\n\x1a"]*(?:"|(?=[\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&<>|)])*)"> + <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&<>|(]))"> + <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&<>|(]))"> + <token type="Keyword"/> + </rule> + <rule pattern="(for(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a]))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/f(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\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]|[&<>|\n\x1a]))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(/l(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\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]|[&<>|\n\x1a]))(?!\^)"> + <token type="Keyword"/> + <push state="for2" state="for"/> + </rule> + <rule pattern="(goto(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(])))((?:(?:(?:\^[\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]|[&<>|\n\x1a])))(?!\^))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:/i(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a])))?)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)((?:not(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\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]|[&<>|\n\x1a])))(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\t\v\f\r ,;=\xa0])+))+)?.*|(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(]))(?:(?:[^\n\x1a^)]|\^[\n\x1a]?[^)])*))"> + <token type="CommentSingle"/> + <push state="follow/compound"/> + </rule> + <rule pattern="(set(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(])))((?:(?:\^[\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&<>|(])))((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:/p)?)((?:(?:\^[\n\x1a]?)?[^\S\n])*)((?:(?:(?:\^[\n\x1a]?)?[^"\n\x1a&<>|^=)]|\^[\n\x1a]?[^"=])+)?)((?:(?:\^[\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="((?:(?<=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:)([\t\v\f\r ,;=\xa0]*)((?:(?:[^\n\x1a&<>|\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="\|\|?|&&?"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="text"/> + </rule> + </state> + <state name="text"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule> + <include state="variable-or-escape"/> + </rule> + <rule pattern="[^"%^\n\x1a&<>|\t\v\f\r ,;=\xa0\d)]+|."> + <token type="Text"/> + </rule> + </state> + <state name="redirect"> + <rule pattern="((?:(?<=[\n\x1a\t\v\f\r ,;=\xa0])\d)?)(>>?&|<&)([\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="((?:(?<=[\n\x1a\t\v\f\r ,;=\xa0])(?<!\^[\n\x1a])\d)?)(>>?|<)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\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&<>|\t\v\f\r ,;=\xa0+:^]|\^[\n\x1a]?[\w\W])*)?)((?:(?:"[^\n\x1a"]*(?:"|(?=[\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]|[^"%^\n\x1a&<>|])*)"> + <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="((?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^()=+\-*/!~%^"\n\x1a&<>|\t\v\f\r ,;=\xa0]|\^[\n\x1a\t\v\f\r ,;=\xa0]?[^)])+"> + <usingself state="variable"/> + </rule> + <rule pattern="(?=[\x00|&])"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="follow"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <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="[^"%^\n\x1a]+|[%^]"> + <token type="LiteralStringDouble"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="variable"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule> + <include state="variable-or-escape"/> + </rule> + <rule pattern="[^"%^\n\x1a]+|."> + <token type="NameVariable"/> + </rule> + </state> + <state name="call/compound"> + <rule pattern="(?=\))"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern="(:?)((?:(?:[^\n\x1a&<>|\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="(")((?:(?:(?:%(?:\*|(?:~[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\t\v\f\r ,;=\xa0]*)(\))"> + <bygroups> + <token type="LiteralStringDouble"/> + <usingself state="string"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="#pop" state="for2" state="string"/> + </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="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])+)?(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\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])+)(?:[&<>|]+|(?:(?:"[^\n\x1a"]*(?:"|(?=[\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]?)?[^"\n\x1a&<>|\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&<>|\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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bibtex.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bibtex.xml new file mode 100644 index 0000000..8fde161 --- /dev/null +++ b/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_@!$&*+\-./:;<>?\[\\\]^`|~][\w@!$&*+\-./:;<>?\[\\\]^`|~]*"> + <token type="NameVariable"/> + </rule> + <rule pattern="""> + <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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\{\"]+"> + <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_@!$&*+\-./:;<>?\[\\\]^`|~][\w@!$&*+\-./:;<>?\[\\\]^`|~]*"> + <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_@!$&*+\-./:;<>?\[\\\]^`|~][\w@!$&*+\-./:;<>?\[\\\]^`|~]*"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bicep.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bicep.xml new file mode 100644 index 0000000..1efc9c8 --- /dev/null +++ b/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="([']?\w+[']?)(:)"> + <bygroups> + <token type="NameProperty"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="\b('(resourceGroup|subscription|managementGroup|tenant)')\b"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="'[\w\$\{\(\)\}\.]{1,}?'"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="('''|').*?('''|')"> + <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="(>=|>|<=|<|==|!=|=~|!~|::|&&|\?\?|!|-|%|\*|\/|\+)"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/blitzbasic.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/blitzbasic.xml new file mode 100644 index 0000000..591b1ad --- /dev/null +++ b/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=""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=""C?"> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="[^"]+"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="root"> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern=";.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="""> + <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="([+\-*/~=<>^])"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bnf.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/bnf.xml new file mode 100644 index 0000000..5c98424 --- /dev/null +++ b/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="(<)([ -;=?-~]+)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameClass"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="::="> + <token type="Operator"/> + </rule> + <rule pattern="[^<>:]+"> + <token type="Text"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/brainfuck.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/brainfuck.xml new file mode 100644 index 0000000..4c84c33 --- /dev/null +++ b/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="[<>]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="[^.,+\-<>\[\]]+"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c++.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c++.xml new file mode 100644 index 0000000..e8702c5 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c++.xml @@ -0,0 +1,326 @@ +<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> + <mime_type>text/x-c++hdr</mime_type> + <mime_type>text/x-c++src</mime_type> + <ensure_nl>true</ensure_nl> + </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*(?=[>{])"> + <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*(?:/[*].*?[*]/\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="(?<=\\)\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)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")"> + <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)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="(L?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')"> + <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]('?[0-9A-Fa-f]+)*)[LlUu]*"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0('?[0-7]+)+[LlUu]*"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[Bb][01]('?[01]+)*[LlUu]*"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="[0-9]('?[0-9]+)*[LlUu]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\*/"> + <token type="Error"/> + </rule> + <rule pattern="[~!%^&*+=|?:<>/-]"> + <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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|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="[^\\"\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.*?(?<!\\)\n"> + <token type="CommentPreproc"/> + <push/> + </rule> + <rule pattern="^\s*#el(?:se|if).*\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="^\s*#endif.*?(?<!\\)\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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c.xml new file mode 100644 index 0000000..d63d9b7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/c.xml @@ -0,0 +1,253 @@ +<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> + </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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|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="[^\\"\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="(?<=\\)\n"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="if0"> + <rule pattern="^\s*#if.*?(?<!\\)\n"> + <token type="CommentPreproc"/> + <push/> + </rule> + <rule pattern="^\s*#el(?:se|if).*\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="^\s*#endif.*?(?<!\\)\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?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')"> + <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="[~!%^&*+=|?:<>/-]"> + <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"> + <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="[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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cap_n_proto.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cap_n_proto.xml new file mode 100644 index 0000000..3e7d147 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cap_n_proto.xml @@ -0,0 +1,122 @@ +<lexer> + <config> + <name>Cap'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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ceylon.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ceylon.xml new file mode 100644 index 0000000..4c41218 --- /dev/null +++ b/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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="".*``.*``.*""> + <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="[~^*!%&\[\](){}<>|+=:;,./?-]"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cfengine3.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cfengine3.xml new file mode 100644 index 0000000..d330549 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cfengine3.xml @@ -0,0 +1,206 @@ +<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+)(string|slist|int|real)(\s*)(=>)(\s*)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameVariable"/> + <token type="Punctuation"/> + <token type="Text"/> + <token type="KeywordType"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(\S+)(\s*)(=>)(\s*)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="doublequotestring"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="singlequotestring"/> + </rule> + <rule pattern="`"> + <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="NameClass"/> + <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="Punctuation"/> + </rule> + <rule pattern="=>"> + <token type="Operator"/> + </rule> + <rule pattern="->"> + <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="""> + <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="'"> + <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="`"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="."> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer> diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cfstatement.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cfstatement.xml new file mode 100644 index 0000000..46a84cf --- /dev/null +++ b/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="[-+*/^&=!]"> + <token type="Operator"/> + </rule> + <rule pattern="<=|>=|<|>|=="> + <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="\|\||&&"> + <token type="Operator"/> + </rule> + <rule pattern="\?"> + <token type="Operator"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="'.*?'"> + <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=""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="#.+?#"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^"#]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="#"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/chaiscript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/chaiscript.xml new file mode 100644 index 0000000..860439a --- /dev/null +++ b/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="\$\{[^"}]+?\}"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="\$"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\\\\"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\\""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[^\\"$]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <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="\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|\.\.(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?"> + <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="""> + <token type="LiteralStringDouble"/> + <push state="dqstring"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/clojure.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/clojure.xml new file mode 100644 index 0000000..ee83a6a --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/clojure.xml @@ -0,0 +1,68 @@ +<lexer> + <config> + <name>Clojure</name> + <alias>clojure</alias> + <alias>clj</alias> + <filename>*.clj</filename> + <mime_type>text/x-clojure</mime_type> + <mime_type>application/x-clojure</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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="\\(.|[a-z]+)"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="::?#?(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="~@|[`\'#^~&@]"> + <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|>=|->|==|<=|or|=|/|>|-|\*|\+|<) "> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<=\()(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="NameFunction"/> + </rule> + <rule pattern="(?!#)[\w!$%*+<=>?/.#-]+"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cmake.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cmake.xml new file mode 100644 index 0000000..b041cfd --- /dev/null +++ b/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="(\$<)(.+?)(>)"> + <bygroups> + <token type="Operator"/> + <token type="NameVariable"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="(?s)".*?""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\\\S+"> + <token type="LiteralString"/> + </rule> + <rule pattern="[^)$"# \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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cobol.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cobol.xml new file mode 100644 index 0000000..a8a8029 --- /dev/null +++ b/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=""[^"\n]*("|\n)"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'[^'\n]*('|\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}|\*>.*\n)"> + <token type="Comment"/> + </rule> + </state> + <state name="core"> + <rule pattern="(^|(?<=[^\w\-]))(ALL\s+)?((ZEROES)|(HIGH-VALUE|LOW-VALUE|QUOTE|SPACE|ZERO)(S)?)\s*($|(?=[^\w\-]))"> + <token type="NameConstant"/> + </rule> + <rule pattern="(^|(?<=[^\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="(^|(?<=[^\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="(^|(?<=[^\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="(^|(?<=[^\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="(\*\*|\*|\+|-|/|<=|>=|<|>|==|/=|=)"> + <token type="Operator"/> + </rule> + <rule pattern="([(),;:&%.])"> + <token type="Punctuation"/> + </rule> + <rule pattern="(^|(?<=[^\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="(^|(?<=[^\w\-]))(true|false)\s*($|(?=[^\w\-]))"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(^|(?<=[^\w\-]))(equal|equals|ne|lt|le|gt|ge|greater|less|than|not|and|or)\s*($|(?=[^\w\-]))"> + <token type="OperatorWord"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/coffeescript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/coffeescript.xml new file mode 100644 index 0000000..e29722f --- /dev/null +++ b/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="'''"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="#|\\.|\'|""> + <token type="LiteralString"/> + </rule> + <rule> + <include state="strings"/> + </rule> + </state> + <state name="dqs"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\.|\'"> + <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="'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="#|\\.|""> + <token type="LiteralString"/> + </rule> + <rule> + <include state="strings"/> + </rule> + </state> + <state name="tdqs"> + <rule pattern="""""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\.|\'|""> + <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="\+\+|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?"> + <token type="Operator"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(?:\([^()]*\))?\s*[=-]>"> + <token type="NameFunction"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[{(\[;,]"> + <token type="Punctuation"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[})\].]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?<![.$])(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="(?<![.$])(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="""""> + <token type="LiteralString"/> + <push state="tdqs"/> + </rule> + <rule pattern="'''"> + <token type="LiteralString"/> + <push state="tsqs"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="dqs"/> + </rule> + <rule pattern="'"> + <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="[^#\\\'"]+"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/common_lisp.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/common_lisp.xml new file mode 100644 index 0000000..0fb9a7a --- /dev/null +++ b/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=""(\\.|\\\n|[^"\\])*""> + <token type="LiteralString"/> + </rule> + <rule pattern=":(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="::(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern=":#(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="'(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="'"> + <token type="Operator"/> + </rule> + <rule pattern="`"> + <token type="Operator"/> + </rule> + <rule pattern="[-+]?\d+\.?(?=[ "()\'\n,;`])"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[-+]?\d+/\d+(?=[ "()\'\n,;`])"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[-+]?(\d*\.\d+([defls][-+]?\d+)?|\d+(\.\d*)?[defls][-+]?\d+)(?=[ "()\'\n,;`])"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="#\\.(?=[ "()\'\n,;`])"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="#\\(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="#\("> + <token type="Operator"/> + <push state="body"/> + </rule> + <rule pattern="#\d*\*[01]*"> + <token type="LiteralOther"/> + </rule> + <rule pattern="#:(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="#[.,]"> + <token type="Operator"/> + </rule> + <rule pattern="#\'"> + <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?"(\\.|[^"])*""> + <token type="LiteralOther"/> + </rule> + <rule pattern="#\d+="> + <token type="Operator"/> + </rule> + <rule pattern="#\d+#"> + <token type="Operator"/> + </rule> + <rule pattern="#+nil(?=[ "()\'\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)(?=[ "()\'\n,;`])"> + <token type="NameConstant"/> + </rule> + <rule pattern="\*(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)\*"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/coq.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/coq.xml new file mode 100644 index 0000000..62f64ff --- /dev/null +++ b/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="[^"]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <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\']*(?=\s*\.)"> + <token type="NameNamespace"/> + </rule> + <rule pattern="[A-Z][\w\']*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-z][a-z0-9_\']*"> + <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\']*)"> + <token type="Name"/> + </rule> + <rule pattern="(λ|Π|\|\}|\{\||\\/|/\\|=>|~|\}|\|]|\||\{<|\{|`|_|]|\[\||\[>|\[<|\[|\?\?|\?|>\}|>]|>|=|<->|<-|<|;;|;|:>|:=|::|:|\.\.|\.|->|-\.|-|,|\+|\*|\)|\(|&&|&|#|!=)"> + <token type="Operator"/> + </rule> + <rule pattern="([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]"> + <token type="Operator"/> + </rule> + <rule pattern="\b(unit|nat|bool|string|ascii|list)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[^\W\d][\w']*"> + <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="'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'.'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'"> + <token type="Keyword"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="[~?][a-z][\w\']*:"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/crystal.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/crystal.xml new file mode 100644 index 0000000..94853db --- /dev/null +++ b/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="\\[\\<>]"> + <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="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="[^\\"#]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[\\#]"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <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#"\']|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="\\[<]"> + <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="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(?=[*%&^`~+-/\[<>=])"> + <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="(?<!\.)(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="(?<!\w)(<<-?)(["`\']?)([a-zA-Z_]\w*)(\2)(.*?\n)"> + <token type="LiteralStringHeredoc"/> + </rule> + <rule pattern="(<<-?)("|\')()(\2)(.*?\n)"> + <token type="LiteralStringHeredoc"/> + </rule> + <rule pattern="__END__"> + <token type="CommentPreproc"/> + <push state="end-part"/> + </rule> + <rule pattern="(?:^|(?<=[=<>~!:])|(?<=(?:\s|;)when\s)|(?<=(?:\s|;)or\s)|(?<=(?:\s|;)and\s)|(?<=\.index\s)|(?<=\.scan\s)|(?<=\.sub\s)|(?<=\.sub!\s)|(?<=\.gsub\s)|(?<=\.gsub!\s)|(?<=\.match\s)|(?<=(?:\s|;)if\s)|(?<=(?:\s|;)elsif\s)|(?<=^when\s)|(?<=^index\s)|(?<=^scan\s)|(?<=^sub\s)|(?<=^gsub\s)|(?<=^sub!\s)|(?<=^gsub!\s)|(?<=^match\s)|(?<=^if\s)|(?<=^elsif\s))(\s*)(/)"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringRegex"/> + </bygroups> + <push state="multiline-regex"/> + </rule> + <rule pattern="(?<=\(|,|\[)/"> + <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="\$[!@&`\'+~=/\\,;.<>_*$?:"^-]"> + <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#"\']|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="(\.|::)(\[\]\?|<=>|===|\[\]=|>>|&&|\*\*|\[\]|\|\||>=|=~|!~|<<|<=|!=|==|<|/|=|-|\+|>|\*|&|%|\^|!|\||~)"> + <bygroups> + <token type="Operator"/> + <token type="NameOperator"/> + </bygroups> + </rule> + <rule pattern="(\.|::)([a-zA-Z_]\w*[!?]?|[*%&^`~+\-/\[<>=])"> + <bygroups> + <token type="Operator"/> + <token type="Name"/> + </bygroups> + </rule> + <rule pattern="[a-zA-Z_]\w*(?:[!?](?!=))?"> + <token type="Name"/> + </rule> + <rule pattern="(\[|\]\??|\*\*|<=>?|>=|<<?|>>?|=~|===|!~|&&?|\|\||\.{1,3})"> + <token type="Operator"/> + </rule> + <rule pattern="[-+/*%=<>&!^|~]=?"> + <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="\\[\\<>]"> + <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="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}(\[\]\?|<=>|===|\[\]=|>>|&&|\*\*|\[\]|\|\||>=|=~|!~|<<|<=|!=|==|<|/|=|-|\+|>|\*|&|%|\^|!|\||~)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern=":'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="'(\\\\|\\'|[^']|\\[^'\\]+)'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern=":""> + <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="""> + <token type="LiteralStringDouble"/> + <push state="simple-string"/> + </rule> + <rule pattern="(?<!\.)`"> + <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="%<"> + <token type="LiteralStringOther"/> + <push state="ab-intp-string"/> + </rule> + <rule pattern="%[wi]<"> + <token type="LiteralStringOther"/> + <push state="ab-string"/> + </rule> + <rule pattern="%r<"> + <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="(?<=[-+/*%=<>&!^|~,(])(\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="(%([\[{(<]))((?:\\\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*[!?]?|\*\*?|[-+]@?|[/%&|^`~]|\[\]=?|<<|>>|<=?>|>=?|===?)"> + <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="[^\\"#]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="[\\#]"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="""> + <token type="LiteralStringSymbol"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/csharp.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/csharp.xml new file mode 100644 index 0000000..8c2ff45 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/csharp.xml @@ -0,0 +1,115 @@ +<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="[~!%^&*()+=|\[\]:;,.<>/?-]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[{}]"> + <token type="Punctuation"/> + </rule> + <rule pattern="@"(""|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="\$@?"(""|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"\n])*["\n]"> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'"> + <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[^\n\r]+"> + <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="(abstract|as|async|await|base|break|by|case|catch|checked|const|continue|default|delegate|do|else|enum|event|explicit|extern|false|finally|fixed|for|foreach|goto|if|implicit|in|init|internal|is|let|lock|new|null|on|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|switch|this|throw|true|try|typeof|unchecked|unsafe|virtual|void|while|get|set|new|partial|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="(bool|byte|char|decimal|double|dynamic|float|int|long|object|sbyte|short|string|uint|ulong|ushort|var)\b\??"> + <token type="KeywordType"/> + </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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/css.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/css.xml new file mode 100644 index 0000000..0faa06e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/css.xml @@ -0,0 +1,323 @@ +<lexer> + <config> + <name>CSS</name> + <alias>css</alias> + <filename>*.css</filename> + <mime_type>text/css</mime_type> + </config> + <rules> + <state name="numeric-end"> + <rule pattern="(vmin|grad|vmax|turn|dppx|dpcm|kHz|dpi|rad|rem|deg|vw|vh|ch|px|mm|cm|in|pt|pc|Hz|ex|em|ms|q|s)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="%"> + <token type="KeywordType"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="atrule"> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="atcontent"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="basics"/> + </rule> + </state> + <state name="atcontent"> + <rule> + <include state="basics"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="2"/> + </rule> + </state> + <state name="common-values"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(-webkit-|-khtml-|prince-|-atsc-|-moz-|-rim-|-wap-|-ms-|-xv-|mso-|-ah-|-hp-|-ro-|-tc-|-o-)"> + <token type="KeywordPseudo"/> + </rule> + <rule> + <include state="urls"/> + </rule> + <rule pattern="(attr|blackness|blend|blenda|blur|brightness|calc|circle|color-mod|contrast|counter|cubic-bezier|device-cmyk|drop-shadow|ellipse|gray|grayscale|hsl|hsla|hue|hue-rotate|hwb|image|inset|invert|lightness|linear-gradient|matrix|matrix3d|opacity|perspective|polygon|radial-gradient|rect|repeating-linear-gradient|repeating-radial-gradient|rgb|rgba|rotate|rotate3d|rotateX|rotateY|rotateZ|saturate|saturation|scale|scale3d|scaleX|scaleY|scaleZ|sepia|shade|skewX|skewY|steps|tint|toggle|translate|translate3d|translateX|translateY|translateZ|whiteness)(\()"> + <bygroups> + <token type="NameBuiltin"/> + <token type="Punctuation"/> + </bygroups> + <push state="function-start"/> + </rule> + <rule pattern="([a-zA-Z_][\w-]+)(\()"> + <bygroups> + <token type="NameFunction"/> + <token type="Punctuation"/> + </bygroups> + <push state="function-start"/> + </rule> + <rule pattern="(use-glyph-orientation|decimal-leading-zero|ruby-base-container|ruby-text-container|table-column-group|table-header-group|geometricPrecision|table-footer-group|optimizeLegibility|alternate-reverse|repeat no-repeat|table-row-group|all-petite-caps|ultra-condensed|extra-condensed|box-decoration|sideways-right|extra-expanded|no-close-quote|all-small-caps|semi-condensed|ultra-expanded|column-reverse|space-between|semi-expanded|table-caption|no-open-quote|sideways-left|double-circle|vertical-text|optimizeSpeed|weight style|currentColor|titling-caps|match-parent|table-column|line-through|inline-block|inline-table|wrap-reverse|avoid-column|manipulation|space-around|context-menu|lower-alpha|row-reverse|not-allowed|content-box|ease-in-out|close-quote|lower-latin|crisp-edges|lower-roman|lower-greek|upper-alpha|upper-latin|upper-roman|nwse-resize|nesw-resize|preserve-3d|inline-flex|petite-caps|color-dodge|descendants|padding-box|capitalize|small-caps|difference|inter-word|step-start|all-scroll|stroke-box|soft-light|margin-box|open-quote|table-cell|row-resize|border-box|hard-light|break-word|color-burn|luminosity|full-width|col-resize|from-image|avoid-page|scale-down|saturation|sans-serif|flex-start|distribute|horizontal|alternate|ruby-text|force-end|list-item|se-resize|mandatory|exclusion|ns-resize|underline|ruby-base|ew-resize|condensed|container|uppercase|no-repeat|nw-resize|table-row|backwards|crosshair|proximity|sw-resize|lowercase|allow-end|each-line|monospace|pixelated|ne-resize|luminance|pan-right|ellipsis|pan-down|pan-left|overline|multiply|progress|relative|infinite|repeat-x|repeat-y|georgian|forwards|flex-end|s-resize|fill-box|expanded|separate|ease-out|sideways|e-resize|step-end|n-resize|collapse|triangle|baseline|view-box|w-resize|armenian|absolute|xx-large|xx-small|vertical|zoom-out|contain|ease-in|running|no-drop|zoom-in|unicase|hanging|smaller|x-large|overlay|compact|lighter|lighten|objects|oblique|x-small|reverse|stretch|upright|cursive|inherit|initial|outside|pointer|decimal|default|justify|visible|balance|isolate|fantasy|paused|static|pan-up|invert|inside|italic|weight|inline|hidden|outset|larger|repeat|always|spaces|sticky|circle|digits|linear|column|smooth|nowrap|bolder|normal|sesame|dashed|groove|darken|bottom|run-in|manual|dotted|double|medium|filled|screen|scroll|center|strict|square|edges|serif|start|thick|first|clone|fixed|slice|small|under|unset|block|color|round|solid|space|right|ridge|blink|below|pan-y|avoid|large|cover|inset|alpha|local|alias|style|loose|table|mixed|pan-x|page|ruby|disc|none|snap|ease|text|show|thin|clip|left|open|wrap|fill|cell|flat|flex|flip|last|both|help|bold|over|hide|wait|icon|move|auto|copy|wavy|top|ltr|row|rtl|end|hue|dot|off|all|ink|to|on)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(cjk-ideographic|katakana-iroha|hiragana-iroha|small-caption|bidi-override|center-right|center-left|text-bottom|message-box|continuous|status-bar|right-side|rightwards|spell-out|left-side|landscape|far-right|leftwards|narrower|portrait|katakana|far-left|text-top|pre-wrap|hiragana|pre-line|silent|x-high|faster|higher|middle|x-soft|behind|x-fast|hebrew|slower|x-loud|super|above|lower|wider|level|aural|embed|x-low|cross|crop|fast|once|high|slow|soft|loud|yes|pre|low|mix)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(lightgoldenrodyellow|mediumspringgreen|mediumaquamarine|mediumslateblue|mediumturquoise|mediumvioletred|lightsteelblue|cornflowerblue|lightslategray|blanchedalmond|mediumseagreen|lightslategrey|darkolivegreen|darkgoldenrod|darkslateblue|lightseagreen|rebeccapurple|darkslategrey|darkslategray|palegoldenrod|paleturquoise|palevioletred|darkturquoise|lavenderblush|antiquewhite|mediumorchid|lightskyblue|mediumpurple|midnightblue|darkseagreen|lemonchiffon|springgreen|yellowgreen|greenyellow|navajowhite|darkmagenta|lightyellow|transparent|lightsalmon|forestgreen|saddlebrown|deepskyblue|floralwhite|dodgerblue|ghostwhite|lightcoral|sandybrown|darkviolet|papayawhip|mediumblue|chartreuse|lightgreen|whitesmoke|aquamarine|darkorange|darksalmon|powderblue|darkorchid|blueviolet|indianred|mintcream|mistyrose|olivedrab|goldenrod|orangered|lawngreen|gainsboro|lightblue|firebrick|lightcyan|peachpuff|lightgray|darkkhaki|lightgrey|darkgreen|rosybrown|royalblue|slateblue|chocolate|cadetblue|burlywood|slategray|slategrey|limegreen|steelblue|turquoise|palegreen|lightpink|aliceblue|moccasin|darkgrey|darkblue|seagreen|lavender|cornsilk|deeppink|seashell|darkgray|honeydew|darkcyan|dimgrey|magenta|crimson|darkred|hotpink|skyblue|oldlace|dimgray|fuchsia|thistle|orchid|indigo|orange|tomato|violet|salmon|yellow|silver|purple|bisque|sienna|maroon|black|linen|azure|white|wheat|khaki|green|olive|ivory|coral|brown|beige|snow|blue|navy|aqua|teal|gray|gold|grey|lime|peru|cyan|pink|plum|tan|red)\b"> + <token type="KeywordConstant"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="basics"/> + </rule> + </state> + <state name="numeric-values"> + <rule pattern="\#[a-zA-Z0-9]{1,6}"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[+\-]?[0-9]*[.][0-9]+"> + <token type="LiteralNumberFloat"/> + <push state="numeric-end"/> + </rule> + <rule pattern="[+\-]?[0-9]+"> + <token type="LiteralNumberInteger"/> + <push state="numeric-end"/> + </rule> + </state> + <state name="atparenthesis"> + <rule> + <include state="common-values"/> + </rule> + <rule pattern="/\*(?:.|\n)*?\*/"> + <token type="Comment"/> + </rule> + <rule> + <include state="numeric-values"/> + </rule> + <rule pattern="[*+/-]"> + <token type="Operator"/> + </rule> + <rule pattern="[,]"> + <token type="Punctuation"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[a-zA-Z_-]\w*"> + <token type="Name"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="atparenthesis"/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="basics"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="/\*(?:.|\n)*?\*/"> + <token type="Comment"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="content"/> + </rule> + <rule pattern="(\:{1,2})([\w-]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameDecorator"/> + </bygroups> + </rule> + <rule pattern="(\.)([\w-]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="(\#)([\w-]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(@)([\w-]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="Keyword"/> + </bygroups> + <push state="atrule"/> + </rule> + <rule pattern="[\w-]+"> + <token type="NameTag"/> + </rule> + <rule pattern="[~^*!%&$\[\]()<>|+=@:;,./?-]"> + <token type="Operator"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="content"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + </rule> + <rule pattern="^@.*?$"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="(-webkit-|-khtml-|prince-|-atsc-|-moz-|-rim-|-wap-|-ms-|-xv-|mso-|-ah-|-hp-|-ro-|-tc-|-o-)"> + <token type="KeywordPseudo"/> + </rule> + <rule pattern="(align-content|align-items|align-self|alignment-baseline|all|animation|animation-delay|animation-direction|animation-duration|animation-fill-mode|animation-iteration-count|animation-name|animation-play-state|animation-timing-function|appearance|azimuth|backface-visibility|background|background-attachment|background-blend-mode|background-clip|background-color|background-image|background-origin|background-position|background-repeat|background-size|baseline-shift|bookmark-label|bookmark-level|bookmark-state|border|border-bottom|border-bottom-color|border-bottom-left-radius|border-bottom-right-radius|border-bottom-style|border-bottom-width|border-boundary|border-collapse|border-color|border-image|border-image-outset|border-image-repeat|border-image-slice|border-image-source|border-image-width|border-left|border-left-color|border-left-style|border-left-width|border-radius|border-right|border-right-color|border-right-style|border-right-width|border-spacing|border-style|border-top|border-top-color|border-top-left-radius|border-top-right-radius|border-top-style|border-top-width|border-width|bottom|box-decoration-break|box-shadow|box-sizing|box-snap|box-suppress|break-after|break-before|break-inside|caption-side|caret|caret-animation|caret-color|caret-shape|chains|clear|clip|clip-path|clip-rule|color|color-interpolation-filters|column-count|column-fill|column-gap|column-rule|column-rule-color|column-rule-style|column-rule-width|column-span|column-width|columns|content|counter-increment|counter-reset|counter-set|crop|cue|cue-after|cue-before|cursor|direction|display|dominant-baseline|elevation|empty-cells|filter|flex|flex-basis|flex-direction|flex-flow|flex-grow|flex-shrink|flex-wrap|float|float-defer|float-offset|float-reference|flood-color|flood-opacity|flow|flow-from|flow-into|font|font-family|font-feature-settings|font-kerning|font-language-override|font-size|font-size-adjust|font-stretch|font-style|font-synthesis|font-variant|font-variant-alternates|font-variant-caps|font-variant-east-asian|font-variant-ligatures|font-variant-numeric|font-variant-position|font-weight|footnote-display|footnote-policy|glyph-orientation-vertical|grid|grid-area|grid-auto-columns|grid-auto-flow|grid-auto-rows|grid-column|grid-column-end|grid-column-gap|grid-column-start|grid-gap|grid-row|grid-row-end|grid-row-gap|grid-row-start|grid-template|grid-template-areas|grid-template-columns|grid-template-rows|hanging-punctuation|height|hyphenate-character|hyphenate-limit-chars|hyphenate-limit-last|hyphenate-limit-lines|hyphenate-limit-zone|hyphens|image-orientation|image-resolution|initial-letter|initial-letter-align|initial-letter-wrap|isolation|justify-content|justify-items|justify-self|left|letter-spacing|lighting-color|line-break|line-grid|line-height|line-snap|list-style|list-style-image|list-style-position|list-style-type|margin|margin-bottom|margin-left|margin-right|margin-top|marker-side|marquee-direction|marquee-loop|marquee-speed|marquee-style|mask|mask-border|mask-border-mode|mask-border-outset|mask-border-repeat|mask-border-slice|mask-border-source|mask-border-width|mask-clip|mask-composite|mask-image|mask-mode|mask-origin|mask-position|mask-repeat|mask-size|mask-type|max-height|max-lines|max-width|min-height|min-width|mix-blend-mode|motion|motion-offset|motion-path|motion-rotation|move-to|nav-down|nav-left|nav-right|nav-up|object-fit|object-position|offset-after|offset-before|offset-end|offset-start|opacity|order|orphans|outline|outline-color|outline-offset|outline-style|outline-width|overflow|overflow-style|overflow-wrap|overflow-x|overflow-y|padding|padding-bottom|padding-left|padding-right|padding-top|page|page-break-after|page-break-before|page-break-inside|page-policy|pause|pause-after|pause-before|perspective|perspective-origin|pitch|pitch-range|play-during|polar-angle|polar-distance|position|presentation-level|quotes|region-fragment|resize|rest|rest-after|rest-before|richness|right|rotation|rotation-point|ruby-align|ruby-merge|ruby-position|running|scroll-snap-coordinate|scroll-snap-destination|scroll-snap-points-x|scroll-snap-points-y|scroll-snap-type|shape-image-threshold|shape-inside|shape-margin|shape-outside|size|speak|speak-as|speak-header|speak-numeral|speak-punctuation|speech-rate|stress|string-set|tab-size|table-layout|text-align|text-align-last|text-combine-upright|text-decoration|text-decoration-color|text-decoration-line|text-decoration-skip|text-decoration-style|text-emphasis|text-emphasis-color|text-emphasis-position|text-emphasis-style|text-indent|text-justify|text-orientation|text-overflow|text-shadow|text-space-collapse|text-space-trim|text-spacing|text-transform|text-underline-position|text-wrap|top|transform|transform-origin|transform-style|transition|transition-delay|transition-duration|transition-property|transition-timing-function|unicode-bidi|user-select|vertical-align|visibility|voice-balance|voice-duration|voice-family|voice-pitch|voice-range|voice-rate|voice-stress|voice-volume|volume|white-space|widows|width|will-change|word-break|word-spacing|word-wrap|wrap-after|wrap-before|wrap-flow|wrap-inside|wrap-through|writing-mode|z-index)(\s*)(\:)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="value-start"/> + </rule> + <rule pattern="(--[a-zA-Z_][\w-]*)(\s*)(\:)"> + <bygroups> + <token type="NameVariable"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="value-start"/> + </rule> + <rule pattern="([a-zA-Z_][\w-]*)(\s*)(\:)"> + <bygroups> + <token type="Name"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="value-start"/> + </rule> + <rule pattern="/\*(?:.|\n)*?\*/"> + <token type="Comment"/> + </rule> + </state> + <state name="value-start"> + <rule> + <include state="common-values"/> + </rule> + <rule pattern="(color-interpolation-filters|glyph-orientation-vertical|border-bottom-right-radius|transition-timing-function|animation-iteration-count|animation-timing-function|border-bottom-left-radius|font-variant-east-asian|font-variant-alternates|border-top-right-radius|text-underline-position|scroll-snap-destination|font-language-override|text-emphasis-position|border-top-left-radius|font-variant-ligatures|scroll-snap-coordinate|hyphenate-limit-lines|background-attachment|font-feature-settings|grid-template-columns|text-decoration-style|font-variant-position|hyphenate-limit-chars|text-decoration-color|shape-image-threshold|background-blend-mode|hyphenate-limit-zone|initial-letter-align|text-combine-upright|hyphenate-limit-last|text-decoration-line|box-decoration-break|text-decoration-skip|animation-play-state|scroll-snap-points-y|font-variant-numeric|scroll-snap-points-x|animation-direction|border-bottom-width|hanging-punctuation|border-bottom-color|border-image-outset|border-image-repeat|list-style-position|border-image-source|initial-letter-wrap|text-space-collapse|background-position|hyphenate-character|grid-template-areas|backface-visibility|text-emphasis-style|transition-duration|animation-fill-mode|transition-property|text-emphasis-color|border-bottom-style|border-image-slice|mask-border-outset|border-right-width|border-right-style|perspective-origin|alignment-baseline|border-right-color|presentation-level|grid-template-rows|animation-duration|mask-border-source|mask-border-repeat|border-image-width|column-rule-color|speak-punctuation|dominant-baseline|marquee-direction|column-rule-width|mask-border-slice|border-left-color|mask-border-width|grid-auto-columns|counter-increment|border-left-style|grid-column-start|image-orientation|background-repeat|font-variant-caps|page-break-inside|page-break-before|background-origin|column-rule-style|border-left-width|list-style-image|page-break-after|transform-origin|border-top-color|border-top-style|border-top-width|footnote-display|background-color|image-resolution|background-image|transition-delay|text-orientation|font-size-adjust|mask-border-mode|scroll-snap-type|animation-delay|text-align-last|grid-column-end|list-style-type|text-space-trim|grid-column-gap|justify-content|text-decoration|footnote-policy|caret-animation|border-collapse|border-boundary|region-fragment|background-clip|background-size|float-reference|motion-rotation|object-position|transform-style|overflow-style|border-spacing|baseline-shift|initial-letter|bookmark-label|grid-row-start|animation-name|bookmark-level|flex-direction|letter-spacing|bookmark-state|mask-composite|grid-auto-rows|mix-blend-mode|outline-offset|padding-bottom|polar-distance|vertical-align|voice-duration|grid-auto-flow|rotation-point|text-transform|font-synthesis|lighting-color|speak-numeral|counter-reset|outline-style|border-bottom|outline-color|marquee-speed|ruby-position|mask-position|overflow-wrap|margin-bottom|text-overflow|motion-offset|align-content|grid-template|voice-balance|padding-right|border-radius|justify-items|shape-outside|outline-width|flood-opacity|text-emphasis|marquee-style|offset-before|text-spacing|offset-after|speak-header|float-offset|break-before|text-justify|padding-left|shape-margin|offset-start|justify-self|shape-inside|word-spacing|break-inside|caption-side|border-right|wrap-through|border-width|unicode-bidi|grid-row-gap|grid-row-end|voice-family|column-count|table-layout|pause-before|margin-right|box-suppress|font-kerning|font-stretch|marquee-loop|border-style|font-variant|voice-volume|writing-mode|voice-stress|border-image|border-color|column-width|voice-range|counter-set|rest-before|mask-border|border-left|polar-angle|mask-origin|text-shadow|mask-repeat|play-during|pitch-range|perspective|margin-left|pause-after|page-policy|white-space|voice-pitch|will-change|empty-cells|motion-path|align-items|caret-shape|padding-top|column-fill|caret-color|flex-shrink|line-height|text-indent|wrap-before|float-defer|wrap-inside|speech-rate|column-rule|user-select|font-family|break-after|grid-column|column-span|font-weight|marker-side|flood-color|rest-after|box-sizing|overflow-x|overflow-y|wrap-after|align-self|offset-end|object-fit|visibility|appearance|column-gap|border-top|list-style|min-height|flex-basis|word-break|box-shadow|max-height|background|line-break|text-align|margin-top|ruby-merge|ruby-align|font-style|string-set|cue-before|mask-image|transition|voice-rate|mask-clip|cue-after|font-size|text-wrap|clip-path|grid-area|clip-rule|mask-mode|direction|mask-size|elevation|flow-from|mask-type|line-grid|transform|max-width|word-wrap|flow-into|min-width|flex-flow|flex-grow|nav-right|flex-wrap|animation|wrap-flow|isolation|max-lines|line-snap|tab-size|speak-as|rotation|grid-gap|richness|box-snap|position|overflow|nav-left|grid-row|nav-down|opacity|outline|padding|hyphens|z-index|azimuth|move-to|running|display|columns|content|orphans|resize|quotes|volume|motion|border|margin|chains|filter|nav-up|stress|height|cursor|bottom|widows|right|speak|color|pitch|caret|clear|width|pause|float|order|left|clip|grid|crop|font|flex|mask|size|page|flow|rest|all|top|cue)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\!important"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="/\*(?:.|\n)*?\*/"> + <token type="Comment"/> + </rule> + <rule> + <include state="numeric-values"/> + </rule> + <rule pattern="[~^*!%&<>|+=@:./?-]+"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\](),]+"> + <token type="Punctuation"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[a-zA-Z_][\w-]*"> + <token type="Name"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="2"/> + </rule> + </state> + <state name="function-start"> + <rule> + <include state="common-values"/> + </rule> + <rule pattern="/\*(?:.|\n)*?\*/"> + <token type="Comment"/> + </rule> + <rule> + <include state="numeric-values"/> + </rule> + <rule pattern="[*+/-]"> + <token type="Operator"/> + </rule> + <rule pattern="[,]"> + <token type="Punctuation"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[a-zA-Z_-]\w*"> + <token type="Name"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="atparenthesis"/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="urls"> + <rule pattern="(url)(\()(".*?")(\))"> + <bygroups> + <token type="NameBuiltin"/> + <token type="Punctuation"/> + <token type="LiteralStringDouble"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(url)(\()('.*?')(\))"> + <bygroups> + <token type="NameBuiltin"/> + <token type="Punctuation"/> + <token type="LiteralStringSingle"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(url)(\()(.*?)(\))"> + <bygroups> + <token type="NameBuiltin"/> + <token type="Punctuation"/> + <token type="LiteralStringOther"/> + <token type="Punctuation"/> + </bygroups> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cython.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/cython.xml new file mode 100644 index 0000000..15dfe4d --- /dev/null +++ b/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*)("""(?:.|\n)*?""")"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="^(\s*)('''(?:.|\n)*?''')"> + <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="(<)([a-zA-Z0-9.?]+)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="KeywordType"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="!=|==|<<|>>|[-~+/*%=<>&^|.?]"> + <token type="Operator"/> + </rule> + <rule pattern="(from)(\d+)(<=)(\s+)(<)(\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])""""> + <token type="LiteralString"/> + <push state="tdqs"/> + </rule> + <rule pattern="(?:[rR]|[uU][rR]|[rR][uU])'''"> + <token type="LiteralString"/> + <push state="tsqs"/> + </rule> + <rule pattern="(?:[rR]|[uU][rR]|[rR][uU])""> + <token type="LiteralString"/> + <push state="dqs"/> + </rule> + <rule pattern="(?:[rR]|[uU][rR]|[rR][uU])'"> + <token type="LiteralString"/> + <push state="sqs"/> + </rule> + <rule pattern="[uU]?""""> + <token type="LiteralString"/> + <combined state="stringescape" state="tdqs"/> + </rule> + <rule pattern="[uU]?'''"> + <token type="LiteralString"/> + <combined state="stringescape" state="tsqs"/> + </rule> + <rule pattern="[uU]?""> + <token type="LiteralString"/> + <combined state="stringescape" state="dqs"/> + </rule> + <rule pattern="[uU]?'"> + <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"\']|\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="[^\\\'"%\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="[\'"\\]"> + <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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\"|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings"/> + </rule> + </state> + <state name="tsqs"> + <rule pattern="'''"> + <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="(?=["\'])"> + <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="'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\'|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings"/> + </rule> + </state> + <state name="tdqs"> + <rule pattern="""""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings"/> + </rule> + <rule> + <include state="nl"/> + </rule> + </state> + <state name="builtins"> + <rule pattern="(?<!\.)(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="(?<!\.)(self|None|Ellipsis|NotImplemented|False|True|NULL)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(?<!\.)(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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/d.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/d.xml new file mode 100644 index 0000000..49d7843 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/d.xml @@ -0,0 +1,130 @@ +<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|deprecated|do|else|finally|for|foreach|foreach_reverse|goto|if|in|invariant|is|macro|mixin|new|out|pragma|return|super|switch|this|throw|try|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.\[\]$<>]*\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|enum|export|final|function|inout|lazy|nothrow|override|package|private|protected|public|pure|static|synchronized|template|volatile|__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|string|wstring|dstring)\b"> + <token type="KeywordType"/> + </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]?"(\\\\|\\"|[^"])*"[cwd]?"> + <token type="LiteralString"/> + </rule> + <rule pattern="(`)([^`]*)(`)[cwd]?"> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'"> + <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="([~^*!%&\[\](){}<>|+=:;,./?-]|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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dart.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dart.xml new file mode 100644 index 0000000..f1b454f --- /dev/null +++ b/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="""""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="[^"$\\]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule> + <include state="string_common"/> + </rule> + <rule pattern="(\$|\")+"> + <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="'''"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\'$\\]+"> + <token type="LiteralStringSingle"/> + </rule> + <rule> + <include state="string_common"/> + </rule> + <rule pattern="(\$|\')+"> + <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="[~!%^&*+=|?:<>/-]|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"""([\w\W]*?)""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="r'''([\w\W]*?)'''"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="r"(.*?)""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="r'(.*?)'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="""""> + <token type="LiteralStringDouble"/> + <push state="string_double_multiline"/> + </rule> + <rule pattern="'''"> + <token type="LiteralStringSingle"/> + <push state="string_single_multiline"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string_double"/> + </rule> + <rule pattern="'"> + <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'\"$\\])"> + <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="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="[^"$\\\n]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule> + <include state="string_common"/> + </rule> + <rule pattern="\$+"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="string_single"> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="[^'$\\\n]+"> + <token type="LiteralStringSingle"/> + </rule> + <rule> + <include state="string_common"/> + </rule> + <rule pattern="\$+"> + <token type="LiteralStringSingle"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/diff.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/diff.xml new file mode 100644 index 0000000..c10963e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/diff.xml @@ -0,0 +1,40 @@ +<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="\+.*\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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/django_jinja.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/django_jinja.xml new file mode 100644 index 0000000..3c97c22 --- /dev/null +++ b/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=":?"(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=":?'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="([{}()\[\]+\-*/,:~]|[><=]=?)"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dtd.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dtd.xml new file mode 100644 index 0000000..0edbbde --- /dev/null +++ b/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="(%|&)[^;]*;"> + <token type="NameEntity"/> + </rule> + <rule pattern="<!--"> + <token type="Comment"/> + <push state="comment"/> + </rule> + <rule pattern="[(|)*,?+]"> + <token type="Operator"/> + </rule> + <rule pattern=""[^"]*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\'[^\']*\'"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="comment"> + <rule pattern="[^-]+"> + <token type="Comment"/> + </rule> + <rule pattern="-->"> + <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="[^>\s|()?+*,]+"> + <token type="NameTag"/> + </rule> + <rule pattern=">"> + <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="[^>\s|()?+*,]+"> + <token type="NameAttribute"/> + </rule> + <rule pattern=">"> + <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="[^>\s|()?+*,]+"> + <token type="NameEntity"/> + </rule> + <rule pattern=">"> + <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="[^>\s|()?+*,]+"> + <token type="NameAttribute"/> + </rule> + <rule pattern=">"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="common"/> + </rule> + <rule pattern="(<!ELEMENT)(\s+)(\S+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameTag"/> + </bygroups> + <push state="element"/> + </rule> + <rule pattern="(<!ATTLIST)(\s+)(\S+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameTag"/> + </bygroups> + <push state="attlist"/> + </rule> + <rule pattern="(<!ENTITY)(\s+)(\S+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameEntity"/> + </bygroups> + <push state="entity"/> + </rule> + <rule pattern="(<!NOTATION)(\s+)(\S+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameTag"/> + </bygroups> + <push state="notation"/> + </rule> + <rule pattern="(<!\[)([^\[\s]+)(\s*)(\[)"> + <bygroups> + <token type="Keyword"/> + <token type="NameEntity"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(<!DOCTYPE)(\s+)([^>\s]+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameTag"/> + </bygroups> + </rule> + <rule pattern="PUBLIC|SYSTEM"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="[\[\]>]"> + <token type="Keyword"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dylan.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/dylan.xml new file mode 100644 index 0000000..3660d14 --- /dev/null +++ b/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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|x[a-f0-9]{2,4}|[0-7]{1,3})"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"\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="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\\'\n])'"> + <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!&*<>|^$%@+~?/=-]+)(:)(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!&*<>|^$%@+~?/=-]+)"> + <bygroups> + <token type="Operator"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="(=>|::|#\(|#\[|##|\?\?|\?=|\?|[(){}\[\],.;])"> + <token type="Punctuation"/> + </rule> + <rule pattern=":="> + <token type="Operator"/> + </rule> + <rule pattern="#[tf]"> + <token type="Literal"/> + </rule> + <rule pattern="#""> + <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!&*<>|^$%@+~?/=-]+:"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="<[\w!&*<>|^$%@+~?/=-]+>"> + <token type="NameClass"/> + </rule> + <rule pattern="\*[\w!&*<>|^$%@+~?/=-]+\*"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="\$[\w!&*<>|^$%@+~?/=-]+"> + <token type="NameConstant"/> + </rule> + <rule pattern="(let|method|function)([ \t]+)([\w!&*<>|^$%@+~?/=-]+)"> + <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!&*<>|^$%@+~?/=-]+)"> + <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="""> + <token type="LiteralStringSymbol"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralStringSymbol"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ebnf.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ebnf.xml new file mode 100644 index 0000000..df5d62f --- /dev/null +++ b/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=""[^"]*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'[^']*'"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/elixir.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/elixir.xml new file mode 100644 index 0000000..a3308d6 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/elixir.xml @@ -0,0 +1,743 @@ +<lexer> + <config> + <name>Elixir</name> + <alias>elixir</alias> + <alias>ex</alias> + <alias>exs</alias> + <filename>*.ex</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="[^'\\]+"> + <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-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="[^#'\\]+"> + <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="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*""""> + <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*""""> + <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="=>"> + <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=":(?:\.\.\.|<<>>|%\{\}|%|\{\})"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern=":(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>|\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~|\<|\>|\+|\-|\*|\/|\!|\^|\&))"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern=":""> + <token type="LiteralStringSymbol"/> + <push state="string_double_atom"/> + </rule> + <rule pattern=":'"> + <token type="LiteralStringSymbol"/> + <push state="string_single_atom"/> + </rule> + <rule pattern="((?:\.\.\.|<<>>|%\{\}|%|\{\})|(?:(?:\.\.\.|[a-z_]\w*[!?]?)|[A-Z]\w*(?:\.[A-Z]\w*)*|(?:\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>|\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~|\<|\>|\+|\-|\*|\/|\!|\^|\&)))(:)(?=\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="\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>"> + <token type="Operator"/> + </rule> + <rule pattern="\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~"> + <token type="Operator"/> + </rule> + <rule pattern="\\\\|\<\<|\>\>|\=\>|\(|\)|\:|\;|\,|\[|\]"> + <token type="Punctuation"/> + </rule> + <rule pattern="&\d"> + <token type="NameEntity"/> + </rule> + <rule pattern="\<|\>|\+|\-|\*|\/|\!|\^|\&"> + <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=""""\s*"> + <token type="LiteralStringHeredoc"/> + <push state="heredoc_double"/> + </rule> + <rule pattern="'''\s*$"> + <token type="LiteralStringHeredoc"/> + <push state="heredoc_single"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string_double"/> + </rule> + <rule pattern="'"> + <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])(""")"> + <bygroups> + <token type="LiteralStringOther"/> + <token type="LiteralStringHeredoc"/> + </bygroups> + <push state="triquot-end" state="triquot-intp"/> + </rule> + <rule pattern="(~[A-Z])(""")"> + <bygroups> + <token type="LiteralStringOther"/> + <token type="LiteralStringHeredoc"/> + </bygroups> + <push state="triquot-end" state="triquot-no-intp"/> + </rule> + <rule pattern="(~[a-z])(''')"> + <bygroups> + <token type="LiteralStringOther"/> + <token type="LiteralStringHeredoc"/> + </bygroups> + <push state="triapos-end" state="triapos-intp"/> + </rule> + <rule pattern="(~[A-Z])(''')"> + <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]<"> + <token type="LiteralStringOther"/> + <push state="ab-intp"/> + </rule> + <rule pattern="~[A-Z]<"> + <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]""> + <token type="LiteralStringOther"/> + <push state="quot-intp"/> + </rule> + <rule pattern="~[A-Z]""> + <token type="LiteralStringOther"/> + <push state="quot-no-intp"/> + </rule> + <rule pattern="~[a-z]'"> + <token type="LiteralStringOther"/> + <push state="apos-intp"/> + </rule> + <rule pattern="~[A-Z]'"> + <token type="LiteralStringOther"/> + <push state="apos-no-intp"/> + </rule> + </state> + <state name="triapos-intp"> + <rule pattern="^\s*'''"> + <token type="LiteralStringHeredoc"/> + <pop depth="1"/> + </rule> + <rule> + <include state="heredoc_interpol"/> + </rule> + </state> + <state name="string_single_atom"> + <rule pattern="[^#'\\]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule> + <include state="escapes"/> + </rule> + <rule pattern="\\."> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="(')"> + <bygroups> + <token type="LiteralStringSymbol"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule> + <include state="interpol"/> + </rule> + </state> + <state name="quot-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-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*'''"> + <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="[^#'\\]+"> + <token type="LiteralStringSingle"/> + </rule> + <rule> + <include state="escapes"/> + </rule> + <rule pattern="\\."> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="(')"> + <bygroups> + <token type="LiteralStringSingle"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule> + <include state="interpol"/> + </rule> + </state> + <state name="string_double_atom"> + <rule pattern="[^#"\\]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule> + <include state="escapes"/> + </rule> + <rule pattern="\\."> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="(")"> + <bygroups> + <token type="LiteralStringSymbol"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule> + <include state="interpol"/> + </rule> + </state> + <state name="ab-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="ab-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="quot-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="triapos-no-intp"> + <rule pattern="^\s*'''"> + <token type="LiteralStringHeredoc"/> + <pop depth="1"/> + </rule> + <rule> + <include state="heredoc_no_interpol"/> + </rule> + </state> + <state name="string_double"> + <rule pattern="[^#"\\]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule> + <include state="escapes"/> + </rule> + <rule pattern="\\."> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="(")"> + <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*""""> + <token type="LiteralStringHeredoc"/> + <pop depth="1"/> + </rule> + <rule> + <include state="heredoc_no_interpol"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/elm.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/elm.xml new file mode 100644 index 0000000..ed65efc --- /dev/null +++ b/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="""> + <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="\((<-|\|\||\|>|&&|\+\+|->|\.\.|//|>>|>=|/=|==|::|<~|<\||<=|<<|~|<|=|:|>|'|/|\\|\.|\^|-|`|\+|\*|\||%)\)"> + <token type="NameFunction"/> + </rule> + <rule pattern="(<-|\|\||\|>|&&|\+\+|->|\.\.|//|>>|>=|/=|==|::|<~|<\||<=|<<|~|<|=|:|>|'|/|\\|\.|\^|-|`|\+|\*|\||%)"> + <token type="NameFunction"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule pattern="[a-z_][a-zA-Z_\']*"> + <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\\"]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^"]"> + <token type="LiteralString"/> + </rule> + <rule pattern="""> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/emacslisp.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/emacslisp.xml new file mode 100644 index 0000000..668bc62 --- /dev/null +++ b/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="[^"\\`]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="`((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)\'"> + <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="""> + <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="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="\?([^\\]|\\.)"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern=":((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="::((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="'((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="'"> + <token type="Operator"/> + </rule> + <rule pattern="`"> + <token type="Operator"/> + </rule> + <rule pattern="[-+]?\d+\.?(?=[ "()\]\'\n,;`])"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[-+]?\d+/\d+(?=[ "()\]\'\n,;`])"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[-+]?(\d*\.\d+([defls][-+]?\d+)?|\d+(\.\d*)?[defls][-+]?\d+)(?=[ "()\]\'\n,;`])"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\[|\]"> + <token type="Punctuation"/> + </rule> + <rule pattern="#:((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="#\^\^?"> + <token type="Operator"/> + </rule> + <rule pattern="#\'"> + <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)(?=[ "()\]\'\n,;`])"> + <token type="NameConstant"/> + </rule> + <rule pattern="\*((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)\*"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/erlang.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/erlang.xml new file mode 100644 index 0000000..b186588 --- /dev/null +++ b/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="(\+\+?|--?|\*|/|<|>|/=|=:=|=/=|=<|>=|==?|<-|!|\?)"> + <token type="Operator"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="<<"> + <token type="NameLabel"/> + </rule> + <rule pattern=">>"> + <token type="NameLabel"/> + </rule> + <rule pattern="((?:[a-z]\w*|'[^\n']*[^\\]'))(:)"> + <bygroups> + <token type="NameNamespace"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(?:^|(?<=:))((?:[a-z]\w*|'[^\n']*[^\\]'))(\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="[]\[:_@\".{}()|;,]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?:[A-Z_]\w*)"> + <token type="NameVariable"/> + </rule> + <rule pattern="(?:[a-z]\w*|'[^\n']*[^\\]')"> + <token type="Name"/> + </rule> + <rule pattern="\?(?:(?:[A-Z_]\w*)|(?:[a-z]\w*|'[^\n']*[^\\]'))"> + <token type="NameConstant"/> + </rule> + <rule pattern="\$(?:(?:\\(?:[bdefnrstv\'"\\]|[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*|'[^\n']*[^\\]')(:?\.(?:[a-z]\w*|'[^\n']*[^\\]'))?"> + <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\'"\\]|[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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="~[0-9.*]*[~#+BPWXb-ginpswx]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^"\\~]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="~"> + <token type="LiteralString"/> + </rule> + </state> + <state name="directive"> + <rule pattern="(define)(\s*)(\()((?:(?:[A-Z_]\w*)|(?:[a-z]\w*|'[^\n']*[^\\]')))"> + <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*|'[^\n']*[^\\]')))"> + <bygroups> + <token type="NameEntity"/> + <token type="Text"/> + <token type="Punctuation"/> + <token type="NameLabel"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(?:[a-z]\w*|'[^\n']*[^\\]')"> + <token type="NameEntity"/> + <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=":="> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/factor.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/factor.xml new file mode 100644 index 0000000..4743b9a --- /dev/null +++ b/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+=>\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+=>\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+<\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+<\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="(?:<PRIVATE|PRIVATE>)\s"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern=""""\s+(?:.|\n)*?\s+""""> + <token type="LiteralString"/> + </rule> + <rule pattern=""(?:\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="\S+"\s+(?:\\\\|\\"|[^"])*""> + <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>array|identity-tuple\?|identity-tuple|retainstack|callstack\?|tri-curry\*|tri-curry@|tri-curry|<wrapper>|datastack|bi-curry@|bi-curry\*|hashcode\*|callstack|\?execute|hashcode|boolean\?|compose\?|>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>assoc|value-at\*|assoc-map|delete-at|change-at|assoc>map|value-at|push-at|assoc=|values|set-at|<enum>|inc-at|2cache|value\?|assoc\?|>alist|cache|enum\?|assoc|unzip|key\?|enum|keys|\?at|\?of|zip|at\+|at\*|at|of)\s"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(shallow-spread>quot|recursive-hashcode|linear-case-quot|deep-spread>quot|to-fixed-point|execute-effect|wrong-values\?|4cleave>quot|2cleave>quot|wrong-values|3cleave>quot|cleave>quot|call-effect|alist>quot|case>quot|case-find|cond>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>fixnum-strict|log2-expects-positive|out-of-fixnum-range\?|out-of-fixnum-range|find-last-integer|next-power-of-2|\(all-integers\?\)|integer>fixnum|\(find-integer\)|\(each-integer\)|imaginary-part|fp-nan-payload|all-integers\?|find-integer|each-integer|fp-infinity\?|fp-special\?|fp-bitwise=|bits>double|double>bits|power-of-2\?|unless-zero|denominator|next-float|bits>float|float>bits|prev-float|unordered\?|real-part|when-zero|numerator|rational\?|>integer|rational|complex\?|<fp-nan>|fp-qnan\?|fp-snan\?|integer\?|number=|bignum\?|integer|>fixnum|fp-sign|fp-nan\?|fixnum\?|number\?|complex|if-zero|>bignum|bignum|number|fixnum|float\?|bitxor|ratio\?|bitnot|bitand|>float|real\?|bitor|zero\?|even\?|times|shift|float|recip|align|ratio|neg\?|real|log2|bit\?|odd\?|/mod|\?1\+|mod|rem|neg|sgn|u<=|u>=|abs|u>|2/|2\^|/i|/f|sq|<=|u<|>=|-|\+|<|\*|/|>)\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|<repetition>|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|<reversed>|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|<slice>|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|<array>|1array|2array|3array|4array|>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>error|with-input-stream|with-error>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|<string>|1string|>string|string\?|string)\s"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(<vector>|1vector|>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|<continuation>|original-error|ignore-errors|continue-with|continuation\?|in-callback\?|continuation|error-thread|attempt-all|<condition>|with-return|condition\?|<restart>|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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fennel.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fennel.xml new file mode 100644 index 0000000..b9b6d59 --- /dev/null +++ b/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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="\\(.|[a-z]+)"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="::?#?(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="~@|[`\'#^~&@]"> + <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|-\?>>|each|->>|let|doc|for|and|set|not|-\?>|bor|lua|\?\.|do|>=|<=|//|\.\.|->|or|if|~=|\^|>|=|<|:|/|\.|-|\+|\*|%|#) "> + <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="(?<=\()(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="NameFunction"/> + </rule> + <rule pattern="(?!#)[\w!$%*+<=>?/.#-]+"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fish.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fish.xml new file mode 100644 index 0000000..deb7814 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fish.xml @@ -0,0 +1,159 @@ +<lexer> + <config> + <name>Fish</name> + <alias>fish</alias> + <alias>fishshell</alias> + <filename>*.fish</filename> + <filename>*.load</filename> + <mime_type>application/x-fish</mime_type> + </config> + <rules> + <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="[-+*/%^|&]|\*\*|\|\|"> + <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="root"> + <rule> + <include state="basic"/> + </rule> + <rule> + <include state="interp"/> + </rule> + <rule> + <include state="data"/> + </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="\$#?(\w+|.)"> + <token type="NameVariable"/> + </rule> + </state> + <state name="basic"> + <rule pattern="(?<=(?:^|\A|;|&&|\|\||\||\b(continue|function|return|switch|begin|while|break|count|false|block|echo|case|true|else|exit|test|set|cdh|and|pwd|for|end|not|if|cd|or)\b)\s*)(continue|function|return|switch|begin|while|break|count|false|block|test|case|true|echo|exit|else|set|cdh|and|pwd|for|end|not|if|cd|or)(?=;?\b)"> + <token type="Keyword"/> + </rule> + <rule pattern="(?<=for\s+\S+\s+)in\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(fish_update_completions|fish_command_not_found|fish_breakpoint_prompt|fish_status_to_signal|fish_right_prompt|fish_is_root_user|fish_mode_prompt|fish_vcs_prompt|fish_key_reader|fish_svn_prompt|fish_git_prompt|fish_hg_prompt|fish_greeting|fish_add_path|commandline|fish_prompt|fish_indent|fish_config|fish_pager|breakpoint|fish_title|prompt_pwd|functions|set_color|realpath|funcsave|contains|complete|argparse|fish_opt|history|builtin|getopts|suspend|command|mimedb|printf|ulimit|disown|string|source|funced|status|random|isatty|fishd|prevd|vared|umask|nextd|alias|pushd|emit|jobs|popd|help|psub|wait|fish|read|time|exec|eval|math|trap|type|dirs|dirh|abbr|kill|bind|hash|open|fc|bg|fg)\s*\b(?!\.)"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="#!.*\n"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="#.*\n"> + <token type="Comment"/> + </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="(?<=\[[^\]]+)\.\.|-(?=[^\[]+\])"> + <token type="Operator"/> + </rule> + <rule pattern="<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2"> + <token type="LiteralString"/> + </rule> + <rule pattern="(?<=set\s+(?:--?[^\d\W][\w-]*\s+)?)\w+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(?<=for\s+)\w[\w-]*(?=\s+in)"> + <token type="NameVariable"/> + </rule> + <rule pattern="(?<=function\s+)\w(?:[^\n])*?(?= *[-\n])"> + <token type="NameFunction"/> + </rule> + <rule pattern="(?<=(?:^|\b(?:and|or|sudo)\b|;|\|\||&&|\||\(|(?:\b\w+\s*=\S+\s)) *)\w[\w-]*"> + <token type="NameFunction"/> + </rule> + </state> + <state name="data"> + <rule pattern="(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\$])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="(?s)\$'(\\\\|\\[0-7]+|\\.|[^'\\])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="(?s)'.*?'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + </rule> + <rule pattern="&&|\|\||&|\||\^|<|>"> + <token type="Operator"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\b\d+\b"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="(?<=\s+)--?[^\d][\w-]*"> + <token type="NameAttribute"/> + </rule> + <rule pattern=".+?"> + <token type="Text"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="(?s)(\\\\|\\[0-7]+|\\.|[^"\\$])+"> + <token type="LiteralStringDouble"/> + </rule> + <rule> + <include state="interp"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/forth.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/forth.xml new file mode 100644 index 0000000..31096a2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/forth.xml @@ -0,0 +1,78 @@ +<lexer> + <config> + <name>Forth</name> + <alias>forth</alias> + <filename>*.frt</filename> + <filename>*.fth</filename> + <filename>*.fs</filename> + <mime_type>application/x-forth</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\\.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\([\s].*?\)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(:|variable|constant|value|buffer:)(\s+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="worddef"/> + </rule> + <rule pattern="([.sc]")(\s+?)"> + <bygroups> + <token type="LiteralString"/> + <token type="Text"/> + </bygroups> + <push state="stringdef"/> + </rule> + <rule pattern="(blk|block|buffer|evaluate|flush|load|save-buffers|update|empty-buffers|list|refill|scr|thru|\#s|\*\/mod|\+loop|\/mod|0<|0=|1\+|1-|2!|2\*|2\/|2@|2drop|2dup|2over|2swap|>body|>in|>number|>r|\?dup|abort|abort\"|abs|accept|align|aligned|allot|and|base|begin|bl|c!|c,|c@|cell\+|cells|char|char\+|chars|constant|count|cr|create|decimal|depth|do|does>|drop|dup|else|emit|environment\?|evaluate|execute|exit|fill|find|fm\/mod|here|hold|i|if|immediate|invert|j|key|leave|literal|loop|lshift|m\*|max|min|mod|move|negate|or|over|postpone|quit|r>|r@|recurse|repeat|rot|rshift|s\"|s>d|sign|sm\/rem|source|space|spaces|state|swap|then|type|u\.|u\<|um\*|um\/mod|unloop|until|variable|while|word|xor|\[char\]|\[\'\]|@|!|\#|<\#|\#>|:|;|\+|-|\*|\/|,|<|>|\|1\+|1-|\.|\.r|0<>|0>|2>r|2r>|2r@|:noname|\?do|again|c\"|case|compile,|endcase|endof|erase|false|hex|marker|nip|of|pad|parse|pick|refill|restore-input|roll|save-input|source-id|to|true|tuck|u\.r|u>|unused|value|within|\[compile\]|\#tib|convert|expect|query|span|tib|2constant|2literal|2variable|d\+|d-|d\.|d\.r|d0<|d0=|d2\*|d2\/|d<|d=|d>s|dabs|dmax|dmin|dnegate|m\*\/|m\+|2rot|du<|catch|throw|abort|abort\"|at-xy|key\?|page|ekey|ekey>char|ekey\?|emit\?|ms|time&date|BIN|CLOSE-FILE|CREATE-FILE|DELETE-FILE|FILE-POSITION|FILE-SIZE|INCLUDE-FILE|INCLUDED|OPEN-FILE|R\/O|R\/W|READ-FILE|READ-LINE|REPOSITION-FILE|RESIZE-FILE|S\"|SOURCE-ID|W/O|WRITE-FILE|WRITE-LINE|FILE-STATUS|FLUSH-FILE|REFILL|RENAME-FILE|>float|d>f|f!|f\*|f\+|f-|f\/|f0<|f0=|f<|f>d|f@|falign|faligned|fconstant|fdepth|fdrop|fdup|fliteral|float\+|floats|floor|fmax|fmin|fnegate|fover|frot|fround|fswap|fvariable|represent|df!|df@|dfalign|dfaligned|dfloat\+|dfloats|f\*\*|f\.|fabs|facos|facosh|falog|fasin|fasinh|fatan|fatan2|fatanh|fcos|fcosh|fe\.|fexp|fexpm1|fln|flnp1|flog|fs\.|fsin|fsincos|fsinh|fsqrt|ftan|ftanh|f~|precision|set-precision|sf!|sf@|sfalign|sfaligned|sfloat\+|sfloats|\(local\)|to|locals\||allocate|free|resize|definitions|find|forth-wordlist|get-current|get-order|search-wordlist|set-current|set-order|wordlist|also|forth|only|order|previous|-trailing|\/string|blank|cmove|cmove>|compare|search|sliteral|.s|dump|see|words|;code|ahead|assembler|bye|code|cs-pick|cs-roll|editor|state|\[else\]|\[if\]|\[then\]|forget|defer|defer@|defer!|action-of|begin-structure|field:|buffer:|parse-name|buffer:|traverse-wordlist|n>r|nr>|2value|fvalue|name>interpret|name>compile|name>string|cfield:|end-structure)\s"> + <token type="Keyword"/> + </rule> + <rule pattern="(\$[0-9A-F]+)"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(\#|%|&|\-|\+)?[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(\#|%|&|\-|\+)?[0-9.]+"> + <token type="KeywordType"/> + </rule> + <rule pattern="(@i|!i|@e|!e|pause|noop|turnkey|sleep|itype|icompare|sp@|sp!|rp@|rp!|up@|up!|>a|a>|a@|a!|a@+|a@-|>b|b>|b@|b!|b@+|b@-|find-name|1ms|sp0|rp0|\(evaluate\)|int-trap|int!)\s"> + <token type="NameConstant"/> + </rule> + <rule pattern="(do-recognizer|r:fail|recognizer:|get-recognizers|set-recognizers|r:float|r>comp|r>int|r>post|r:name|r:word|r:dnum|r:num|recognizer|forth-recognizer|rec:num|rec:float|rec:word)\s"> + <token type="NameDecorator"/> + </rule> + <rule pattern="(Evalue|Rvalue|Uvalue|Edefer|Rdefer|Udefer)(\s+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="worddef"/> + </rule> + <rule pattern="[^\s]+(?=[\s])"> + <token type="NameFunction"/> + </rule> + </state> + <state name="worddef"> + <rule pattern="\S+"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="stringdef"> + <rule pattern="[^"]+"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fortran.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fortran.xml new file mode 100644 index 0000000..012808b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fortran.xml @@ -0,0 +1,82 @@ +<lexer> + <config> + <name>Fortran</name> + <alias>fortran</alias> + <filename>*.f03</filename> + <filename>*.f90</filename> + <filename>*.F03</filename> + <filename>*.F90</filename> + <mime_type>text/x-fortran</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="core"> + <rule pattern="\b(NON_OVERRIDABLE|NON_INTRINSIC|ASYNCHRONOUS|ALLOCATABLE|CODIMENSION|EQUIVALENCE|CONCURRRENT|SYNCMEMORY|SUBROUTINE|CONTIGUOUS|SYNCIMAGES|ENUMERATOR|DEALLOCATE|BLOCKDATA|BACKSPACE|PROTECTED|RECURSIVE|PROCEDURE|SUBMODULE|EXTRINSIC|ASSOCIATE|PARAMETER|INTERFACE|ELEMENTAL|DIMENSION|INTRINSIC|ABSTRACT|EXTERNAL|CRITICAL|SEQUENCE|DEFERRED|CONTINUE|NAMELIST|CONTAINS|OPTIONAL|ALLOCATE|VOLATILE|IMPLICIT|FUNCTION|SYNCALL|INCLUDE|INQUIRE|EXTENDS|ALLSTOP|OPTIONS|PROGRAM|PRIVATE|POINTER|NULLIFY|GENERIC|FORMAT|FORALL|ENCODE|IMAGES|UNLOCK|ASSIGN|IMPURE|TARGET|PUBLIC|INTENT|RESULT|ACCEPT|COMMON|RETURN|MEMORY|MODULE|REWIND|DECODE|NOPASS|SELECT|IMPORT|ENTRY|BLOCK|CLASS|WRITE|WHERE|CLOSE|PAUSE|CYCLE|PRINT|FINAL|WHILE|ARRAY|VALUE|SAVE|PURE|READ|SYNC|ENUM|ELSE|EXIT|FILE|DATA|GOTO|STOP|PASS|LOCK|CASE|CALL|BYTE|OPEN|BIND|THEN|TYPE|NONE|USE|END|ALL|IF|IS|DO)\s*\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(C_LONG_DOUBLE_COMPLEX|DOUBLE PRECISION|C_DOUBLE_COMPLEX|C_INT_LEAST32_T|C_INT_LEAST64_T|C_FLOAT_COMPLEX|C_INT_LEAST16_T|C_INT_LEAST8_T|C_INT_FAST32_T|C_INT_FAST64_T|DOUBLE COMPLEX|C_INT_FAST16_T|C_SIGNED_CHAR|C_LONG_DOUBLE|C_INT_FAST8_T|C_LONG_LONG|C_INTMAX_T|C_INTPTR_T|C_INT32_T|C_INT64_T|C_INT16_T|CHARACTER|C_DOUBLE|C_SIZE_T|C_INT8_T|C_FUNPTR|COMPLEX|C_FLOAT|C_SHORT|LOGICAL|INTEGER|C_LONG|C_BOOL|C_CHAR|C_INT|C_PTR|REAL)\s*\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(\*\*|\*|\+|-|\/|<|>|<=|>=|==|\/=|=)"> + <token type="Operator"/> + </rule> + <rule pattern="(::)"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="[()\[\],:&%;.]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\b(Get_Environment_Variable|Command_Argument_Count|Execute_Command_Line|Get_Command_Argument|Selected_Real_Kind|Selected_Char_Kind|C_Carriage_Return|Selected_Int_Kind|C_Horizontal_Tab|Extends_Type_Of|C_F_ProcPointer|C_Vertical_Tab|Date_and_Time|Is_Contiguous|C_Null_Funptr|Atomic_Define|Is_Iostat_Eor|Iso_C_Binding|Random_Number|Is_Iostat_End|C_Associated|Same_Type_As|Storage_Size|System_Clock|Set_Exponent|ErFC_Scaled|Get_Command|Dot_Product|C_Backspace|C_Null_Char|Image_Index|C_F_Pointer|MinExponent|Random_Seed|MaxExponent|C_Form_Feed|Move_Alloc|C_New_Line|Num_Images|Atomic_Ref|Associated|This_Image|Merge_Bits|C_Null_Ptr|Bessel_Y1|Bessel_JN|Bessel_J1|Bessel_J0|Transpose|RRSpacing|Allocated|Log_Gamma|Precision|Bessel_YN|Bessel_Y0|Bit_Size|Transfer|LCoBound|CPU_Time|UCoBound|Fraction|C_Sizeof|Exponent|ImagPart|C_FunLoc|New_Line|RealPart|Len_Trim|C_Alert|Spacing|Ceiling|Epsilon|AdjustR|Product|Complex|DShiftR|AdjustL|DShiftL|Present|IParity|Reshape|FindLoc|EOShift|Logical|Nearest|Digits|Modulo|DbesYN|MaxVal|TrailZ|MvBits|DbesJN|Second|IDNInt|IAChar|MinVal|IErrNo|RShift|TtyNam|MinLoc|Repeat|Rename|LShift|UBound|System|Parity|HostNm|LBound|SymLnk|MClock|GMTime|GetUId|GetPId|GetLog|PError|Spread|MaxLoc|Unlink|MatMul|GetGId|Signal|GetEnv|IShftC|IsaTty|ShiftA|GetCWD|CShift|LnBlnk|ShiftL|Unpack|Access|GetArg|Verify|GError|ShiftR|DNInt|FSeek|FStat|FTell|Gamma|FPutC|Flush|Floor|Float|FGetC|FDate|Radix|ETime|DTime|Range|DTanH|DSqRt|DSinH|DSign|Hypot|DProd|Scale|Norm2|DErFC|DCosH|IArgC|IBClr|IBits|IBSet|IChar|IDate|DbesY|IDInt|DbesJ|DATan|DASin|DACos|Shape|C_Loc|CTime|Index|CSqRt|Count|Conjg|Cmplx|Short|IShft|ChMod|ISign|ChDir|Sleep|BTest|SRand|ITime|Merge|BesYN|BesJN|ATanH|ASinH|ANInt|UMask|Alarm|AImag|MaskR|MaskL|ACosH|LTime|LStat|AChar|IRand|Abort|ZSqRt|SqRt|ZLog|ZExp|ZCos|Link|ZAbs|ACos|AInt|ALog|Kind|Kill|Long|ZSin|AMin|Imag|IFix|IEOr|Trim|IDiM|IAny|IAnd|Sign|NInt|AMod|Tiny|Null|IAbs|ASin|Pack|Huge|FPut|FNum|FGet|Time|Exit|Rand|ErFC|TanH|DTan|Real|DSin|DMod|DMin|DMax|DLog|DInt|ATan|DExp|Scan|DErF|DDiM|DCos|Dble|DAbs|BesJ|CSin|CosH|BesY|CLog|Char|CExp|SinH|Stat|CCos|Sngl|CAbs|IAll|AMax|IOr|Sin|BGE|Sum|Cos|BGT|DiM|Tan|ErF|Exp|Log|Not|Any|And|BLE|Mod|Min|Int|Len|All|LGe|LGt|Abs|XOr|Max|LLe|LLt|Loc|BLT|Or)\s*\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\.(true|false)\."> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\.(eq|ne|lt|le|gt|ge|not|and|or|eqv|neqv)\."> + <token type="OperatorWord"/> + </rule> + </state> + <state name="strings"> + <rule pattern="(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="nums"> + <rule pattern="\d+(?![.e])(_[a-z]\w+)?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[+-]?\d*\.\d+([ed][-+]?\d+)?(_[a-z]\w+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+-]?\d+\.\d*([ed][-+]?\d+)?(_[a-z]\w+)?"> + <token type="LiteralNumberFloat"/> + </rule> + </state> + <state name="root"> + <rule pattern="^#.*\n"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="!.*\n"> + <token type="Comment"/> + </rule> + <rule> + <include state="strings"/> + </rule> + <rule> + <include state="core"/> + </rule> + <rule pattern="[a-z][\w$]*"> + <token type="Name"/> + </rule> + <rule> + <include state="nums"/> + </rule> + <rule pattern="[\s]+"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fsharp.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fsharp.xml new file mode 100644 index 0000000..f608979 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/fsharp.xml @@ -0,0 +1,245 @@ +<lexer> + <config> + <name>FSharp</name> + <alias>fsharp</alias> + <filename>*.fs</filename> + <filename>*.fsi</filename> + <mime_type>text/x-fsharp</mime_type> + </config> + <rules> + <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="LiteralString"/> + <push state="lstring"/> + </rule> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="tqs"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="[(*)@]"> + <token type="Comment"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^\\"]+"> + <token type="LiteralString"/> + </rule> + <rule> + <include state="escape-sequence"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="\n"> + <token type="LiteralString"/> + </rule> + <rule pattern=""B?"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="lstring"> + <rule pattern="[^"]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\n"> + <token type="LiteralString"/> + </rule> + <rule pattern=""""> + <token type="LiteralString"/> + </rule> + <rule pattern=""B?"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="tqs"> + <rule pattern="[^"]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\n"> + <token type="LiteralString"/> + </rule> + <rule pattern=""""B?"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + </rule> + </state> + <state name="escape-sequence"> + <rule pattern="\\[\\"\'ntbrafv]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\[0-9]{3}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\u[0-9a-fA-F]{4}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\U[0-9a-fA-F]{8}"> + <token type="LiteralStringEscape"/> + </rule> + </state> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\(\)|\[\]"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="\b(?<!\.)([A-Z][\w\']*)(?=\s*\.)"> + <token type="NameNamespace"/> + <push state="dotted"/> + </rule> + <rule pattern="\b([A-Z][\w\']*)"> + <token type="Name"/> + </rule> + <rule pattern="///.*?\n"> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\(\*(?!\))"> + <token type="Comment"/> + <push state="comment"/> + </rule> + <rule pattern="@""> + <token type="LiteralString"/> + <push state="lstring"/> + </rule> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="tqs"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="\b(open|module)(\s+)([\w.]+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="\b(let!?)(\s+)(\w+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="\b(type)(\s+)(\w+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="\b(member|override)(\s+)(\w+)(\.)(\w+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Name"/> + <token type="Punctuation"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="\b(abstract|as|assert|base|begin|class|default|delegate|do!|do|done|downcast|downto|elif|else|end|exception|extern|false|finally|for|function|fun|global|if|inherit|inline|interface|internal|in|lazy|let!|let|match|member|module|mutable|namespace|new|null|of|open|override|private|public|rec|return!|return|select|static|struct|then|to|true|try|type|upcast|use!|use|val|void|when|while|with|yield!|yield|atomic|break|checked|component|const|constraint|constructor|continue|eager|event|external|fixed|functor|include|method|mixin|object|parallel|process|protected|pure|sealed|tailcall|trait|virtual|volatile)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="``([^`\n\r\t]|`[^`\n\r\t])+``"> + <token type="Name"/> + </rule> + <rule pattern="#[ \t]*(if|endif|else|line|nowarn|light|r|\d+)\b"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="(!=|#|&&|&|\(|\)|\*|\+|,|-\.|->|-|\.\.|\.|::|:=|:>|:|;;|;|<-|<\]|<|>\]|>|\?\?|\?|\[<|\[\||\[|\]|_|`|\{|\|\]|\||\}|~|<@@|<@|=|@>|@@>)"> + <token type="Operator"/> + </rule> + <rule pattern="([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]"> + <token type="Operator"/> + </rule> + <rule pattern="\b(and|or|not)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="\b(sbyte|byte|char|nativeint|unativeint|float32|single|float|double|int8|uint8|int16|uint16|int32|uint32|int64|uint64|decimal|unit|bool|string|list|exn|obj|enum)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[^\W\d][\w']*"> + <token type="Name"/> + </rule> + <rule pattern="\d[\d_]*[uU]?[yslLnQRZINGmM]?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0[oO][0-7][0-7_]*[uU]?[yslLn]?"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[bB][01][01_]*[uU]?[yslLn]?"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'B?"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'.'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'"> + <token type="Keyword"/> + </rule> + <rule pattern="@?""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="[~?][a-z][\w\']*:"> + <token type="NameVariable"/> + </rule> + </state> + <state name="dotted"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\."> + <token type="Punctuation"/> + </rule> + <rule pattern="[A-Z][\w\']*(?=\s*\.)"> + <token type="NameNamespace"/> + </rule> + <rule pattern="[A-Z][\w\']*"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-z_][\w\']*"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer> diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gas.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gas.xml new file mode 100644 index 0000000..1ef31de --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gas.xml @@ -0,0 +1,121 @@ +<lexer> + <config> + <name>GAS</name> + <alias>gas</alias> + <alias>asm</alias> + <filename>*.s</filename> + <filename>*.S</filename> + <mime_type>text/x-gas</mime_type> + </config> + <rules> + <state name="punctuation"> + <rule pattern="[-*,.()\[\]!:]+"> + <token type="Punctuation"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+):"> + <token type="NameLabel"/> + </rule> + <rule pattern="\.(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)"> + <token type="NameAttribute"/> + <push state="directive-args"/> + </rule> + <rule pattern="lock|rep(n?z)?|data\d+"> + <token type="NameAttribute"/> + </rule> + <rule pattern="(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)"> + <token type="NameFunction"/> + <push state="instruction-args"/> + </rule> + <rule pattern="[\r\n]+"> + <token type="Text"/> + </rule> + </state> + <state name="directive-args"> + <rule pattern="(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)"> + <token type="NameConstant"/> + </rule> + <rule pattern=""(\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="@(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)"> + <token type="NameAttribute"/> + </rule> + <rule pattern="(?:0[xX][a-zA-Z0-9]+|\d+)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[\r\n]+"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + </state> + <state name="instruction-args"> + <rule pattern="([a-z0-9]+)( )(<)((?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+))(>)"> + <bygroups> + <token type="LiteralNumberHex"/> + <token type="Text"/> + <token type="Punctuation"/> + <token type="NameConstant"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="([a-z0-9]+)( )(<)((?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+))([-+])((?:0[xX][a-zA-Z0-9]+|\d+))(>)"> + <bygroups> + <token type="LiteralNumberHex"/> + <token type="Text"/> + <token type="Punctuation"/> + <token type="NameConstant"/> + <token type="Punctuation"/> + <token type="LiteralNumberInteger"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)"> + <token type="NameConstant"/> + </rule> + <rule pattern="(?:0[xX][a-zA-Z0-9]+|\d+)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="%(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)"> + <token type="NameVariable"/> + </rule> + <rule pattern="$(?:0[xX][a-zA-Z0-9]+|\d+)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="$'(.|\\')'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="[\r\n]+"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[;#].*?\n"> + <token type="Comment"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gdscript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gdscript.xml new file mode 100644 index 0000000..fb75fc8 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gdscript.xml @@ -0,0 +1,265 @@ +<lexer> + <config> + <name>GDScript</name> + <alias>gdscript</alias> + <alias>gd</alias> + <filename>*.gd</filename> + <mime_type>text/x-gdscript</mime_type> + <mime_type>application/x-gdscript</mime_type> + </config> + <rules> + <state name="builtins"> + <rule pattern="(?<!\.)(instance_from_id|nearest_po2|print_stack|type_exist|rand_range|linear2db|var2bytes|dict2inst|randomize|bytes2var|rand_seed|db2linear|inst2dict|printerr|printraw|decimals|preload|deg2rad|str2var|stepify|var2str|convert|weakref|fposmod|funcref|rad2deg|dectime|printt|is_inf|is_nan|assert|Color8|typeof|ColorN|prints|floor|atan2|yield|randf|print|range|clamp|round|randi|sqrt|tanh|cosh|ceil|ease|acos|load|fmod|lerp|seed|sign|atan|sinh|hash|asin|sin|str|cos|tan|pow|exp|min|abs|log|max)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<!\.)(self|false|true|PI|NAN|INF)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(?<!\.)(Physics2DShapeQueryParameters|PhysicsShapeQueryParameters|Physics2DDirectBodyStateSW|NavigationPolygonInstance|ResourceInteractiveLoader|Physics2DDirectSpaceState|Physics2DShapeQueryResult|Physics2DTestMotionResult|InputEventJoystickButton|InputEventJoystickMotion|Physics2DDirectBodyState|PhysicsDirectBodyStateSW|PhysicsShapeQueryResult|PhysicsDirectSpaceState|SpatialSound2DServerSW|PackedDataContainerRef|NavigationMeshInstance|ResourceImportMetadata|PhysicsDirectBodyState|ConcavePolygonShape2D|CanvasItemShaderGraph|EditorScenePostImport|InputEventScreenTouch|InputEventMouseButton|InputEventMouseMotion|SpatialSound2DServer|AudioStreamOGGVorbis|VisibilityNotifier2D|InputEventScreenDrag|ConvexPolygonShape2D|SpatialSoundServerSW|ParticleAttractor2D|PackedDataContainer|SpatialStreamPlayer|RenderTargetTexture|AnimationTreePlayer|ConcavePolygonShape|InstancePlaceholder|MaterialShaderGraph|AudioStreamPlayback|VisibilityEnabler2D|SpatialSamplePlayer|DampedSpringJoint2D|InterpolatedCamera|ConvexPolygonShape|ConfirmationDialog|SpatialSoundServer|BakedLightInstance|ParallaxBackground|CollisionPolygon2D|CanvasItemMaterial|VisibilityNotifier|EditorImportPlugin|VideoStreamTheora|TouchScreenButton|ResourcePreloader|OccluderPolygon2D|BakedLightSampler|CollisionObject2D|RemoteTransform2D|PolygonPathFinder|StyleBoxImageMask|NavigationPolygon|TranslationServer|MultiMeshInstance|ImmediateGeometry|Physics2DServerSW|ColorPickerButton|VisibilityEnabler|PHashTranslation|RectangleShape2D|DirectionalLight|AnimatedSprite3D|WorldEnvironment|CollisionShape2D|EventStreamChibi|InputEventAction|CollisionPolygon|AudioStreamSpeex|EditorFileDialog|GeometryInstance|Generic6DOFJoint|PacketPeerStream|CanvasItemShader|KinematicBody2D|StyleBoxTexture|PhysicsServerSW|VSplitContainer|CenterContainer|GDFunctionState|AudioStreamOpus|TextureProgress|MarginContainer|CollisionObject|LightOccluder2D|AnimationPlayer|HSplitContainer|ScrollContainer|SoundRoomParams|Physics2DServer|MaterialShader|ShaderMaterial|ViewportSprite|SplitContainer|AudioStreamMPC|VisualInstance|PanelContainer|BackBufferCopy|SamplePlayer2D|CanvasModulate|ResourceLoader|CapsuleShape2D|ReferenceFrame|NavigationMesh|CollisionShape|ConeTwistJoint|ProximityGroup|AnimatedSprite|SegmentShape2D|BoneAttachment|RichTextLabel|CircleShape2D|VBoxContainer|PacketPeerUDP|SpatialPlayer|TextureButton|KinematicBody|SoundPlayer2D|PhysicsServer|ParallaxLayer|InputEventKey|GrooveJoint2D|PhysicsBody2D|FixedMaterial|GridContainer|HBoxContainer|StreamPeerSSL|StyleBoxEmpty|StreamPeerTCP|SampleLibrary|GDNativeClass|AudioServerSW|ResourceSaver|SpriteBase3D|StreamPlayer|AtlasTexture|VisualServer|SamplePlayer|StyleBoxFlat|StaticBody2D|SpriteFrames|MeshDataTool|MeshInstance|Vector3Array|BoxContainer|TabContainer|HButtonArray|LargeTexture|Navigation2D|WindowDialog|EditorScript|EditorPlugin|TextureFrame|AcceptDialog|ImageTexture|CapsuleShape|VehicleWheel|VButtonArray|Vector2Array|InputDefault|OptionButton|PathFollow2D|VehicleBody|ColorPicker|PopupDialog|ProgressBar|CanvasLayer|Translation|Environment|EventPlayer|VideoPlayer|EventStream|VideoStream|ButtonGroup|Particles2D|Patch9Frame|ButtonArray|SurfaceTool|MeshLibrary|PackedScene|PhysicsBody|AudioStream|Performance|StringArray|AudioServer|RigidBody2D|LineShape2D|SliderJoint|SphereShape|ShaderGraph|CheckButton|StreamPeer|FileDialog|PathFollow|SceneState|RoomBounds|Dictionary|VSeparator|PacketPeer|VScrollBar|MenuButton|HTTPClient|PinJoint2D|BakedLight|PlaneShape|InputEvent|BaseButton|HSeparator|HScrollBar|Navigation|PopupPanel|StaticBody|Position2D|Position3D|ToolButton|HingeJoint|CanvasItem|RayShape2D|ColorArray|ConfigFile|TCP_Server|RayCast2D|ColorRamp|SpotLight|RealArray|GraphNode|Container|Reference|PopupMenu|Separator|Polygon2D|MultiMesh|Semaphore|Transform|OmniLight|GraphEdit|Particles|Animation|Marshalls|SceneTree|RigidBody|XMLParser|PathRemap|ScrollBar|Directory|PCKPacker|RawArray|TextEdit|MainLoop|TreeItem|StyleBox|Material|Geometry|Matrix32|Resource|UndoRedo|RayShape|TestCube|ItemList|CheckBox|Camera2D|Skeleton|Sprite3D|Viewport|NodePath|IntArray|BoxShape|PinJoint|InputMap|LineEdit|GDScript|Vector3|TileMap|HSlider|Spatial|SpinBox|World2D|IP_Unix|Curve2D|Curve3D|WeakRef|GridMap|Matrix3|VSlider|CubeMap|Joint2D|Globals|Shape2D|Texture|Control|TileSet|Light2D|FuncRef|Vector2|RayCast|Script|Node2D|Button|BitMap|Sample|Object|String|Shader|Area2D|Slider|Sprite|Thread|Path2D|Camera|Portal|float|Theme|World|YSort|Shape|Joint|Mutex|Tween|RegEx|Label|Rect2|Array|Plane|Light|Range|Color|Input|Popup|Panel|Timer|Image|Area|Quad|bool|AABB|Quat|File|Tabs|Path|Font|Tree|Room|Mesh|Node|RID|int|Nil|IP|OS)\b"> + <token type="NameException"/> + </rule> + </state> + <state name="sqs"> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\'|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings-single"/> + </rule> + </state> + <state name="stringescape"> + <rule pattern="\\([\\abfnrtv"\']|\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="classname"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="strings-single"> + <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^\\\'"%\n]+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="%"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="funcname"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+[eE][+-]?[0-9]+j?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[xX][a-fA-F0-9]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d+j?"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="tdqs"> + <rule pattern="""""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings-double"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="name"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="[]{}:(),;[]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="\\"> + <token type="Text"/> + </rule> + <rule pattern="(in|and|or|not)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="!=|==|<<|>>|&&|\+=|-=|\*=|/=|%=|&=|\|=|\|\||[-~+/*%=<>&^.!|$]"> + <token type="Operator"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule pattern="(def)((?:\s|\\\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="funcname"/> + </rule> + <rule pattern="(class)((?:\s|\\\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="classname"/> + </rule> + <rule> + <include state="builtins"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <push state="tdqs"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="tsqs"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <push state="dqs"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="sqs"/> + </rule> + <rule pattern="([uUbB]?)(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="stringescape" state="tdqs"/> + </rule> + <rule pattern="([uUbB]?)(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="stringescape" state="tsqs"/> + </rule> + <rule pattern="([uUbB]?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="stringescape" state="dqs"/> + </rule> + <rule pattern="([uUbB]?)(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="stringescape" state="sqs"/> + </rule> + <rule> + <include state="name"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(breakpoint|continue|onready|extends|signal|return|export|static|setget|switch|break|const|while|class|tool|pass|func|case|enum|else|elif|var|for|do|if)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="dqs"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\"|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings-double"/> + </rule> + </state> + <state name="tsqs"> + <rule pattern="'''"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings-single"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="strings-double"> + <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^\\\'"%\n]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="%"> + <token type="LiteralStringDouble"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gherkin.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gherkin.xml new file mode 100644 index 0000000..c53a2cb --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gherkin.xml @@ -0,0 +1,263 @@ +<lexer> + <config> + <name>Gherkin</name> + <alias>cucumber</alias> + <alias>Cucumber</alias> + <alias>gherkin</alias> + <alias>Gherkin</alias> + <filename>*.feature</filename> + <filename>*.FEATURE</filename> + <mime_type>text/x-gherkin</mime_type> + </config> + <rules> + <state name="comments"> + <rule pattern="\s*#.*$"> + <token type="Comment"/> + </rule> + </state> + <state name="featureElementsOnStack"> + <rule pattern="^(\s*)(하지만|조건|먼저|만일|만약|단|그리고|그러면|那麼|那么|而且|當|当|前提|假設|假设|假如|假定|但是|但し|並且|并且|同時|同时|もし|ならば|ただし|しかし|かつ|و |متى |لكن |عندما |ثم |بفرض |اذاً |כאשר |וגם |בהינתן |אזי |אז |אבל |Якщо |Унда |То |Припустимо, що |Припустимо |Онда |Но |Нехай |Лекин |Когато |Када |Кад |К тому же |И |Задато |Задати |Задате |Если |Допустим |Дадено |Ва |Бирок |Аммо |Али |Але |Агар |А |І |Și |És |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Youse know when youse got |Youse know like when |Yna |Ya know how |Ya gotta |Y |Wun |Wtedy |When y'all |When |Wenn |WEN |Và |Ve |Und |Un |Thì |Then y'all |Then |Tapi |Tak |Tada |Tad |Så |Stel |Soit |Siis |Si |Sed |Se |Quando |Quand |Quan |Pryd |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Når |När |Niin |Nhưng |N |Mutta |Men |Mas |Maka |Majd |Mais |Maar |Ma |Lorsque |Lorsqu'|Kun |Kuid |Kui |Khi |Keď |Ketika |Když |Kaj |Kai |Kada |Kad |Jeżeli |Ja |Ir |I CAN HAZ |I |Ha |Givun |Givet |Given y'all |Given |Gitt |Gegeven |Gegeben sei |Fakat |Eğer ki |Etant donné |Et |Então |Entonces |Entao |En |Eeldades |E |Duota |Dun |Donitaĵo |Donat |Donada |Do |Diyelim ki |Dengan |Den youse gotta |De |Dato |Dar |Dann |Dan |Dado |Dacă |Daca |DEN |Când |Cuando |Cho |Cept |Cand |Cal |But y'all |But |Buh |Biết |Bet |BUT |Atès |Atunci |Atesa |Anrhegedig a |Angenommen |And y'all |And |An |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Aber |AN |A také |A |\* )"> + <token type="Keyword"/> + <pop depth="2"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="(\s|.)"> + <token type="NameFunction"/> + </rule> + </state> + <state name="tableContent"> + <rule pattern="\s+\|\s*$"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="\\\|"> + <token type="LiteralString"/> + </rule> + <rule pattern="\s*\|"> + <token type="Keyword"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="doubleStringTable"/> + </rule> + <rule> + <include state="string"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?"> + <token type="LiteralString"/> + </rule> + </state> + <state name="tableVars"> + <rule pattern="(<[^>]+>)"> + <token type="NameVariable"/> + </rule> + </state> + <state name="doubleString"> + <rule pattern="""> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule> + <include state="string"/> + </rule> + </state> + <state name="featureElements"> + <rule pattern="^(\s*)(하지만|조건|먼저|만일|만약|단|그리고|그러면|那麼|那么|而且|當|当|前提|假設|假设|假如|假定|但是|但し|並且|并且|同時|同时|もし|ならば|ただし|しかし|かつ|و |متى |لكن |عندما |ثم |بفرض |اذاً |כאשר |וגם |בהינתן |אזי |אז |אבל |Якщо |Унда |То |Припустимо, що |Припустимо |Онда |Но |Нехай |Лекин |Когато |Када |Кад |К тому же |И |Задато |Задати |Задате |Если |Допустим |Дадено |Ва |Бирок |Аммо |Али |Але |Агар |А |І |Și |És |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Youse know when youse got |Youse know like when |Yna |Ya know how |Ya gotta |Y |Wun |Wtedy |When y'all |When |Wenn |WEN |Và |Ve |Und |Un |Thì |Then y'all |Then |Tapi |Tak |Tada |Tad |Så |Stel |Soit |Siis |Si |Sed |Se |Quando |Quand |Quan |Pryd |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Når |När |Niin |Nhưng |N |Mutta |Men |Mas |Maka |Majd |Mais |Maar |Ma |Lorsque |Lorsqu'|Kun |Kuid |Kui |Khi |Keď |Ketika |Když |Kaj |Kai |Kada |Kad |Jeżeli |Ja |Ir |I CAN HAZ |I |Ha |Givun |Givet |Given y'all |Given |Gitt |Gegeven |Gegeben sei |Fakat |Eğer ki |Etant donné |Et |Então |Entonces |Entao |En |Eeldades |E |Duota |Dun |Donitaĵo |Donat |Donada |Do |Diyelim ki |Dengan |Den youse gotta |De |Dato |Dar |Dann |Dan |Dado |Dacă |Daca |DEN |Când |Cuando |Cho |Cept |Cand |Cal |But y'all |But |Buh |Biết |Bet |BUT |Atès |Atunci |Atesa |Anrhegedig a |Angenommen |And y'all |And |An |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Aber |AN |A také |A |\* )"> + <token type="Keyword"/> + <push state="stepContentStack"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="(\s|.)"> + <token type="NameFunction"/> + </rule> + </state> + <state name="examplesTableHeader"> + <rule pattern="\s+\|\s*$"> + <token type="Keyword"/> + <pop depth="2"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="\\\|"> + <token type="NameVariable"/> + </rule> + <rule pattern="\s*\|"> + <token type="Keyword"/> + </rule> + <rule pattern="[^|]"> + <token type="NameVariable"/> + </rule> + </state> + <state name="stepContentStack"> + <rule pattern="$"> + <token type="Keyword"/> + <pop depth="2"/> + </rule> + <rule> + <include state="stepContent"/> + </rule> + </state> + <state name="pyString"> + <rule pattern="""""> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <include state="string"/> + </rule> + </state> + <state name="examplesTable"> + <rule pattern="\s+\|"> + <token type="Keyword"/> + <push state="examplesTableHeader"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="(\s|.)"> + <token type="NameFunction"/> + </rule> + </state> + <state name="stepContentRoot"> + <rule pattern="$"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <include state="stepContent"/> + </rule> + </state> + <state name="doubleStringTable"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <include state="string"/> + </rule> + </state> + <state name="string"> + <rule> + <include state="tableVars"/> + </rule> + <rule pattern="(\s|.)"> + <token type="LiteralString"/> + </rule> + </state> + <state name="stepContent"> + <rule pattern="""> + <token type="NameFunction"/> + <push state="doubleString"/> + </rule> + <rule> + <include state="tableVars"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="(\s|.)"> + <token type="NameFunction"/> + </rule> + </state> + <state name="scenarioSectionsOnStack"> + <rule pattern="^(\s*)(시나리오 개요|시나리오|배경|背景|場景大綱|場景|场景大纲|场景|劇本大綱|劇本|剧本大纲|剧本|テンプレ|シナリオテンプレート|シナリオテンプレ|シナリオアウトライン|シナリオ|سيناريو مخطط|سيناريو|الخلفية|תרחיש|תבנית תרחיש|רקע|Тарих|Сценарій|Сценарио|Сценарий структураси|Сценарий|Структура сценарію|Структура сценарија|Структура сценария|Скица|Рамка на сценарий|Пример|Предыстория|Предистория|Позадина|Передумова|Основа|Концепт|Контекст|Założenia|Wharrimean is|Tình huống|The thing of it is|Tausta|Taust|Tapausaihio|Tapaus|Szenariogrundriss|Szenario|Szablon scenariusza|Stsenaarium|Struktura scenarija|Skica|Skenario konsep|Skenario|Situācija|Senaryo taslağı|Senaryo|Scénář|Scénario|Schema dello scenario|Scenārijs pēc parauga|Scenārijs|Scenár|Scenaro|Scenariusz|Scenariul de şablon|Scenariul de sablon|Scenariu|Scenario Outline|Scenario Amlinellol|Scenario|Scenarijus|Scenarijaus šablonas|Scenarij|Scenarie|Rerefons|Raamstsenaarium|Primer|Pozadí|Pozadina|Pozadie|Plan du scénario|Plan du Scénario|Osnova scénáře|Osnova|Náčrt Scénáře|Náčrt Scenáru|Mate|MISHUN SRSLY|MISHUN|Kịch bản|Konturo de la scenaro|Kontext|Konteksts|Kontekstas|Kontekst|Koncept|Khung tình huống|Khung kịch bản|Háttér|Grundlage|Geçmiş|Forgatókönyv vázlat|Forgatókönyv|Fono|Esquema do Cenário|Esquema do Cenario|Esquema del escenario|Esquema de l'escenari|Escenario|Escenari|Dis is what went down|Dasar|Contexto|Contexte|Contesto|Condiţii|Conditii|Cenário|Cenario|Cefndir|Bối cảnh|Blokes|Bakgrunn|Bakgrund|Baggrund|Background|B4|Antecedents|Antecedentes|All y'all|Achtergrond|Abstrakt Scenario|Abstract Scenario)(:)(.*)$"> + <bygroups> + <token type="NameFunction"/> + <token type="Keyword"/> + <token type="Keyword"/> + <token type="NameFunction"/> + </bygroups> + <push state="featureElementsOnStack"/> + </rule> + </state> + <state name="narrative"> + <rule> + <include state="scenarioSectionsOnStack"/> + </rule> + <rule pattern="(\s|.)"> + <token type="NameFunction"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="NameFunction"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="""""> + <token type="Keyword"/> + <push state="pyString"/> + </rule> + <rule pattern="\s+\|"> + <token type="Keyword"/> + <push state="tableContent"/> + </rule> + <rule pattern="""> + <token type="NameFunction"/> + <push state="doubleString"/> + </rule> + <rule> + <include state="tableVars"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule pattern="(\s*)(@[^@\r\n\t ]+)"> + <bygroups> + <token type="NameFunction"/> + <token type="NameTag"/> + </bygroups> + </rule> + <rule pattern="^(\s*)(하지만|조건|먼저|만일|만약|단|그리고|그러면|那麼|那么|而且|當|当|前提|假設|假设|假如|假定|但是|但し|並且|并且|同時|同时|もし|ならば|ただし|しかし|かつ|و |متى |لكن |عندما |ثم |بفرض |اذاً |כאשר |וגם |בהינתן |אזי |אז |אבל |Якщо |Унда |То |Припустимо, що |Припустимо |Онда |Но |Нехай |Лекин |Когато |Када |Кад |К тому же |И |Задато |Задати |Задате |Если |Допустим |Дадено |Ва |Бирок |Аммо |Али |Але |Агар |А |І |Și |És |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Youse know when youse got |Youse know like when |Yna |Ya know how |Ya gotta |Y |Wun |Wtedy |When y'all |When |Wenn |WEN |Và |Ve |Und |Un |Thì |Then y'all |Then |Tapi |Tak |Tada |Tad |Så |Stel |Soit |Siis |Si |Sed |Se |Quando |Quand |Quan |Pryd |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Når |När |Niin |Nhưng |N |Mutta |Men |Mas |Maka |Majd |Mais |Maar |Ma |Lorsque |Lorsqu'|Kun |Kuid |Kui |Khi |Keď |Ketika |Když |Kaj |Kai |Kada |Kad |Jeżeli |Ja |Ir |I CAN HAZ |I |Ha |Givun |Givet |Given y'all |Given |Gitt |Gegeven |Gegeben sei |Fakat |Eğer ki |Etant donné |Et |Então |Entonces |Entao |En |Eeldades |E |Duota |Dun |Donitaĵo |Donat |Donada |Do |Diyelim ki |Dengan |Den youse gotta |De |Dato |Dar |Dann |Dan |Dado |Dacă |Daca |DEN |Când |Cuando |Cho |Cept |Cand |Cal |But y'all |But |Buh |Biết |Bet |BUT |Atès |Atunci |Atesa |Anrhegedig a |Angenommen |And y'all |And |An |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Aber |AN |A také |A |\* )"> + <bygroups> + <token type="NameFunction"/> + <token type="Keyword"/> + </bygroups> + <push state="stepContentRoot"/> + </rule> + <rule pattern="^(기능|機能|功能|フィーチャ|خاصية|תכונה|Функціонал|Функционалност|Функционал|Фича|Особина|Могућност|Özellik|Właściwość|Tính năng|Trajto|Savybė|Požiadavka|Požadavek|Osobina|Ominaisuus|Omadus|OH HAI|Mogućnost|Mogucnost|Jellemző|Fīča|Funzionalità|Funktionalität|Funkcionalnost|Funkcionalitāte|Funcționalitate|Functionaliteit|Functionalitate|Funcionalitat|Funcionalidade|Fonctionnalité|Fitur|Feature|Egenskap|Egenskab|Crikey|Característica|Arwedd)(:)(.*)$"> + <bygroups> + <token type="Keyword"/> + <token type="Keyword"/> + <token type="NameFunction"/> + </bygroups> + <push state="narrative"/> + </rule> + <rule pattern="^(\s*)(시나리오 개요|시나리오|배경|背景|場景大綱|場景|场景大纲|场景|劇本大綱|劇本|剧本大纲|剧本|テンプレ|シナリオテンプレート|シナリオテンプレ|シナリオアウトライン|シナリオ|سيناريو مخطط|سيناريو|الخلفية|תרחיש|תבנית תרחיש|רקע|Тарих|Сценарій|Сценарио|Сценарий структураси|Сценарий|Структура сценарію|Структура сценарија|Структура сценария|Скица|Рамка на сценарий|Пример|Предыстория|Предистория|Позадина|Передумова|Основа|Концепт|Контекст|Założenia|Wharrimean is|Tình huống|The thing of it is|Tausta|Taust|Tapausaihio|Tapaus|Szenariogrundriss|Szenario|Szablon scenariusza|Stsenaarium|Struktura scenarija|Skica|Skenario konsep|Skenario|Situācija|Senaryo taslağı|Senaryo|Scénář|Scénario|Schema dello scenario|Scenārijs pēc parauga|Scenārijs|Scenár|Scenaro|Scenariusz|Scenariul de şablon|Scenariul de sablon|Scenariu|Scenario Outline|Scenario Amlinellol|Scenario|Scenarijus|Scenarijaus šablonas|Scenarij|Scenarie|Rerefons|Raamstsenaarium|Primer|Pozadí|Pozadina|Pozadie|Plan du scénario|Plan du Scénario|Osnova scénáře|Osnova|Náčrt Scénáře|Náčrt Scenáru|Mate|MISHUN SRSLY|MISHUN|Kịch bản|Konturo de la scenaro|Kontext|Konteksts|Kontekstas|Kontekst|Koncept|Khung tình huống|Khung kịch bản|Háttér|Grundlage|Geçmiş|Forgatókönyv vázlat|Forgatókönyv|Fono|Esquema do Cenário|Esquema do Cenario|Esquema del escenario|Esquema de l'escenari|Escenario|Escenari|Dis is what went down|Dasar|Contexto|Contexte|Contesto|Condiţii|Conditii|Cenário|Cenario|Cefndir|Bối cảnh|Blokes|Bakgrunn|Bakgrund|Baggrund|Background|B4|Antecedents|Antecedentes|All y'all|Achtergrond|Abstrakt Scenario|Abstract Scenario)(:)(.*)$"> + <bygroups> + <token type="NameFunction"/> + <token type="Keyword"/> + <token type="Keyword"/> + <token type="NameFunction"/> + </bygroups> + <push state="featureElements"/> + </rule> + <rule pattern="^(\s*)(예|例子|例|サンプル|امثلة|דוגמאות|Сценарији|Примери|Приклади|Мисоллар|Значения|Örnekler|Voorbeelden|Variantai|Tapaukset|Scenarios|Scenariji|Scenarijai|Příklady|Példák|Príklady|Przykłady|Primjeri|Primeri|Piemēri|Pavyzdžiai|Paraugs|Juhtumid|Exemplos|Exemples|Exemplele|Exempel|Examples|Esempi|Enghreifftiau|Ekzemploj|Eksempler|Ejemplos|EXAMPLZ|Dữ liệu|Contoh|Cobber|Beispiele)(:)(.*)$"> + <bygroups> + <token type="NameFunction"/> + <token type="Keyword"/> + <token type="Keyword"/> + <token type="NameFunction"/> + </bygroups> + <push state="examplesTable"/> + </rule> + <rule pattern="(\s|.)"> + <token type="NameFunction"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/glsl.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/glsl.xml new file mode 100644 index 0000000..ca0b696 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/glsl.xml @@ -0,0 +1,65 @@ +<lexer> + <config> + <name>GLSL</name> + <alias>glsl</alias> + <filename>*.vert</filename> + <filename>*.frag</filename> + <filename>*.geo</filename> + <mime_type>text/x-glslsrc</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="^#.*"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="//.*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/(\\\n)?[*](.|\n)*?[*](\\\n)?/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="\+|-|~|!=?|\*|/|%|<<|>>|<=?|>=?|==?|&&?|\^|\|\|?"> + <token type="Operator"/> + </rule> + <rule pattern="[?:]"> + <token type="Operator"/> + </rule> + <rule pattern="\bdefined\b"> + <token type="Operator"/> + </rule> + <rule pattern="[;{}(),\[\]]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[+-]?\d*\.\d+([eE][-+]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+-]?\d+\.\d*([eE][-+]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F]*"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0[0-7]*"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="[1-9][0-9]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\b(sampler3DsamplerCube|sampler2DShadow|sampler1DShadow|invariant|sampler1D|sampler2D|attribute|mat3mat4|centroid|continue|varying|uniform|discard|mat4x4|mat3x3|mat2x3|mat4x2|mat3x2|mat2x2|mat2x4|mat3x4|struct|return|mat4x3|bvec4|false|ivec4|ivec3|const|float|inout|ivec2|break|while|bvec3|bvec2|vec3|else|true|void|bool|vec2|vec4|mat2|for|out|int|in|do|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(sampler2DRectShadow|sampler2DRect|sampler3DRect|namespace|precision|interface|volatile|template|unsigned|external|noinline|mediump|typedef|default|switch|static|extern|inline|sizeof|output|packed|double|public|fvec3|class|union|short|highp|fixed|input|fvec4|hvec2|hvec3|hvec4|dvec2|dvec3|dvec4|fvec2|using|long|this|enum|lowp|cast|goto|half|asm)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="\."> + <token type="Punctuation"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gnuplot.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gnuplot.xml new file mode 100644 index 0000000..ee6a245 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/gnuplot.xml @@ -0,0 +1,289 @@ +<lexer> + <config> + <name>Gnuplot</name> + <alias>gnuplot</alias> + <filename>*.plot</filename> + <filename>*.plt</filename> + <mime_type>text/x-gnuplot</mime_type> + </config> + <rules> + <state name="whitespace"> + <rule pattern="#"> + <token type="Comment"/> + <push state="comment"/> + </rule> + <rule pattern="[ \t\v\f]+"> + <token type="Text"/> + </rule> + </state> + <state name="save"> + <rule pattern="functions\b|function\b|functio\b|functi\b|funct\b|func\b|fun\b|fu\b|f\b|set\b|se\b|s\b|terminal\b|termina\b|termin\b|termi\b|term\b|ter\b|te\b|t\b|variables\b|variable\b|variabl\b|variab\b|varia\b|vari\b|var\b|va\b|v\b"> + <token type="NameBuiltin"/> + </rule> + <rule> + <include state="genericargs"/> + </rule> + </state> + <state name="pause"> + <rule pattern="(mouse|any|button1|button2|button3)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="keypress\b|keypres\b|keypre\b|keypr\b|keyp\b|key\b"> + <token type="NameBuiltin"/> + </rule> + <rule> + <include state="genericargs"/> + </rule> + </state> + <state name="plot"> + <rule pattern="axes\b|axe\b|ax\b|axis\b|axi\b|binary\b|binar\b|bina\b|bin\b|every\b|ever\b|eve\b|ev\b|index\b|inde\b|ind\b|in\b|i\b|matrix\b|matri\b|matr\b|mat\b|smooth\b|smoot\b|smoo\b|smo\b|sm\b|s\b|thru\b|title\b|titl\b|tit\b|ti\b|t\b|notitle\b|notitl\b|notit\b|noti\b|not\b|using\b|usin\b|usi\b|us\b|u\b|with\b|wit\b|wi\b|w\b"> + <token type="NameBuiltin"/> + </rule> + <rule> + <include state="genericargs"/> + </rule> + </state> + <state name="if"> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="genericargs"/> + </rule> + </state> + <state name="genericargs"> + <rule> + <include state="noargs"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="dqstring"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="sqstring"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[,.~!%^&*+=|?:<>/-]"> + <token type="Operator"/> + </rule> + <rule pattern="[{}()\[\]]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(eq|ne)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="([a-zA-Z_]\w*)(\s*)(\()"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="@[a-zA-Z_]\w*"> + <token type="NameConstant"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + </state> + <state name="comment"> + <rule pattern="[^\\\n]"> + <token type="Comment"/> + </rule> + <rule pattern="\\\n"> + <token type="Comment"/> + </rule> + <rule pattern="\\"> + <token type="Comment"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="bind\b|bin\b|bi\b"> + <token type="Keyword"/> + <push state="bind"/> + </rule> + <rule pattern="exit\b|exi\b|ex\b|quit\b|qui\b|qu\b|q\b"> + <token type="Keyword"/> + <push state="quit"/> + </rule> + <rule pattern="fit\b|fi\b|f\b"> + <token type="Keyword"/> + <push state="fit"/> + </rule> + <rule pattern="(if)(\s*)(\()"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="if"/> + </rule> + <rule pattern="else\b"> + <token type="Keyword"/> + </rule> + <rule pattern="pause\b|paus\b|pau\b|pa\b"> + <token type="Keyword"/> + <push state="pause"/> + </rule> + <rule pattern="plot\b|plo\b|pl\b|p\b|replot\b|replo\b|repl\b|rep\b|splot\b|splo\b|spl\b|sp\b"> + <token type="Keyword"/> + <push state="plot"/> + </rule> + <rule pattern="save\b|sav\b|sa\b"> + <token type="Keyword"/> + <push state="save"/> + </rule> + <rule pattern="set\b|se\b"> + <token type="Keyword"/> + <push state="genericargs" state="optionarg"/> + </rule> + <rule pattern="show\b|sho\b|sh\b|unset\b|unse\b|uns\b"> + <token type="Keyword"/> + <push state="noargs" state="optionarg"/> + </rule> + <rule pattern="lower\b|lowe\b|low\b|raise\b|rais\b|rai\b|ra\b|call\b|cal\b|ca\b|cd\b|clear\b|clea\b|cle\b|cl\b|help\b|hel\b|he\b|h\b|\?\b|history\b|histor\b|histo\b|hist\b|his\b|hi\b|load\b|loa\b|lo\b|l\b|print\b|prin\b|pri\b|pr\b|pwd\b|reread\b|rerea\b|rere\b|rer\b|re\b|reset\b|rese\b|res\b|screendump\b|screendum\b|screendu\b|screend\b|screen\b|scree\b|scre\b|scr\b|shell\b|shel\b|she\b|system\b|syste\b|syst\b|sys\b|sy\b|update\b|updat\b|upda\b|upd\b|up\b"> + <token type="Keyword"/> + <push state="genericargs"/> + </rule> + <rule pattern="pwd\b|reread\b|rerea\b|rere\b|rer\b|re\b|reset\b|rese\b|res\b|screendump\b|screendum\b|screendu\b|screend\b|screen\b|scree\b|scre\b|scr\b|shell\b|shel\b|she\b|test\b"> + <token type="Keyword"/> + <push state="noargs"/> + </rule> + <rule pattern="([a-zA-Z_]\w*)(\s*)(=)"> + <bygroups> + <token type="NameVariable"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + <push state="genericargs"/> + </rule> + <rule pattern="([a-zA-Z_]\w*)(\s*\(.*?\)\s*)(=)"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + <push state="genericargs"/> + </rule> + <rule pattern="@[a-zA-Z_]\w*"> + <token type="NameConstant"/> + </rule> + <rule pattern=";"> + <token type="Keyword"/> + </rule> + </state> + <state name="dqstring"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + <rule pattern="\n"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="optionarg"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="all\b|al\b|a\b|angles\b|angle\b|angl\b|ang\b|an\b|arrow\b|arro\b|arr\b|ar\b|autoscale\b|autoscal\b|autosca\b|autosc\b|autos\b|auto\b|aut\b|au\b|bars\b|bar\b|ba\b|b\b|border\b|borde\b|bord\b|bor\b|boxwidth\b|boxwidt\b|boxwid\b|boxwi\b|boxw\b|box\b|clabel\b|clabe\b|clab\b|cla\b|cl\b|clip\b|cli\b|cl\b|c\b|cntrparam\b|cntrpara\b|cntrpar\b|cntrpa\b|cntrp\b|cntr\b|cnt\b|cn\b|contour\b|contou\b|conto\b|cont\b|con\b|co\b|data\b|dat\b|da\b|datafile\b|datafil\b|datafi\b|dataf\b|data\b|dgrid3d\b|dgrid3\b|dgrid\b|dgri\b|dgr\b|dg\b|dummy\b|dumm\b|dum\b|du\b|encoding\b|encodin\b|encodi\b|encod\b|enco\b|enc\b|decimalsign\b|decimalsig\b|decimalsi\b|decimals\b|decimal\b|decima\b|decim\b|deci\b|dec\b|fit\b|fontpath\b|fontpat\b|fontpa\b|fontp\b|font\b|format\b|forma\b|form\b|for\b|fo\b|function\b|functio\b|functi\b|funct\b|func\b|fun\b|fu\b|functions\b|function\b|functio\b|functi\b|funct\b|func\b|fun\b|fu\b|grid\b|gri\b|gr\b|g\b|hidden3d\b|hidden3\b|hidden\b|hidde\b|hidd\b|hid\b|historysize\b|historysiz\b|historysi\b|historys\b|history\b|histor\b|histo\b|hist\b|his\b|isosamples\b|isosample\b|isosampl\b|isosamp\b|isosam\b|isosa\b|isos\b|iso\b|is\b|key\b|ke\b|k\b|keytitle\b|keytitl\b|keytit\b|keyti\b|keyt\b|label\b|labe\b|lab\b|la\b|linestyle\b|linestyl\b|linesty\b|linest\b|lines\b|line\b|lin\b|li\b|ls\b|loadpath\b|loadpat\b|loadpa\b|loadp\b|load\b|loa\b|locale\b|local\b|loca\b|loc\b|logscale\b|logscal\b|logsca\b|logsc\b|logs\b|log\b|macros\b|macro\b|macr\b|mac\b|mapping\b|mappin\b|mappi\b|mapp\b|map\b|mapping3d\b|mapping3\b|mapping\b|mappin\b|mappi\b|mapp\b|map\b|margin\b|margi\b|marg\b|mar\b|lmargin\b|lmargi\b|lmarg\b|lmar\b|rmargin\b|rmargi\b|rmarg\b|rmar\b|tmargin\b|tmargi\b|tmarg\b|tmar\b|bmargin\b|bmargi\b|bmarg\b|bmar\b|mouse\b|mous\b|mou\b|mo\b|multiplot\b|multiplo\b|multipl\b|multip\b|multi\b|mxtics\b|mxtic\b|mxti\b|mxt\b|nomxtics\b|nomxtic\b|nomxti\b|nomxt\b|mx2tics\b|mx2tic\b|mx2ti\b|mx2t\b|nomx2tics\b|nomx2tic\b|nomx2ti\b|nomx2t\b|mytics\b|mytic\b|myti\b|myt\b|nomytics\b|nomytic\b|nomyti\b|nomyt\b|my2tics\b|my2tic\b|my2ti\b|my2t\b|nomy2tics\b|nomy2tic\b|nomy2ti\b|nomy2t\b|mztics\b|mztic\b|mzti\b|mzt\b|nomztics\b|nomztic\b|nomzti\b|nomzt\b|mcbtics\b|mcbtic\b|mcbti\b|mcbt\b|nomcbtics\b|nomcbtic\b|nomcbti\b|nomcbt\b|offsets\b|offset\b|offse\b|offs\b|off\b|of\b|origin\b|origi\b|orig\b|ori\b|or\b|output\b|outpu\b|outp\b|out\b|ou\b|o\b|parametric\b|parametri\b|parametr\b|paramet\b|parame\b|param\b|para\b|par\b|pa\b|pm3d\b|pm3\b|pm\b|palette\b|palett\b|palet\b|pale\b|pal\b|colorbox\b|colorbo\b|colorb\b|plot\b|plo\b|pl\b|p\b|pointsize\b|pointsiz\b|pointsi\b|points\b|point\b|poin\b|poi\b|polar\b|pola\b|pol\b|print\b|prin\b|pri\b|pr\b|object\b|objec\b|obje\b|obj\b|samples\b|sample\b|sampl\b|samp\b|sam\b|sa\b|size\b|siz\b|si\b|style\b|styl\b|sty\b|st\b|surface\b|surfac\b|surfa\b|surf\b|sur\b|su\b|table\b|terminal\b|termina\b|termin\b|termi\b|term\b|ter\b|te\b|t\b|termoptions\b|termoption\b|termoptio\b|termopti\b|termopt\b|termop\b|termo\b|tics\b|tic\b|ti\b|ticscale\b|ticscal\b|ticsca\b|ticsc\b|ticslevel\b|ticsleve\b|ticslev\b|ticsle\b|ticsl\b|timefmt\b|timefm\b|timef\b|timestamp\b|timestam\b|timesta\b|timest\b|times\b|time\b|tim\b|title\b|titl\b|tit\b|variables\b|variable\b|variabl\b|variab\b|varia\b|vari\b|var\b|va\b|v\b|version\b|versio\b|versi\b|vers\b|ver\b|ve\b|view\b|vie\b|vi\b|xyplane\b|xyplan\b|xypla\b|xypl\b|xyp\b|xdata\b|xdat\b|xda\b|x2data\b|x2dat\b|x2da\b|ydata\b|ydat\b|yda\b|y2data\b|y2dat\b|y2da\b|zdata\b|zdat\b|zda\b|cbdata\b|cbdat\b|cbda\b|xlabel\b|xlabe\b|xlab\b|xla\b|xl\b|x2label\b|x2labe\b|x2lab\b|x2la\b|x2l\b|ylabel\b|ylabe\b|ylab\b|yla\b|yl\b|y2label\b|y2labe\b|y2lab\b|y2la\b|y2l\b|zlabel\b|zlabe\b|zlab\b|zla\b|zl\b|cblabel\b|cblabe\b|cblab\b|cbla\b|cbl\b|xtics\b|xtic\b|xti\b|noxtics\b|noxtic\b|noxti\b|x2tics\b|x2tic\b|x2ti\b|nox2tics\b|nox2tic\b|nox2ti\b|ytics\b|ytic\b|yti\b|noytics\b|noytic\b|noyti\b|y2tics\b|y2tic\b|y2ti\b|noy2tics\b|noy2tic\b|noy2ti\b|ztics\b|ztic\b|zti\b|noztics\b|noztic\b|nozti\b|cbtics\b|cbtic\b|cbti\b|nocbtics\b|nocbtic\b|nocbti\b|xdtics\b|xdtic\b|xdti\b|noxdtics\b|noxdtic\b|noxdti\b|x2dtics\b|x2dtic\b|x2dti\b|nox2dtics\b|nox2dtic\b|nox2dti\b|ydtics\b|ydtic\b|ydti\b|noydtics\b|noydtic\b|noydti\b|y2dtics\b|y2dtic\b|y2dti\b|noy2dtics\b|noy2dtic\b|noy2dti\b|zdtics\b|zdtic\b|zdti\b|nozdtics\b|nozdtic\b|nozdti\b|cbdtics\b|cbdtic\b|cbdti\b|nocbdtics\b|nocbdtic\b|nocbdti\b|xmtics\b|xmtic\b|xmti\b|noxmtics\b|noxmtic\b|noxmti\b|x2mtics\b|x2mtic\b|x2mti\b|nox2mtics\b|nox2mtic\b|nox2mti\b|ymtics\b|ymtic\b|ymti\b|noymtics\b|noymtic\b|noymti\b|y2mtics\b|y2mtic\b|y2mti\b|noy2mtics\b|noy2mtic\b|noy2mti\b|zmtics\b|zmtic\b|zmti\b|nozmtics\b|nozmtic\b|nozmti\b|cbmtics\b|cbmtic\b|cbmti\b|nocbmtics\b|nocbmtic\b|nocbmti\b|xrange\b|xrang\b|xran\b|xra\b|xr\b|x2range\b|x2rang\b|x2ran\b|x2ra\b|x2r\b|yrange\b|yrang\b|yran\b|yra\b|yr\b|y2range\b|y2rang\b|y2ran\b|y2ra\b|y2r\b|zrange\b|zrang\b|zran\b|zra\b|zr\b|cbrange\b|cbrang\b|cbran\b|cbra\b|cbr\b|rrange\b|rrang\b|rran\b|rra\b|rr\b|trange\b|trang\b|tran\b|tra\b|tr\b|urange\b|urang\b|uran\b|ura\b|ur\b|vrange\b|vrang\b|vran\b|vra\b|vr\b|xzeroaxis\b|xzeroaxi\b|xzeroax\b|xzeroa\b|x2zeroaxis\b|x2zeroaxi\b|x2zeroax\b|x2zeroa\b|yzeroaxis\b|yzeroaxi\b|yzeroax\b|yzeroa\b|y2zeroaxis\b|y2zeroaxi\b|y2zeroax\b|y2zeroa\b|zzeroaxis\b|zzeroaxi\b|zzeroax\b|zzeroa\b|zeroaxis\b|zeroaxi\b|zeroax\b|zeroa\b|zero\b|zer\b|ze\b|z\b"> + <token type="NameBuiltin"/> + <pop depth="1"/> + </rule> + </state> + <state name="bind"> + <rule pattern="!"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule pattern="allwindows\b|allwindow\b|allwindo\b|allwind\b|allwin\b|allwi\b|allw\b|all\b"> + <token type="NameBuiltin"/> + </rule> + <rule> + <include state="genericargs"/> + </rule> + </state> + <state name="fit"> + <rule pattern="via\b"> + <token type="NameBuiltin"/> + </rule> + <rule> + <include state="plot"/> + </rule> + </state> + <state name="noargs"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="sqstring"> + <rule pattern="''"> + <token type="LiteralString"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\\'\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + <rule pattern="\n"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="quit"> + <rule pattern="gnuplot\b"> + <token type="Keyword"/> + </rule> + <rule> + <include state="noargs"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/go_template.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/go_template.xml new file mode 100644 index 0000000..a293330 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/go_template.xml @@ -0,0 +1,112 @@ +<lexer> + <config> + <name>Go HTML Template</name> + <alias>go-html-template</alias> + </config> + <rules> + <state name="template"> + <rule pattern="[-]?}}"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="(?=}})"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="\("> + <token type="Operator"/> + <push state="subexpression"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule> + <include state="expression"/> + </rule> + </state> + <state name="subexpression"> + <rule pattern="\)"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule> + <include state="expression"/> + </rule> + </state> + <state name="expression"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="\("> + <token type="Operator"/> + <push state="subexpression"/> + </rule> + <rule pattern="(range|if|else|while|with|template|end|true|false|nil|and|call|html|index|js|len|not|or|print|printf|println|urlquery|eq|ne|lt|le|gt|ge)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\||:?=|,"> + <token type="Operator"/> + </rule> + <rule pattern="[$]?[^\W\d]\w*"> + <token type="NameOther"/> + </rule> + <rule pattern="\$|[$]?\.(?:[^\W\d]\w*)?"> + <token type="NameAttribute"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </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][+\-]?\d+|\.\d*|[eE][+\-]?\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?\.\d+([eE][+\-]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?0[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="-?0[xX][0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="-?0b[01_]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="-?(0|[1-9][0-9]*)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="`[^`]*`"> + <token type="LiteralString"/> + </rule> + </state> + <state name="root"> + <rule pattern="{{(- )?/\*(.|\n)*?\*/( -)?}}"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="{{[-]?"> + <token type="CommentPreproc"/> + <push state="template"/> + </rule> + <rule pattern="[^{]+"> + <token type="Other"/> + </rule> + <rule pattern="{"> + <token type="Other"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/graphql.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/graphql.xml new file mode 100644 index 0000000..b062273 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/graphql.xml @@ -0,0 +1,88 @@ +<lexer> + <config> + <name>GraphQL</name> + <alias>graphql</alias> + <alias>graphqls</alias> + <alias>gql</alias> + <filename>*.graphql</filename> + <filename>*.graphqls</filename> + </config> + <rules> + <state name="root"> + <rule pattern="(query|mutation|subscription|fragment|scalar|implements|interface|union|enum|input|type)"> + <token type="KeywordDeclaration"/> + <push state="type"/> + </rule> + <rule pattern="(on|extend|schema|directive|\.\.\.)"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(QUERY|MUTATION|SUBSCRIPTION|FIELD|FRAGMENT_DEFINITION|FRAGMENT_SPREAD|INLINE_FRAGMENT|SCHEMA|SCALAR|OBJECT|FIELD_DEFINITION|ARGUMENT_DEFINITION|INTERFACE|UNION|ENUM|ENUM_VALUE|INPUT_OBJECT|INPUT_FIELD_DEFINITION)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="[^\W\d]\w*"> + <token type="NameProperty"/> + </rule> + <rule pattern="\@\w+"> + <token type="NameDecorator"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + <push state="type"/> + </rule> + <rule pattern="[\(\)\{\}\[\],!\|=]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\$\w+"> + <token type="NameVariable"/> + </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][+\-]?\d+|\.\d*|[eE][+\-]?\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\.\d+([eE][+\-]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(0|[1-9][0-9]*)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern=""""[\x00-\x7F]*?""""> + <token type="LiteralString"/> + </rule> + <rule pattern=""(\\["\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])""> + <token type="LiteralStringChar"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern=""(true|false|null)*""> + <token type="Literal"/> + </rule> + <rule pattern="[\r\n\s]+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="#[^\r\n]*"> + <token type="Comment"/> + </rule> + </state> + <state name="type"> + <rule pattern="[^\W\d]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/groff.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/groff.xml new file mode 100644 index 0000000..3af0a43 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/groff.xml @@ -0,0 +1,90 @@ +<lexer> + <config> + <name>Groff</name> + <alias>groff</alias> + <alias>nroff</alias> + <alias>man</alias> + <filename>*.[1-9]</filename> + <filename>*.1p</filename> + <filename>*.3pm</filename> + <filename>*.man</filename> + <mime_type>application/x-troff</mime_type> + <mime_type>text/troff</mime_type> + </config> + <rules> + <state name="request"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="escapes"/> + </rule> + <rule pattern=""[^\n"]+""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="\S+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + <state name="root"> + <rule pattern="(\.)(\w+)"> + <bygroups> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + <push state="request"/> + </rule> + <rule pattern="\."> + <token type="Punctuation"/> + <push state="request"/> + </rule> + <rule pattern="[^\\\n]+"> + <token type="Text"/> + <push state="textline"/> + </rule> + <rule> + <push state="textline"/> + </rule> + </state> + <state name="textline"> + <rule> + <include state="escapes"/> + </rule> + <rule pattern="[^\\\n]+"> + <token type="Text"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="escapes"> + <rule pattern="\\"[^\n]*"> + <token type="Comment"/> + </rule> + <rule pattern="\\[fn]\w"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\\(.{2}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\.\[.*\]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\."> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + <push state="request"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/groovy.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/groovy.xml new file mode 100644 index 0000000..0dd7b82 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/groovy.xml @@ -0,0 +1,135 @@ +<lexer> + <config> + <name>Groovy</name> + <alias>groovy</alias> + <filename>*.groovy</filename> + <filename>*.gradle</filename> + <mime_type>text/x-groovy</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="root"> + <rule pattern="#!(.*?)$"> + <token type="CommentPreproc"/> + <push state="base"/> + </rule> + <rule> + <push state="base"/> + </rule> + </state> + <state name="base"> + <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"/> + </rule> + <rule pattern="@[a-zA-Z_][\w.]*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="(as|assert|break|case|catch|continue|default|do|else|finally|for|if|in|goto|instanceof|new|return|switch|this|throw|try|while|in|as)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(abstract|const|enum|extends|final|implements|native|private|protected|public|static|strictfp|super|synchronized|throws|transient|volatile)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(def|boolean|byte|char|double|float|int|long|short|void)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(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)(\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="""".*?""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'''.*?'''"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="\$/((?!/\$).)*/\$"> + <token type="LiteralString"/> + </rule> + <rule pattern="/(\\\\|\\"|[^/])*/"> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="(\.)([a-zA-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="[~^*!%&\[\](){}<>|+=:;,./?-]"> + <token type="Operator"/> + </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]+L?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + </state> + <state name="class"> + <rule pattern="[a-zA-Z_]\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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/handlebars.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/handlebars.xml new file mode 100644 index 0000000..7cf2a64 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/handlebars.xml @@ -0,0 +1,147 @@ +<lexer> + <config> + <name>Handlebars</name> + <alias>handlebars</alias> + <alias>hbs</alias> + <filename>*.handlebars</filename> + <filename>*.hbs</filename> + </config> + <rules> + <state name="root"> + <rule pattern="[^{]+"> + <token type="Other"/> + </rule> + <rule pattern="\{\{!.*\}\}"> + <token type="Comment"/> + </rule> + <rule pattern="(\{\{\{)(\s*)"> + <bygroups> + <token type="CommentSpecial"/> + <token type="Text"/> + </bygroups> + <push state="tag"/> + </rule> + <rule pattern="(\{\{)(\s*)"> + <bygroups> + <token type="CommentPreproc"/> + <token type="Text"/> + </bygroups> + <push state="tag"/> + </rule> + </state> + <state name="tag"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\}\}\}"> + <token type="CommentSpecial"/> + <pop depth="1"/> + </rule> + <rule pattern="\}\}"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="([#/]*)(each|if|unless|else|with|log|in(?:line)?)"> + <bygroups> + <token type="Keyword"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="#\*inline"> + <token type="Keyword"/> + </rule> + <rule pattern="([#/])([\w-]+)"> + <bygroups> + <token type="NameFunction"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="([\w-]+)(=)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="(>)(\s*)(@partial-block)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(#?>)(\s*)([\w-]+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="(>)(\s*)(\()"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="dynamic-partial"/> + </rule> + <rule> + <include state="generic"/> + </rule> + </state> + <state name="dynamic-partial"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="(lookup)(\s+)(\.|this)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameVariable"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(lookup)(\s+)(\S+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <usingself state="variable"/> + </bygroups> + </rule> + <rule pattern="[\w-]+"> + <token type="NameFunction"/> + </rule> + <rule> + <include state="generic"/> + </rule> + </state> + <state name="variable"> + <rule pattern="[a-zA-Z][\w-]*"> + <token type="NameVariable"/> + </rule> + <rule pattern="\.[\w-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(this\/|\.\/|(\.\.\/)+)[\w-]+"> + <token type="NameVariable"/> + </rule> + </state> + <state name="generic"> + <rule> + <include state="variable"/> + </rule> + <rule pattern=":?"(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=":?'(\\\\|\\'|[^'])*'"> + <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> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/haskell.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/haskell.xml new file mode 100644 index 0000000..6dc6912 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/haskell.xml @@ -0,0 +1,272 @@ +<lexer> + <config> + <name>Haskell</name> + <alias>haskell</alias> + <alias>hs</alias> + <filename>*.hs</filename> + <mime_type>text/x-haskell</mime_type> + </config> + <rules> + <state name="escape"> + <rule pattern="[abfnrtv"\'&\\]"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="\^[][\p{Lu}@^_]"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="NUL|SOH|[SE]TX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|S[OI]|DLE|DC[1-4]|NAK|SYN|ETB|CAN|EM|SUB|ESC|[FGRU]S|SP|DEL"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="o[0-7]+"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="x[\da-fA-F]+"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="\s+\\"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="--(?![!#$%&*+./<=>?@^|_~:\\]).*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\{-"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\bimport\b"> + <token type="KeywordReserved"/> + <push state="import"/> + </rule> + <rule pattern="\bmodule\b"> + <token type="KeywordReserved"/> + <push state="module"/> + </rule> + <rule pattern="\berror\b"> + <token type="NameException"/> + </rule> + <rule pattern="\b(case|class|data|default|deriving|do|else|family|if|in|infix[lr]?|instance|let|newtype|of|then|type|where|_)(?!\')\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="'[^\\]'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="^[_\p{Ll}][\w\']*"> + <token type="NameFunction"/> + </rule> + <rule pattern="'?[_\p{Ll}][\w']*"> + <token type="Name"/> + </rule> + <rule pattern="('')?[\p{Lu}][\w\']*"> + <token type="KeywordType"/> + </rule> + <rule pattern="(')[\p{Lu}][\w\']*"> + <token type="KeywordType"/> + </rule> + <rule pattern="(')\[[^\]]*\]"> + <token type="KeywordType"/> + </rule> + <rule pattern="(')\([^)]*\)"> + <token type="KeywordType"/> + </rule> + <rule pattern="\\(?![:!#$%&*+.\\/<=>?@^|~-]+)"> + <token type="NameFunction"/> + </rule> + <rule pattern="(<-|::|->|=>|=)(?![:!#$%&*+.\\/<=>?@^|~-]+)"> + <token type="OperatorWord"/> + </rule> + <rule pattern=":[:!#$%&*+.\\/<=>?@^|~-]*"> + <token type="KeywordType"/> + </rule> + <rule pattern="[:!#$%&*+.\\/<=>?@^|~-]+"> + <token type="Operator"/> + </rule> + <rule pattern="\d+[eE][+-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+\.\d+([eE][+-]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[oO][0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[xX][\da-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringChar"/> + <push state="character"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="\[\]"> + <token type="KeywordType"/> + </rule> + <rule pattern="\(\)"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[][(),;`{}]"> + <token type="Punctuation"/> + </rule> + </state> + <state name="import"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="qualified\b"> + <token type="Keyword"/> + </rule> + <rule pattern="([\p{Lu}][\w.]*)(\s+)(as)(\s+)([\p{Lu}][\w.]*)"> + <bygroups> + <token type="NameNamespace"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="Name"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="([\p{Lu}][\w.]*)(\s+)(hiding)(\s+)(\()"> + <bygroups> + <token type="NameNamespace"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="funclist"/> + </rule> + <rule pattern="([\p{Lu}][\w.]*)(\s+)(\()"> + <bygroups> + <token type="NameNamespace"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="funclist"/> + </rule> + <rule pattern="[\w.]+"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + </state> + <state name="module"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="([\p{Lu}][\w.]*)(\s+)(\()"> + <bygroups> + <token type="NameNamespace"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="funclist"/> + </rule> + <rule pattern="[\p{Lu}][\w.]*"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + </state> + <state name="funclist"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[\p{Lu}]\w*"> + <token type="KeywordType"/> + </rule> + <rule pattern="(_[\w\']+|[\p{Ll}][\w\']*)"> + <token type="NameFunction"/> + </rule> + <rule pattern="--(?![!#$%&*+./<=>?@^|_~:\\]).*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\{-"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="[:!#$%&*+.\\/<=>?@^|~-]+"> + <token type="Operator"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="funclist" state="funclist"/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="2"/> + </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="character"> + <rule pattern="[^\\']'"> + <token type="LiteralStringChar"/> + <pop depth="1"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringEscape"/> + <push state="escape"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringChar"/> + <pop depth="1"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^\\"]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringEscape"/> + <push state="escape"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hcl.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hcl.xml new file mode 100644 index 0000000..d3ed208 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hcl.xml @@ -0,0 +1,143 @@ +<lexer> + <config> + <name>HCL</name> + <alias>hcl</alias> + <filename>*.hcl</filename> + <mime_type>application/x-hcl</mime_type> + </config> + <rules> + <state name="punctuation"> + <rule pattern="[\[\](),.]"> + <token type="Punctuation"/> + </rule> + </state> + <state name="string"> + <rule pattern="(".*")"> + <bygroups> + <token type="LiteralStringDouble"/> + </bygroups> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="string"/> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule> + <include state="curly"/> + </rule> + <rule> + <include state="basic"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumber"/> + </rule> + </state> + <state name="basic"> + <rule pattern="\b(false|true)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="\s*/\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\s*#.*\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(.*?)(\s*)(=)"> + <bygroups> + <token type="Name"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="\b\w+\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="var_builtin"/> + </rule> + </state> + <state name="curly"> + <rule pattern="\{"> + <token type="TextPunctuation"/> + </rule> + <rule pattern="\}"> + <token type="TextPunctuation"/> + </rule> + </state> + <state name="function"> + <rule pattern="(\s+)(".*")(\s+)"> + <bygroups> + <token type="Text"/> + <token type="LiteralString"/> + <token type="Text"/> + </bygroups> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule> + <include state="curly"/> + </rule> + </state> + <state name="var_builtin"> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push/> + </rule> + <rule pattern="\b(element|concat|lookup|file|join)\b"> + <token type="NameBuiltin"/> + </rule> + <rule> + <include state="string"/> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <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> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hexdump.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hexdump.xml new file mode 100644 index 0000000..a6f28ea --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hexdump.xml @@ -0,0 +1,189 @@ +<lexer> + <config> + <name>Hexdump</name> + <alias>hexdump</alias> + </config> + <rules> + <state name="offset"> + <rule pattern="^([0-9A-Ha-h]+)(:)"> + <bygroups> + <token type="NameLabel"/> + <token type="Punctuation"/> + </bygroups> + <push state="offset-mode"/> + </rule> + <rule pattern="^[0-9A-Ha-h]+"> + <token type="NameLabel"/> + </rule> + </state> + <state name="offset-mode"> + <rule pattern="\s"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern="[0-9A-Ha-h]+"> + <token type="NameLabel"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + </rule> + </state> + <state name="piped-strings"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule> + <include state="offset"/> + </rule> + <rule pattern="[0-9A-Ha-h]{2}"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(\s{2,3})(\|)(.{1,16})(\|)$"> + <bygroups> + <token type="Text"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="\s"> + <token type="Text"/> + </rule> + <rule pattern="^\*"> + <token type="Punctuation"/> + </rule> + </state> + <state name="bracket-strings"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule> + <include state="offset"/> + </rule> + <rule pattern="[0-9A-Ha-h]{2}"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(\s{2,3})(\>)(.{1,16})(\<)$"> + <bygroups> + <token type="Text"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="\s"> + <token type="Text"/> + </rule> + <rule pattern="^\*"> + <token type="Punctuation"/> + </rule> + </state> + <state name="nonpiped-strings"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule> + <include state="offset"/> + </rule> + <rule pattern="([0-9A-Ha-h]{2})(\-)([0-9A-Ha-h]{2})"> + <bygroups> + <token type="LiteralNumberHex"/> + <token type="Punctuation"/> + <token type="LiteralNumberHex"/> + </bygroups> + </rule> + <rule pattern="[0-9A-Ha-h]{2}"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(\s{19,})(.{1,20}?)$"> + <bygroups> + <token type="Text"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(\s{2,3})(.{1,20})$"> + <bygroups> + <token type="Text"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="\s"> + <token type="Text"/> + </rule> + <rule pattern="^\*"> + <token type="Punctuation"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule> + <include state="offset"/> + </rule> + <rule pattern="([0-9A-Ha-h]{2})(\-)([0-9A-Ha-h]{2})"> + <bygroups> + <token type="LiteralNumberHex"/> + <token type="Punctuation"/> + <token type="LiteralNumberHex"/> + </bygroups> + </rule> + <rule pattern="[0-9A-Ha-h]{2}"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(\s{2,3})(\>)(.{16})(\<)$"> + <bygroups> + <token type="Text"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + <push state="bracket-strings"/> + </rule> + <rule pattern="(\s{2,3})(\|)(.{16})(\|)$"> + <bygroups> + <token type="Text"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + <push state="piped-strings"/> + </rule> + <rule pattern="(\s{2,3})(\>)(.{1,15})(\<)$"> + <bygroups> + <token type="Text"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(\s{2,3})(\|)(.{1,15})(\|)$"> + <bygroups> + <token type="Text"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(\s{2,3})(.{1,15})$"> + <bygroups> + <token type="Text"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(\s{2,3})(.{16}|.{20})$"> + <bygroups> + <token type="Text"/> + <token type="LiteralString"/> + </bygroups> + <push state="nonpiped-strings"/> + </rule> + <rule pattern="\s"> + <token type="Text"/> + </rule> + <rule pattern="^\*"> + <token type="Punctuation"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hlb.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hlb.xml new file mode 100644 index 0000000..64e667d --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hlb.xml @@ -0,0 +1,149 @@ +<lexer> + <config> + <name>HLB</name> + <alias>hlb</alias> + <filename>*.hlb</filename> + </config> + <rules> + <state name="root"> + <rule pattern="(#.*)"> + <bygroups> + <token type="CommentSingle"/> + </bygroups> + </rule> + <rule pattern="((\b(0(b|B|o|O|x|X)[a-fA-F0-9]+)\b)|(\b(0|[1-9][0-9]*)\b))"> + <bygroups> + <token type="LiteralNumber"/> + </bygroups> + </rule> + <rule pattern="((\b(true|false)\b))"> + <bygroups> + <token type="NameBuiltin"/> + </bygroups> + </rule> + <rule pattern="(\bstring\b|\bint\b|\bbool\b|\bfs\b|\boption\b)"> + <bygroups> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="(\b[a-zA-Z_][a-zA-Z0-9]*\b)(\()"> + <bygroups> + <token type="NameFunction"/> + <token type="Punctuation"/> + </bygroups> + <push state="params"/> + </rule> + <rule pattern="(\{)"> + <bygroups> + <token type="Punctuation"/> + </bygroups> + <push state="block"/> + </rule> + <rule pattern="(\n|\r|\r\n)"> + <token type="Text"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\""> + <token type="LiteralString"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralString"/> + </rule> + </state> + <state name="block"> + <rule pattern="(\})"> + <bygroups> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(#.*)"> + <bygroups> + <token type="CommentSingle"/> + </bygroups> + </rule> + <rule pattern="((\b(0(b|B|o|O|x|X)[a-fA-F0-9]+)\b)|(\b(0|[1-9][0-9]*)\b))"> + <bygroups> + <token type="LiteralNumber"/> + </bygroups> + </rule> + <rule pattern="((\b(true|false)\b))"> + <bygroups> + <token type="KeywordConstant"/> + </bygroups> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="(with)"> + <bygroups> + <token type="KeywordReserved"/> + </bygroups> + </rule> + <rule pattern="(as)([\t ]+)(\b[a-zA-Z_][a-zA-Z0-9]*\b)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="(\bstring\b|\bint\b|\bbool\b|\bfs\b|\boption\b)([\t ]+)(\{)"> + <bygroups> + <token type="KeywordType"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="block"/> + </rule> + <rule pattern="(?!\b(?:scratch|image|resolve|http|checksum|chmod|filename|git|keepGitDir|local|includePatterns|excludePatterns|followPaths|generate|frontendInput|shell|run|readonlyRootfs|env|dir|user|network|security|host|ssh|secret|mount|target|localPath|uid|gid|mode|readonly|tmpfs|sourcePath|cache|mkdir|createParents|chown|createdTime|mkfile|rm|allowNotFound|allowWildcards|copy|followSymlinks|contentsOnly|unpack|createDestPath)\b)(\b[a-zA-Z_][a-zA-Z0-9]*\b)"> + <bygroups> + <token type="NameOther"/> + </bygroups> + </rule> + <rule pattern="(\n|\r|\r\n)"> + <token type="Text"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="params"> + <rule pattern="(\))"> + <bygroups> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(variadic)"> + <bygroups> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(\bstring\b|\bint\b|\bbool\b|\bfs\b|\boption\b)"> + <bygroups> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="(\b[a-zA-Z_][a-zA-Z0-9]*\b)"> + <bygroups> + <token type="NameOther"/> + </bygroups> + </rule> + <rule pattern="(\n|\r|\r\n)"> + <token type="Text"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hy.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hy.xml new file mode 100644 index 0000000..a0dae46 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/hy.xml @@ -0,0 +1,104 @@ +<lexer> + <config> + <name>Hy</name> + <alias>hylang</alias> + <filename>*.hy</filename> + <mime_type>text/x-hy</mime_type> + <mime_type>application/x-hy</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="0[0-7]+j?"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[xX][a-fA-F0-9]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="\\(.|[a-z]+)"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="^(\s*)([rRuU]{,2}"""(?:.|\n)*?""")"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="^(\s*)([rRuU]{,2}'''(?:.|\n)*?''')"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="::?(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="~@|[`\'#^~&@]"> + <token type="Operator"/> + </rule> + <rule> + <include state="py-keywords"/> + </rule> + <rule> + <include state="py-builtins"/> + </rule> + <rule pattern="(eval-when-compile|eval-and-compile|with-decorator|unquote-splice|quasiquote|list_comp|unquote|foreach|kwapply|import|not-in|unless|is-not|quote|progn|slice|assoc|first|while|when|rest|cond|<<=|->>|for|get|>>=|let|cdr|car|is|->|do|in|\||~|,) "> + <token type="Keyword"/> + </rule> + <rule pattern="(defmacro|defclass|lambda|defun|defn|setv|def|fn) "> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(repeatedly|take_while|iterator\?|iterable\?|instance\?|distinct|take_nth|numeric\?|iterate|filter|repeat|remove|even\?|none\?|cycle|zero\?|odd\?|pos\?|neg\?|take|drop|inc|dec|nth) "> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<=\()(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="NameFunction"/> + </rule> + <rule pattern="(?!#)[\w!$%*+<=>?/.#-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(\[|\])"> + <token type="Punctuation"/> + </rule> + <rule pattern="(\{|\})"> + <token type="Punctuation"/> + </rule> + <rule pattern="(\(|\))"> + <token type="Punctuation"/> + </rule> + </state> + <state name="py-keywords"> + <rule pattern="(yield from|continue|finally|lambda|assert|global|except|return|print|yield|while|break|raise|elif|pass|exec|else|with|try|for|del|as|if)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="py-builtins"> + <rule pattern="(?<!\.)(staticmethod|classmethod|__import__|isinstance|basestring|issubclass|frozenset|raw_input|bytearray|enumerate|property|callable|reversed|execfile|hasattr|setattr|compile|complex|delattr|unicode|globals|getattr|unichr|reduce|xrange|buffer|intern|filter|locals|divmod|coerce|sorted|reload|object|slice|round|float|super|input|bytes|apply|tuple|range|iter|dict|long|type|hash|vars|next|file|exit|open|repr|eval|bool|list|bin|pow|zip|ord|oct|min|set|any|max|map|all|len|sum|int|dir|hex|chr|abs|cmp|str|id)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<!\.)(self|None|Ellipsis|NotImplemented|False|True|cls)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(?<!\.)(PendingDeprecationWarning|UnicodeTranslateError|NotImplementedError|UnicodeEncodeError|UnicodeDecodeError|DeprecationWarning|FloatingPointError|UnboundLocalError|KeyboardInterrupt|ZeroDivisionError|EnvironmentError|IndentationError|ArithmeticError|OverflowWarning|ReferenceError|RuntimeWarning|AttributeError|AssertionError|NotImplemented|UnicodeWarning|FutureWarning|BaseException|StopIteration|SyntaxWarning|OverflowError|StandardError|ImportWarning|GeneratorExit|RuntimeError|WindowsError|UnicodeError|LookupError|SyntaxError|SystemError|ImportError|MemoryError|UserWarning|ValueError|IndexError|SystemExit|Exception|TypeError|NameError|EOFError|VMSError|KeyError|TabError|IOError|OSError|Warning)\b"> + <token type="NameException"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/idris.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/idris.xml new file mode 100644 index 0000000..9592d88 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/idris.xml @@ -0,0 +1,216 @@ +<lexer> + <config> + <name>Idris</name> + <alias>idris</alias> + <alias>idr</alias> + <filename>*.idr</filename> + <mime_type>text/x-idris</mime_type> + </config> + <rules> + <state name="escape"> + <rule pattern="[abfnrtv"\'&\\]"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="\^[][A-Z@^_]"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="NUL|SOH|[SE]TX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|S[OI]|DLE|DC[1-4]|NAK|SYN|ETB|CAN|EM|SUB|ESC|[FGRU]S|SP|DEL"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="o[0-7]+"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="x[\da-fA-F]+"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="\s+\\"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="^(\s*)(%lib|link|flag|include|hide|freeze|access|default|logging|dynamic|name|error_handlers|language)"> + <bygroups> + <token type="Text"/> + <token type="KeywordReserved"/> + </bygroups> + </rule> + <rule pattern="(\s*)(--(?![!#$%&*+./<=>?@^|_~:\\]).*?)$"> + <bygroups> + <token type="Text"/> + <token type="CommentSingle"/> + </bygroups> + </rule> + <rule pattern="(\s*)(\|{3}.*?)$"> + <bygroups> + <token type="Text"/> + <token type="CommentSingle"/> + </bygroups> + </rule> + <rule pattern="(\s*)(\{-)"> + <bygroups> + <token type="Text"/> + <token type="CommentMultiline"/> + </bygroups> + <push state="comment"/> + </rule> + <rule pattern="^(\s*)([^\s(){}]+)(\s*)(:)(\s*)"> + <bygroups> + <token type="Text"/> + <token type="NameFunction"/> + <token type="Text"/> + <token type="OperatorWord"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="\b(case|class|data|default|using|do|else|if|in|infix[lr]?|instance|rewrite|auto|namespace|codata|mutual|private|public|abstract|total|partial|let|proof|of|then|static|where|_|with|pattern|term|syntax|prefix|postulate|parameters|record|dsl|impossible|implicit|tactics|intros|intro|compute|refine|exact|trivial)(?!\')\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(import|module)(\s+)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="Text"/> + </bygroups> + <push state="module"/> + </rule> + <rule pattern="('')?[A-Z][\w\']*"> + <token type="KeywordType"/> + </rule> + <rule pattern="[a-z][\w\']*"> + <token type="Text"/> + </rule> + <rule pattern="(<-|::|->|=>|=)"> + <token type="OperatorWord"/> + </rule> + <rule pattern="([(){}\[\]:!#$%&*+.\\/<=>?@^|~-]+)"> + <token type="OperatorWord"/> + </rule> + <rule pattern="\d+[eE][+-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+\.\d+([eE][+-]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[xX][\da-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringChar"/> + <push state="character"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="[^\s(){}]+"> + <token type="Text"/> + </rule> + <rule pattern="\s+?"> + <token type="Text"/> + </rule> + </state> + <state name="module"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="([A-Z][\w.]*)(\s+)(\()"> + <bygroups> + <token type="NameNamespace"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="funclist"/> + </rule> + <rule pattern="[A-Z][\w.]*"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + </state> + <state name="funclist"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[A-Z]\w*"> + <token type="KeywordType"/> + </rule> + <rule pattern="(_[\w\']+|[a-z][\w\']*)"> + <token type="NameFunction"/> + </rule> + <rule pattern="--.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\{-"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="[:!#$%&*+.\\/<=>?@^|~-]+"> + <token type="Operator"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="funclist" state="funclist"/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="2"/> + </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="character"> + <rule pattern="[^\\']"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringEscape"/> + <push state="escape"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringChar"/> + <pop depth="1"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^\\"]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringEscape"/> + <push state="escape"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/igor.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/igor.xml new file mode 100644 index 0000000..1cc0205 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/igor.xml @@ -0,0 +1,47 @@ +<lexer> + <config> + <name>Igor</name> + <alias>igor</alias> + <alias>igorpro</alias> + <filename>*.ipf</filename> + <mime_type>text/ipf</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="root"> + <rule pattern="//.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern=""([^"\\]|\\.)*""> + <token type="LiteralString"/> + </rule> + <rule pattern="\b(AbortOnValue|AbortOnRTE|strswitch|endswitch|continue|default|endfor|endtry|switch|return|elseif|while|catch|endif|break|else|case|for|try|do|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(strconstant|constant|variable|funcref|string|uint64|uint32|uint16|STRUCT|double|dfref|uchar|int16|int32|int64|float|WAVE|SVAR|NVAR|char)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="\b(EndStructure|MultiThread|ThreadSafe|Structure|EndMacro|function|DoPrompt|override|Picture|SubMenu|window|Prompt|static|macro|Proc|Menu|end)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="\b(ConvertGlobalStringTextEncoding|StatsCircularCorrelationTest|LinearFeedbackShiftRegister|StatsCircularTwoSampleTest|StatsLinearCorrelationTest|ITCUpdateFIFOPositionAll2|StatsMultiCorrelationTest|MFR_GetBrickletDeployData|MFR_GetResultFileMetaData|StatsAngularDistanceTest|MFR_GetVernissageVersion|StatsRankCorrelationTest|ITCGetAllChannelsConfig2|GISGetRegisteredFileInfo|AxonTelegraphFindServers|MFR_CheckForNewBricklets|MFR_GetBrickletMetaData|MFR_CreateOverviewTable|StatsWatsonUSquaredTest|StatsWatsonWilliamsTest|ITCConfigChannelUpload2|SavePackagePreferences|LoadPackagePreferences|StatsWheelerWatsonTest|DAQmx_DIO_WriteNewData|ITCUpdateFIFOPosition2|ParseOperationTemplate|GISRasterizeVectorData|MFR_GetXOPErrorMessage|MFR_GetBrickletRawData|StatsWRCorrelationTest|ITCConfigChannelReset2|MFR_GetResultFileName|ImageRemoveBackground|DAQmx_CTR_OutputPulse|ImageHistModification|ITCConfigAllChannels2|StatsLinearRegression|StatsContingencyTable|ImageAnalyzeParticles|GISGetVectorLayerInfo|MFR_GetReportTemplate|MultiThreadingControl|StatsWilcoxonRankTest|SphericalInterpolate|GISWriteGeometryData|StatsNPNominalSRTest|StatsCircularMoments|MFR_GetBrickletCount|GPIBWriteBinaryWave2|ITCFIFOAvailableAll2|DAQmx_CTR_PulseWidth|SphericalTriangulate|ITCGetChannelConfig2|ImageGenerateROIMask|DAQmx_CTR_CountEdges|ITCGetCurrentDevice2|AddWavesToViolinPlot|DAQmx_AI_SetupReader|StatsShapiroWilkTest|GISCreateVectorLayer|AppendMatrixContour|GetLastUserMenuInfo|CtrlNamedBackground|VDTWriteBinaryWave2|DuplicateDataFolder|MatrixLinearSolveTD|CreateAliasShortcut|MFR_CloseResultFile|SetWaveTextEncoding|StatsKendallTauTest|VISAWriteBinaryWave|StatsHodgesAjneTest|RemoveLayoutObjects|ITCGetSerialNumber2|ImageBoundaryToMask|GPIBReadBinaryWave2|MFR_GetBrickletData|DefaultTextEncoding|DAQmx_AO_SetOutputs|PopupContextualMenu|ITCGetErrorString2|ImageEdgeDetection|VDTOperationsPort2|DefaultGuiControls|AutoPositionWindow|ExperimentModified|FastGaussTransform|GISTransformCoords|AppendLayoutObject|VDTReadBinaryWave2|FTPCreateDirectory|StatsVariancesTest|NeuralNetworkTrain|VISAReadBinaryWave|StatsCircularMeans|MFR_OpenResultFile|HDF5ListAttributes|SetActiveSubwindow|ImageRegistration|HDF5ConvertColors|TickWavesFromAxis|StatsANOVA2NRTest|StatsANOVA2RMTest|ITCFIFOAvailable2|AddWavesToBoxPlot|NC_ListAttributes|MeasureStyledText|HDF5TestOperation|GetFileFolderInfo|SetFileFolderInfo|ITCGetDeviceInfo2|SoundInStartChart|GISLoadRasterData|MatrixLinearSolve|EstimatePeakSizes|GISLoadVectorData|ExecuteScriptText|StatsFriedmanTest|ModifyControlList|GISWriteFieldData|ITCConfigChannel2|DeleteAnnotations|GISUnRegisterFile|DAQmx_WaveformGen|RenameDataFolder|MarkPerfTestTime|ITCWriteDigital2|HilbertTransform|ImageUnwrapPhase|HDF5UnlinkObject|LayoutPageAction|GPIBWriteBinary2|VDTTerminalPort2|StatsScheffeTest|ImageInterpolate|ITCSelectDevice2|ThreadGroupPutDF|FindPointsInPoly|AppendViolinPlot|DisplayHelpTopic|DisplayProcedure|RemoveFromLayout|StatsDunnettTest|StatsCochranTest|ImageLineProfile|GISGetRasterInfo|DAQmx_DIO_Config|ModifyViolinPlot|DAQmx_CTR_Period|NeuralNetworkRun|SoundInStopChart|VDTWriteHexWave2|AppendXYZContour|AddFIFOVectData|PlayMovieAction|ImageMorphology|HDF5CreateGroup|ITCReadDigital2|MatrixTranspose|WignerTransform|VISAWriteBinary|ITCGetVersions2|ITCCloseDevice2|VDTWriteBinary2|RatioFromNumber|StatsANOVA1Test|LayoutSlideShow|RemoveFromGizmo|RemoveFromGraph|RemoveFromTable|GISRegisterFile|StatsANOVA2Test|SetProcessSleep|VDTReadHexWave2|ImageSkeleton3d|VDTGetPortList2|DebuggerOptions|GPIBReadBinary2|SetIgorMenuMode|ModifyWaterfall|MCC_FindServers|LombPeriodogram|StatsQuantiles|MoveDataFolder|MatrixConvolve|AppendToLayout|BackgroundInfo|VISAReadBinary|ModifyFreeAxis|GISWriteRaster|ImageTransform|ImageThreshold|MatrixMultiply|DefaultGuiFont|SQLHighLevelOp|ITCGetDevices2|HDF5CloseGroup|NC_ListObjects|HDF5CreateFile|DSPPeriodogram|HDF5CreateLink|NotebookAction|HDF5DumpErrors|GPIBWriteWave2|WindowFunction|ExperimentInfo|ITCInitialize2|MFR_GetVersion|ITCOpenDevice2|SaveExperiment|FindDuplicates|ImageHistogram|KillDataFolder|ITCSetGlobals2|VDTReadBinary2|CtrlBackground|KillBackground|CheckDisplayed|StatsTukeyTest|HideProcedures|JointHistogram|SetDashPattern|ImageComposite|HDF5LoadGroup|ControlUpdate|CopyDimLabels|ToCommandLine|ColorTab2Wave|CreateBrowser|Triangulate3d|ImageFileInfo|VDTClosePort2|MatrixInverse|HideIgorMenus|HDF5SaveImage|HDF5SaveGroup|StatsSignTest|HDF5OpenGroup|HDF5LoadImage|HDF5ListGroup|CustomControl|HDF5FlushFile|HDF5DumpState|VDTWriteWave2|StatsResample|HDF5CloseFile|MatrixSVBkSub|ImageSeedFill|ModifyBoxPlot|ModifyBrowser|MatrixLUBkSub|ModifyContour|ModifyControl|VDTGetStatus2|GraphWaveEdit|GraphWaveDraw|PrintSettings|MoveSubwindow|GPIBReadWave2|StatsNPMCTest|Differentiate|Interpolate3D|AppendToTable|SetIdlePeriod|MultiTaperPSD|SoundSaveWave|AppendToGraph|AppendToGizmo|NC_DumpErrors|AppendBoxPlot|VISAWriteWave|WaveTransform|DrawUserShape|AddMovieFrame|AddMovieAudio|SoundLoadWave|NewDataFolder|SoundInRecord|PrintNotebook|ShowIgorMenus|RemoveContour|SetRandomSeed|KillVariables|ReorderImages|ITCReadTimer2|ReorderTraces|SaveGraphCopy|SaveTableCopy|SetIgorOption|SetBackground|JCAMPLoadWave|SetDataFolder|SoundInStatus|SaveGizmoCopy|DeletePoints|ITCStartAcq2|ITCSetState2|ITCSetModes2|NewWaterfall|OpenNotebook|WaveMeanStdv|KillFreeAxis|PauseForUser|VISAReadWave|NC_CloseFile|GetSelection|BoundingBall|PrimeFactors|VDTWriteHex2|VDTReadWave2|MoveVariable|ITCGetState2|ITCCloseAll2|PutScrapText|Interp3DPath|VDTOpenPort2|FPClustering|Interpolate2|FindSequence|RenameWindow|ModifyLayout|ResumeUpdate|ModifyCamera|HDFReadImage|IntegrateODE|SumDimension|SaveNotebook|MatrixEigenV|MatrixFilter|MatrixGaussJ|SetDrawLayer|InsertPoints|HDF5LoadData|HDF5OpenFile|StatsChiTest|HDF5SaveData|SmoothCustom|StackWindows|DeleteFolder|ImageFromXYZ|StatsDIPTest|ImageRestore|NewFIFOChan|StatsJBTest|ImageRotate|MatrixSolve|MatrixSchur|DefineGuide|StatsKWTest|MatrixLUDTD|ImageFilter|SplitString|SortColumns|DelayUpdate|SetWaveLock|SetVariable|ExportGizmo|ITCStopAcq2|ImageWindow|DefaultFont|SetIgorHook|HDFReadVset|StatsSample|SetDimLabel|StatsSRTest|TDMLoadData|TDMSaveData|FindContour|Integrate2D|ReplaceWave|ReplaceText|ModifyGizmo|ModifyGraph|ModifyImage|ControlInfo|ModifyPanel|ModifyTable|GraphNormal|ThreadStart|TileWindows|RemoveImage|Concatenate|Redimension|ChooseColor|VDTReadHex2|PrintLayout|PrintGraphs|VISAControl|ITCReadADC2|KillStrings|Preferences|FTPDownload|PauseUpdate|AppendImage|NC_LoadData|NC_OpenFile|AddFIFOData|KillControl|NewNotebook|NewFreeAxis|StatsKSTest|ConvexHull|GBLoadWave|ITCSetDAC2|AdoptFiles|DSPDetrend|ImageBlend|ImageFocus|AppendText|SetMarquee|DrawBezier|NILoadWave|DrawAction|KillWindow|SetFormula|MLLoadWave|SetDrawEnv|DoIgorMenu|FIFOStatus|HDFReadSDS|XLLoadWave|ImageSnake|CloseMovie|GetMarquee|DeleteFile|FindLevels|ImageStats|MatrixCorr|NC_Inquire|RenamePICT|ValDisplay|RenamePath|URLRequest|ColorScale|MoveWindow|StatsTTest|RemovePath|ControlBar|PrintTable|GPIBWrite2|PulseStats|CopyScales|TabControl|DAQmx_Scan|CopyFolder|MoveString|MoveFolder|StructFill|SoundInSet|StatsFTest|FReadLine|Integrate|SumSeries|GPIBRead2|MakeIndex|FTPDelete|Correlate|ToolsGrid|GetWindow|PopupMenu|PlaySound|FTPUpload|PlayMovie|MatrixGLM|FindValue|IndexSort|MatrixLLS|MatrixLUD|CloseProc|CloseHelp|GetCamera|FindLevel|ShowTools|ImageSave|StructGet|FindAPeak|MatrixSVD|FilterIIR|FilterFIR|EdgeStats|FIFO2Wave|BuildMenu|ImageLoad|BrowseURL|BoxSmooth|FuncFitMD|DoXOPIdle|VDTWrite2|FBinWrite|KillWaves|ImageGLCM|KillPICTs|VISAWrite|NewCamera|SplitWave|WaveStats|HideTools|StructPut|DrawRRect|SetWindow|ErrorBars|NewLayout|Duplicate|Histogram|FindRoots|Debugger|NewGizmo|NewImage|wfprintf|NewMovie|KillFIFO|KillPath|NewPanel|VISARead|CheckBox|ShowInfo|DrawText|Notebook|DrawRect|SetScale|HideInfo|OpenHelp|DrawPoly|VDTRead2|Optimize|PathInfo|DrawPICT|DrawOval|DrawLine|GetGizmo|Variable|FBinRead|HDF5Dump|GetMouse|MoveWave|LoadData|DoUpdate|TitleBox|LoadPICT|LoadWave|FindPeak|Convolve|CopyFile|SavePICT|StatsKDE|FMaxFlat|SaveData|MatrixOP|MoveFile|CtrlFIFO|CurveFit|GroupBox|Resample|DoWindow|FSetPos|ListBox|Extract|Reverse|DrawArc|sprintf|Execute|NewFIFO|FStatus|Hanning|DoAlert|HDFInfo|TextBox|SetAxis|fprintf|FGetPos|Project|GetAxis|NewPath|FuncFit|Display|FastOp|Remove|NI4882|String|Silent|Layout|Legend|Append|Button|sscanf|Smooth|Modify|Slider|KMeans|printf|Unwrap|APMath|Rotate|Cursor|Rename|Abort|Label|Remez|Cross|Loess|Stack|Chart|Sleep|GPIB2|Print|Close|Save|Sort|DPSS|Grep|Open|Tile|VDT2|Make|IFFT|Edit|Beep|Note|Quit|STFT|pwd|dir|Tag|DWT|FFT|PCA|ICA|CWT|cd)\b"> + <token type="NameClass"/> + </rule> + <rule pattern="\b(TDMGetChannelStringPropertyLen|MCC_SetSlowCurrentInjSetlTime|tango_set_attr_monitor_period|TDMGetLibraryErrorDescription|MCC_GetSlowCurrentInjSetlTime|TDMGetGroupStringPropertyLen|fDAQmx_CTR_SetPulseFrequency|TDMGetFileStringPropertyLen|MCC_SetSlowCurrentInjEnable|MCC_GetSlowCompTauX20Enable|MCC_GetSlowCurrentInjEnable|fDAQmx_WF_WaitUntilFinished|MCC_SetSlowCompTauX20Enable|AxonTelegraphAGetDataStruct|MCC_GetNeutralizationEnable|MCC_SetNeutralizationEnable|AxonTelegraphAGetDataString|fDAQmx_CTR_ReadWithOptions|fDAQmx_ScanWaitWithTimeout|fDAQmx_DisconnectTerminals|MCC_GetWholeCellCompResist|MCC_SetSecondarySignalGain|fDAQmx_CTR_IsPulseFinished|MCC_GetSecondarySignalGain|TDMGetChannelPropertyNames|AxonTelegraphGetDataString|AxonTelegraphGetDataStruct|MCC_GetWholeCellCompEnable|MCC_SetWholeCellCompResist|TDMGetNumChannelProperties|MCC_SetWholeCellCompEnable|tango_suspend_attr_monitor|MCC_GetSlowCurrentInjLevel|tango_reload_dev_interface|MCC_SetSlowCurrentInjLevel|AxonTelegraphSetTimeoutMs|AxonTelegraphGetTimeoutMs|tango_resume_attr_monitor|TDMSetChannelPropertyTime|MCC_SetSecondarySignalLPF|MCC_GetSecondarySignalLPF|zeromq_test_serializeWave|SQLTextWaveTo2DBinaryWave|zeromq_test_serializeWave|TDMGetChannelPropertyTime|SQL2DBinaryWaveToTextWave|TDMGetChannelPropertyType|TDMSetChannelPropertyStr|TDMGetNumGroupProperties|MCC_SetNeutralizationCap|MCC_SetPrimarySignalGain|TDMGetGroupPropertyNames|SQLBinaryWavesToTextWave|TDMReplaceDataValuesTime|TDMGetChannelPropertyNum|TDMGetChannelPropertyStr|TDMSetChannelPropertyNum|TDMCreateChannelProperty|MCC_SelectMultiClamp700B|tango_start_attr_monitor|GetIndependentModuleName|AxonTelegraphAGetDataNum|MCC_GetNeutralizationCap|MCC_GetPrimarySignalGain|UnsetEnvironmentVariable|zeromq_test_callfunction|zeromq_test_callfunction|TDMChannelPropertyExists|tango_compute_image_proj|SQLTextWaveToBinaryWaves|MCC_SetPrimarySignalHPF|MCC_GetRsCompCorrection|MCC_GetPrimarySignalLPF|TDMGetFilePropertyNames|MCC_SetWholeCellCompCap|TDMGetGroupPropertyTime|TDMGetGroupPropertyType|MCC_SetRsCompPrediction|MCC_SetRsCompCorrection|MCC_GetRsCompPrediction|MCC_SetPrimarySignalLPF|fDAQmx_ConnectTerminals|TDMGetNumFileProperties|SQLNumResultRowsIfKnown|fDAQmx_AO_UpdateOutputs|tango_get_dev_black_box|fDAQmx_ScanGetAvailable|fDAQmx_ScanGetNextIndex|TDMAppendDataValuesTime|tango_stop_attr_monitor|tango_get_dev_attr_list|MCC_GetPrimarySignalHPF|TDMSetGroupPropertyTime|MCC_GetWholeCellCompCap|AxonTelegraphGetDataNum|fDAQmx_NumAnalogOutputs|TDMSetGroupPropertyNum|TDMSetGroupPropertyStr|TDMSetFilePropertyTime|StatsInvRectangularCDF|MCC_SetBridgeBalEnable|MCC_GetBridgeBalEnable|MCC_GetBridgeBalResist|MCC_GetOscKillerEnable|fDAQmx_SelfCalibration|tango_write_attributes|MCC_SetOscKillerEnable|TDMGroupPropertyExists|fDAQmx_ExternalCalDate|tango_get_dev_cmd_list|SetEnvironmentVariable|fDAQmx_NumAnalogInputs|TDMCreateGroupProperty|TDMGetFilePropertyType|MCC_SetRsCompBandwidth|TDMGetGroupPropertyStr|MCC_GetRsCompBandwidth|fDAQmx_CTR_ReadCounter|TDMGetGroupPropertyNum|TDMGetFilePropertyTime|MCC_SetBridgeBalResist|GetEnvironmentVariable|TDMGetFilePropertyNum|tango_set_dev_timeout|TDMFilePropertyExists|tango_write_attribute|fDAQmx_CTR_IsFinished|StatsInvTriangularCDF|zeromq_client_connect|zeromq_client_connect|MCC_AutoWholeCellComp|TDMCreateFileProperty|TDMGetFilePropertyStr|GetWavesDataFolderDFR|TDMSetFilePropertyStr|TDMSetFilePropertyNum|tango_get_dev_timeout|tango_get_error_stack|tango_read_attributes|IndependentModuleList|MCC_AutoPipetteOffset|zeromq_handler_start|zeromq_handler_start|tango_read_attribute|fDAQmx_WaveformStart|viGetAttributeString|viSetAttributeString|SpecialCharacterInfo|SpecialCharacterList|TDMSetDataValuesTime|SQLGetConnectAttrNum|SQLGetConnectAttrStr|fDAQmx_WF_IsFinished|fDAQmx_ReadNamedChan|SQLSetConnectAttrNum|SQLSetConnectAttrStr|GISGetAllFileFormats|TDMGetDataValuesTime|tango_get_dev_status|ContourNameToWaveRef|MCC_SetHoldingEnable|SQLUpdateBoundValues|GetIndexedObjNameDFR|MCC_SetPipetteOffset|fDAQmx_DIO_PortWidth|MCC_GetHoldingEnable|MCC_GetPipetteOffset|StatsInvGeometricCDF|StatsInvNBinomialCDF|StatsInvLogNormalCDF|ThreadProcessorCount|TDMReplaceDataValues|FontSizeStringWidth|tango_command_inout|GetBrowserSelection|StatsInvFriedmanCDF|MCC_SetRsCompEnable|TDMGetNumDataValues|ConvertTextEncoding|GetDefaultFontStyle|StatsInvBinomialCDF|fDAQmx_WaveformStop|fDAQmx_CTR_Finished|fDAQmx_AI_GetReader|StatsInvRayleighCDF|DataFolderRefStatus|zeromq_handler_stop|StatsInvSpearmanCDF|TDMAppendDataValues|StatsSpearmanRhoCDF|StatsInvUsquaredCDF|SQLColumnPrivileges|StatsRectangularPDF|StatsRectangularCDF|StatsInvVonMisesCDF|MCC_GetRsCompEnable|fDAQmx_DIO_Finished|zeromq_handler_stop|SQLProcedureColumns|CaptureHistoryStart|StatsInvLogisticCDF|DataFolderRefsEqual|SQLSetDescFieldNum|ThreadGroupRelease|zeromq_server_recv|TraceNameToWaveRef|StatsInvWeibullCDF|SQLGetDiagFieldStr|GetWavesDataFolder|SQLGetDiagFieldNum|SQLGetDescFieldStr|SQLGetDescFieldNum|zeromq_server_bind|MCC_GetFastCompCap|SQLTablePrivileges|SQLColAttributeStr|SQLColAttributeNum|StatsInvTopDownCDF|StatsInvStudentCDF|SphericalHarmonics|StatsTriangularCDF|viAssertIntrSignal|fDAQmx_SelfCalDate|ReplaceStringByKey|ImageNameToWaveRef|viAssertUtilSignal|ReplaceNumberByKey|MCC_GetFastCompTau|StatsTriangularPDF|BinarySearchInterp|StatsVonMisesNoise|MPFXExpConvExpPeak|fDAQmx_ResetDevice|zeromq_server_send|fDAQmx_ErrorString|tango_close_device|MCC_GetSlowCompCap|fDAQmx_NumDIOPorts|fDAQmx_NumCounters|zeromq_server_bind|MCC_SetSlowCompTau|MCC_SetSlowCompCap|StatsInvPoissonCDF|GetDefaultFontSize|MCC_GetSlowCompTau|zeromq_server_recv|zeromq_client_recv|zeromq_client_recv|SQLSetDescFieldStr|MCC_SetFastCompTau|zeromq_server_send|StatsInvMaxwellCDF|fDAQmx_DeviceNames|zeromq_client_send|MCC_SetFastCompCap|zeromq_client_send|ListToWaveRefWave|TDMGetNumChannels|ThreadGroupCreate|XWaveRefFromTrace|MPFXLorenzianPeak|viVxiCommandQuery|NewFreeDataFolder|SQLGetStmtAttrNum|SQLBulkOperations|HDF5AttributeInfo|MCC_AutoBridgeBal|SQLGetStmtAttrStr|PossiblyQuoteName|SQLNumRowsFetched|SQLSetStmtAttrNum|ThreadGroupGetDFR|SQLSetStmtAttrStr|SQLSpecialColumns|viGpibPassControl|StatsGeometricCDF|StatsGeometricPDF|StatsInvCauchyCDF|StatsInvEValueCDF|StatsInvKuiperCDF|StatsInvNormalCDF|StatsInvParetoCDF|WaveRefWaveToList|StatsLogNormalCDF|StatsLogNormalPDF|ThreadReturnValue|StatsNBinomialCDF|StatsNBinomialPDF|WaveRefIndexedDFR|tango_open_device|GetIndexedObjName|tango_ping_device|StatsLogisticCDF|fDAQmx_ScanStart|MCC_AutoSlowComp|MCC_AutoFastComp|ScreenResolution|SQLSetCursorName|StatsInvMooreCDF|GISSRefsAreEqual|fDAQmx_DIO_Write|SQLSetEnvAttrNum|StatsRayleighCDF|fDAQmx_WriteChan|SQLDriverConnect|SQLGetCursorName|StatsInvCMSSDCDF|SQLDescribeParam|SQLSetEnvAttrStr|StatsInvPowerCDF|StatsVonMisesPDF|PixelFromAxisVal|fDAQmx_CTR_Start|StatsInvNCChiCDF|SQLXOPCheckState|StatsInvGammaCDF|StatsTrimmedMean|WaveTextEncoding|StatsRayleighPDF|StatsUSquaredCDF|GetDataFolderDFR|TDMRemoveChannel|viGpibControlATN|SQLBrowseConnect|DataFolderExists|ThreadGroupGetDF|StatsVonMisesCDF|MCC_SetTimeoutMs|SQLBindParameter|TextEncodingName|TextEncodingCode|AxisValFromPixel|SQLGetEnvAttrNum|SQLGetEnvAttrStr|StatsBinomialCDF|TDMSetDataValues|StatsBinomialPDF|SQLNumResultCols|viGpibControlREN|NormalizeUnicode|StatsFriedmanCDF|StatsCorrelation|StatsLogisticPDF|TDMGetDataValues|StrVarOrDefault|SphericalBessJD|StatsPoissonCDF|ControlNameList|viUsbControlOut|SphericalBessYD|StatsStudentCDF|NumVarOrDefault|StatsStudentPDF|StatsPoissonPDF|TDMGetNumGroups|SQLGetFunctions|StatsMaxwellCDF|ChildWindowList|PanelResolution|ThreadGroupWait|HDF5DatasetInfo|viDiscardEvents|HDF5LibraryInfo|ContourNameList|GetRTErrMessage|StatsWeibullPDF|StatsMaxwellPDF|fDAQmx_ScanStop|StatsInvDExpCDF|StatsTopDownCDF|StatsPowerNoise|viOpenDefaultRM|lorentzianNoise|fDAQmx_ScanWait|fDAQmx_DIO_Read|MatrixCondition|CountObjectsDFR|viAssertTrigger|fDAQmx_ReadChan|StatsInvBetaCDF|SQLReinitialize|TDMCloseChannel|StatsWeibullCDF|MandelbrotPoint|SQLFreeConnect|CaptureHistory|TDMGetDataType|TDMGetChannels|RemoveListItem|RemoveFromList|GetBrowserLine|GetRTStackInfo|ParamIsDefault|StatsInvChiCDF|SQLPrimaryKeys|StringFromList|GetDefaultFont|TDMRemoveGroup|StatsKuiperCDF|StatsCauchyCDF|SQLFetchScroll|SQLForeignKeys|SQLMoreResults|SQLGetTypeInfo|StatsCauchyPDF|SpecialDirPath|SphericalBessJ|StatsErlangCDF|SphericalBessY|StatsErlangPDF|FontSizeHeight|SQLAllocHandle|StatsEValueCDF|StatsEValuePDF|viSetAttribute|StatsParetoCDF|StatsInvExpCDF|AnnotationList|StatsInvNCFCDF|TraceFromPixel|viUsbControlIn|viUnmapTrigger|ListToTextWave|WaveRefIndexed|viUnmapAddress|SQLDataSources|logNormalNoise|SQLDescribeCol|MCC_SetHolding|StatsParetoPDF|viGetAttribute|viDisableEvent|StatsHyperGCDF|StatsHyperGPDF|StatsNormalCDF|MCC_GetHolding|StatsNormalPDF|SQLCloseCursor|AnnotationInfo|SQLStatistics|SQLFreeHandle|viGpibSendIFC|StatsNCChiCDF|SQLExecDirect|SQLDisconnect|SQLGetDataNum|SQLGetDataStr|GetErrMessage|expIntegralE1|SQLGetDescRec|WaveRefsEqual|TDMAddChannel|SQLGetDiagRec|StatsMooreCDF|WhichListItem|StatsGammaPDF|SQLGetInfoNum|SQLGetInfoStr|StatsGammaCDF|GuideNameList|viWaitOnEvent|StatsNCChiPDF|TraceNameList|viEnableEvent|LaguerreGauss|TDMCloseGroup|TDMCreateFile|StatsErrorPDF|MPFXGaussPeak|MPFXVoigtPeak|StatsCMSSDCDF|SQLProcedures|DataFolderDir|StatsPowerPDF|WinRecreation|ImageNameList|ReplaceString|GetDataFolder|binomialNoise|TDMOpenFileEx|SQLSetDescRec|StatsInvQpCDF|ProcedureText|ParseFilePath|OperationList|StatsPowerCDF|GetRTLocation|viGpibCommand|GetRTLocInfo|poissonNoise|CountObjects|FunctionPath|FunctionList|GetScrapText|StatsWaldCDF|scaleToIndex|StartMSTimer|StatsBetaCDF|StatsBetaPDF|FunctionInfo|StatsInvQCDF|StatsWaldPDF|IndexToScale|RemoveEnding|StatsInvFCDF|DateToJulian|BinarySearch|StatsDExpCDF|StatsDExpPDF|SelectNumber|SelectString|SQLParamData|Base64Encode|Base64Decode|JulianToDate|viMapTrigger|SQLNumParams|viMapAddress|TDMCloseFile|FindListItem|SQLAllocStmt|FindDimLabel|HDF5TypeInfo|StatsPermute|VariableList|hermiteGauss|SQLNativeSql|viStatusDesc|CreationDate|TDMGetGroups|StatsRunsCDF|StatsGEVPDF|StatsGEVCDF|StatsExpPDF|StatsExpCDF|StatsChiPDF|StatsChiCDF|GetKeyState|GetUserData|SQLRowCount|StopMSTimer|StringByKey|stringmatch|SVAR_Exists|SQLFreeStmt|HyperGNoise|dilogarithm|TDMAddGroup|IgorVersion|sinIntegral|CsrXWaveRef|RemoveByKey|viMoveOut16|viMoveOut32|IndexedFile|PolygonArea|cosIntegral|inverseERFC|CleanupName|NVAR_Exists|FuncRefInfo|TDMOpenFile|NumberByKey|NewFreeWave|TDMSaveFile|Integrate1D|MPFXEMGPeak|ItemsInList|UnPadString|StatsMedian|zeromq_stop|MCC_SetMode|viTerminate|zeromq_stop|AddListItem|StatsNCFCDF|StatsNCFPDF|StatsNCTCDF|StatsNCTPDF|MatrixTrace|GetDimLabel|MCC_GetMode|ContourInfo|TrimString|FresnelCos|FresnelSin|MatrixRank|UniqueName|gammaEuler|SQLBindCol|StatsQpCDF|inverseERF|gammaNoise|NameOfWave|binomialln|zeromq_set|CsrWaveRef|WaveExists|zeromq_set|chebyshevU|viMoveIn16|GetFormula|equalWaves|SQLColumns|SQLConnect|GetRTError|SQLDrivers|viMoveIn32|LayoutInfo|GizmoScale|IndexedDir|SQLPutData|viFindRsrc|faverageXY|SQLPrepare|StringList|GrepString|viMemAlloc|SQLExecute|viMoveOut8|TagWaveRef|SQLFreeEnv|SQLEndTran|viFindNext|URLDecode|TableInfo|LaguerreA|URLEncode|VoigtPeak|strsearch|XWaveName|GuideInfo|PadString|VoigtFunc|MacroList|GizmoInfo|SQLSetPos|factorial|TraceInfo|SQLTables|DimOffset|LegendreA|StatsFCDF|HyperGPFQ|HyperG0F1|StatsFPDF|CheckName|WaveUnits|MatrixDet|chebyshev|SQLCancel|viMoveIn8|HyperG1F1|StatsQCDF|HyperG2F1|MatrixDot|ListMatch|viMemFree|Secs2Date|viReadSTB|date2secs|ImageInfo|Secs2Time|stringCRC|datetime|SortList|IgorInfo|CTabList|viUnlock|CsrXWave|sawtooth|DimDelta|LowerStr|WaveType|WaveName|expNoise|Faddeeva|fakedata|faverage|SQLError|SQLFetch|LambertW|ZernikeR|UpperStr|PICTList|ContourZ|PICTInfo|StudentA|viPeek16|PathList|GrepList|WaveDims|Variance|FetchURL|Laguerre|char2num|num2istr|num2char|JacobiSn|WaveHash|viPeek32|AxisInfo|viPoke16|WaveInfo|binomial|WaveList|JacobiCn|AxisList|TextFile|gammaInc|Interp3D|viPoke32|FontList|Interp2D|StudentT|Besselj|Besselk|Bessely|ModDate|viPoke8|numpnts|numtype|num2str|viPeek8|viOut32|viOut16|WinType|CsrInfo|CsrWave|r2polar|WinName|WinList|defined|digamma|DimSize|viWrite|WaveMin|str2num|WaveCRC|Gauss2D|MarcumQ|Gauss1D|WaveMax|viClear|Besseli|hermite|viClose|viOut8|interp|areaXY|cequal|gnoise|median|TagVal|viRead|strlen|wnoise|cmpstr|gammln|viIn16|viIn32|viLock|exists|AiryBD|Dawson|deltax|AiryAD|enoise|rightx|magsqr|expInt|p2rect|viOpen|poly2D|trunc|erfcw|pnt2x|AiryB|betai|floor|gamma|AiryA|viIn8|acosh|gammp|cpowi|x2pnt|ticks|round|gammq|asinh|limit|leftx|cmplx|Gauss|atan2|atanh|pcsr|Hash|hcsr|imag|atan|asin|area|alog|norm|note|poly|beta|conj|qcsr|erfc|real|sinh|cabs|sech|sign|date|csch|sinc|sqrt|xcsr|acos|coth|zeta|zcsr|tanh|cosh|time|ceil|mean|vcsr|cot|csc|tan|erf|exp|gcd|abs|Inf|sum|log|max|min|mod|NaN|sin|sec|cos|Pi|ln|ei)\b"> + <token type="NameFunction"/> + </rule> + <rule pattern="^#(include|pragma|define|undef|ifdef|ifndef|if|elif|else|endif)"> + <token type="NameDecorator"/> + </rule> + <rule pattern="[^a-z"/]+$"> + <token type="Text"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + <rule pattern="\n|\r"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ini.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ini.xml new file mode 100644 index 0000000..88a742b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ini.xml @@ -0,0 +1,40 @@ +<lexer> + <config> + <name>INI</name> + <alias>ini</alias> + <alias>cfg</alias> + <alias>dosini</alias> + <filename>*.ini</filename> + <filename>*.cfg</filename> + <filename>*.inf</filename> + <filename>.gitconfig</filename> + <filename>.editorconfig</filename> + <mime_type>text/x-ini</mime_type> + <mime_type>text/inf</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[;#].*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\[.*?\]$"> + <token type="Keyword"/> + </rule> + <rule pattern="(.*?)([ \t]*)(=)([ \t]*)(.*(?:\n[ \t].+)*)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Text"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(.+?)$"> + <token type="NameAttribute"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/io.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/io.xml new file mode 100644 index 0000000..9ad94fa --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/io.xml @@ -0,0 +1,71 @@ +<lexer> + <config> + <name>Io</name> + <alias>io</alias> + <filename>*.io</filename> + <mime_type>text/x-iosrc</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="//(.*?)\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="#(.*?)\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/(\\\n)?[*](.|\n)*?[*](\\\n)?/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="/\+"> + <token type="CommentMultiline"/> + <push state="nestedcomment"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="::=|:=|=|\(|\)|;|,|\*|-|\+|>|<|@|!|/|\||\^|\.|%|&|\[|\]|\{|\}"> + <token type="Operator"/> + </rule> + <rule pattern="(clone|do|doFile|doString|method|for|if|else|elseif|then)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(nil|false|true)\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="(Object|list|List|Map|args|Sequence|Coroutine|File)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="nestedcomment"> + <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> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/j.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/j.xml new file mode 100644 index 0000000..872d081 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/j.xml @@ -0,0 +1,157 @@ +<lexer> + <config> + <name>J</name> + <alias>j</alias> + <filename>*.ijs</filename> + <mime_type>text/x-j</mime_type> + </config> + <rules> + <state name="singlequote"> + <rule pattern="[^']"> + <token type="LiteralString"/> + </rule> + <rule pattern="''"> + <token type="LiteralString"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="#!.*$"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="NB\..*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\n+\s*Note"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\s*Note.*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="singlequote"/> + </rule> + <rule pattern="0\s+:\s*0|noun\s+define\s*$"> + <token type="NameEntity"/> + <push state="nounDefinition"/> + </rule> + <rule pattern="(([1-4]|13)\s+:\s*0|(adverb|conjunction|dyad|monad|verb)\s+define)\b"> + <token type="NameFunction"/> + <push state="explicitDefinition"/> + </rule> + <rule pattern="(label_|goto_|for_)\b[a-zA-Z]\w*\."> + <token type="NameLabel"/> + </rule> + <rule pattern="(continue|select|return|assert|catchd|catcht|elseif|whilst|break|catch|fcase|while|throw|else|case|end|try|for|do|if)\."> + <token type="NameLabel"/> + </rule> + <rule pattern="\b[a-zA-Z]\w*"> + <token type="NameVariable"/> + </rule> + <rule pattern="(timespacex|fixdotdot|nameclass|namelist|file2url|tmoutput|ucpcount|boxxopen|smoutput|JVERSION|datatype|toupper|tolower|alpha17|alpha27|getargs|evtloop|boxopen|fliprgb|inverse|scriptd|iospath|cutopen|isatty|toCRLF|toHOST|isutf8|getenv|stdout|script|usleep|sminfo|expand|stderr|clear|fetch|every|erase|empty|Debug|EMPTY|split|names|timex|cutLF|stdin|apply|items|table|exit|Note|list|take|leaf|type|bind|drop|rows|each|echo|sign|CRLF|utf8|sort|pick|ARGV|uucp|ucp|DEL|inv|hfd|dfh|def|LF2|EAV|toJ|TAB|nl|FF|LF|bx|nc|CR|on)"> + <token type="NameFunction"/> + </rule> + <rule pattern="=[.:]"> + <token type="Operator"/> + </rule> + <rule pattern="[-=+*#$%@!~`^&";:.,<>{}\[\]\\|/]"> + <token type="Operator"/> + </rule> + <rule pattern="[abCdDeEfHiIjLMoprtT]\."> + <token type="KeywordReserved"/> + </rule> + <rule pattern="[aDiLpqsStux]\:"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(_[0-9])\:"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="parentheses"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + </state> + <state name="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="explicitDefinition"> + <rule pattern="\b[nmuvxy]\b"> + <token type="NameDecorator"/> + </rule> + <rule> + <include state="root"/> + </rule> + <rule pattern="[^)]"> + <token type="Name"/> + </rule> + <rule pattern="^\)"> + <token type="NameLabel"/> + <pop depth="1"/> + </rule> + <rule pattern="[)]"> + <token type="Name"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="\b_{1,2}\b"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="_?\d+(\.\d+)?(\s*[ejr]\s*)_?\d+(\.?=\d+)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="_?\d+\.(?=\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="_?\d+x"> + <token type="LiteralNumberIntegerLong"/> + </rule> + <rule pattern="_?\d+"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="nounDefinition"> + <rule pattern="[^)]"> + <token type="LiteralString"/> + </rule> + <rule pattern="^\)"> + <token type="NameLabel"/> + <pop depth="1"/> + </rule> + <rule pattern="[)]"> + <token type="LiteralString"/> + </rule> + </state> + <state name="parentheses"> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="explicitDefinition"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/java.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/java.xml new file mode 100644 index 0000000..715f043 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/java.xml @@ -0,0 +1,118 @@ +<lexer> + <config> + <name>Java</name> + <alias>java</alias> + <filename>*.java</filename> + <mime_type>text/x-java</mime_type> + <dot_all>true</dot_all> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <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> + <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="(assert|break|case|catch|continue|default|do|else|finally|for|if|goto|instanceof|new|return|switch|this|throw|try|while)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\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="(abstract|const|enum|extends|final|implements|native|private|protected|public|static|strictfp|super|synchronized|throws|transient|volatile)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(boolean|byte|char|double|float|int|long|short|void)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(package)(\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)(\s+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + </bygroups> + <push state="class"/> + </rule> + <rule pattern="(import(?:\s+static)?)(\s+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="import"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'"> + <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="[~^*!%&\[\](){}<>|+=:;,./?-]"> + <token type="Operator"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/javascript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/javascript.xml new file mode 100644 index 0000000..f8e7b1b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/javascript.xml @@ -0,0 +1,159 @@ +<lexer> + <config> + <name>JavaScript</name> + <alias>js</alias> + <alias>javascript</alias> + <filename>*.js</filename> + <filename>*.jsm</filename> + <filename>*.mjs</filename> + <mime_type>application/javascript</mime_type> + <mime_type>application/x-javascript</mime_type> + <mime_type>text/x-javascript</mime_type> + <mime_type>text/javascript</mime_type> + <dot_all>true</dot_all> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <state name="interp"> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\\`"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\\[^`\\]"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="interp-inside"/> + </rule> + <rule pattern="\$"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="[^`\\$]+"> + <token type="LiteralStringBacktick"/> + </rule> + </state> + <state name="interp-inside"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="commentsandwhitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="<!--"> + <token type="Comment"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="slashstartsregex"> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gimuy]+\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 pattern="\A#! ?/.*?\n"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="^(?=\s|/|<!--)"> + <token type="Text"/> + <push state="slashstartsregex"/> + </rule> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="\d+(\.\d*|[eE][+\-]?\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[bB][01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0[oO][0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9][0-9_]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\.\.\.|=>"> + <token type="Punctuation"/> + </rule> + <rule pattern="\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?"> + <token type="Operator"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[{(\[;,]"> + <token type="Punctuation"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[})\].]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(for|in|while|do|break|return|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|void|yield|this|of)\b"> + <token type="Keyword"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(var|let|with|function)\b"> + <token type="KeywordDeclaration"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(abstract|async|await|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"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(true|false|null|NaN|Infinity|undefined)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|Promise|Proxy|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|Error|eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|document|this|window)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?:[$_\p{L}\p{N}]|\\u[a-fA-F0-9]{4})(?:(?:[$\p{L}\p{N}]|\\u[a-fA-F0-9]{4}))*"> + <token type="NameOther"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <push state="interp"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/json.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/json.xml new file mode 100644 index 0000000..bbe10b1 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/json.xml @@ -0,0 +1,110 @@ +<lexer> + <config> + <name>JSON</name> + <alias>json</alias> + <filename>*.json</filename> + <mime_type>application/json</mime_type> + <dot_all>true</dot_all> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="root"> + <rule> + <include state="value"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + <state name="comment"> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + </state> + <state name="simplevalue"> + <rule pattern="(true|false|null)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="-?(0|[1-9]\d*)(\.\d+[eE](\+|-)?\d+|[eE](\+|-)?\d+|\.\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?(0|[1-9]\d*)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="objectattribute"> + <rule> + <include state="value"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="2"/> + </rule> + </state> + <state name="objectvalue"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="comment"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="NameTag"/> + <push state="objectattribute"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="arrayvalue"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="value"/> + </rule> + <rule> + <include state="comment"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="\]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="value"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="simplevalue"/> + </rule> + <rule> + <include state="comment"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="objectvalue"/> + </rule> + <rule pattern="\["> + <token type="Punctuation"/> + <push state="arrayvalue"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/julia.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/julia.xml new file mode 100644 index 0000000..776dcdb --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/julia.xml @@ -0,0 +1,400 @@ +<lexer> + <config> + <name>Julia</name> + <alias>julia</alias> + <alias>jl</alias> + <filename>*.jl</filename> + <mime_type>text/x-julia</mime_type> + <mime_type>application/x-julia</mime_type> + </config> + <rules> + <state name="string"> + <rule pattern="(")((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)|\d+)?"> + <bygroups> + <token type="LiteralString"/> + <token type="LiteralStringAffix"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\"\'$nrbtfav]|(x|u|U)[a-fA-F0-9]+|\d+)"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="interp"/> + </rule> + <rule pattern="%[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^"$%\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="."> + <token type="LiteralString"/> + </rule> + </state> + <state name="curly"> + <rule pattern="\{"> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="(?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)"> + <token type="KeywordType"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="rawstring"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\""> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="([^"\\]|\\[^"])+"> + <token type="LiteralString"/> + </rule> + </state> + <state name="tqcommand"> + <rule pattern="(```)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)|\d+)?"> + <bygroups> + <token type="LiteralStringBacktick"/> + <token type="LiteralStringAffix"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="\\\$"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="interp"/> + </rule> + <rule pattern="[^\\`$]+"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="."> + <token type="LiteralStringBacktick"/> + </rule> + </state> + <state name="in-intp"> + <rule pattern="\("> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="tqstring"> + <rule pattern="(""")((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)|\d+)?"> + <bygroups> + <token type="LiteralString"/> + <token type="LiteralStringAffix"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\"\'$nrbtfav]|(x|u|U)[a-fA-F0-9]+|\d+)"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="interp"/> + </rule> + <rule pattern="[^"$%\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="."> + <token type="LiteralString"/> + </rule> + </state> + <state name="interp"> + <rule pattern="\$(?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="(\$)(\()"> + <bygroups> + <token type="LiteralStringInterpol"/> + <token type="Punctuation"/> + </bygroups> + <push state="in-intp"/> + </rule> + </state> + <state name="tqregex"> + <rule pattern="(""")([imsxa]*)?"> + <bygroups> + <token type="LiteralStringRegex"/> + <token type="LiteralStringAffix"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="[^"]+"> + <token type="LiteralStringRegex"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="#="> + <token type="CommentMultiline"/> + <push state="blockcomment"/> + </rule> + <rule pattern="#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="[\[\](),;]"> + <token type="Punctuation"/> + </rule> + <rule pattern="((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))(\s*)(:)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))"> + <bygroups> + <token type="Name"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Name"/> + </bygroups> + </rule> + <rule pattern="(?<![\]):<>\d.])(:(?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="(?<=::)(\s*)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))\b(?![(\[])"> + <bygroups> + <token type="Text"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))(\s*)([<>]:)(\s*)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))\b(?![(\[])"> + <bygroups> + <token type="KeywordType"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Text"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="([<>]:)(\s*)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))\b(?![(\[])"> + <bygroups> + <token type="Operator"/> + <token type="Text"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="\b((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))(\s*)([<>]:)"> + <bygroups> + <token type="KeywordType"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="(>>>=|<-->|≕'|⊻=|⇁|⥯|⥮|⥥|⥣|⥡|⥠|⥝|⥜|⥙|//=|⥘|⥕|÷=|⥔|<<=|>>=|￪|⥑|⥏|￬|≔|⩴|√|⥍|⥌|→|↔|↚|↛|↞|↠|↢|↣|↦|↤|↮|⇎|⇍|⇏|⇐|⇒|⇔|⇴|⇶|⇷|⇸|⇹|⇺|⇻|⇼|⇽|⇾|⇿|⟵|⟶|⟷|⟹|⟺|⟻|⟼|⟽|⟾|⟿|⤀|⤁|⤂|⤃|⤄|⤅|⤆|⤇|⤌|⤍|⤎|⤏|⤐|⤑|⤔|⤕|⤖|⤗|⤘|⤝|⤞|⤟|⤠|⥄|⥅|⥆|⥇|⥈|⥊|⥋|⥎|⥐|⥒|⥓|⥖|⥗|⥚|⥛|⥞|⥟|⥢|⥤|⥦|⥧|⥨|⥩|⥪|⥫|⥬|⥭|⥰|⧴|⬱|⬰|⬲|⬳|⬴|⬵|⬶|⬷|⬸|⬹|⬺|⬻|⬼|⬽|⬾|⬿|⭀|⭁|⭂|⭃|⭄|⭇|⭈|⭉|⭊|⭋|⭌|￩|￫|⇜|⇝|↜|↝|↩|↪|↫|↬|↼|↽|⇀|⥉|⇄|⇆|⇇|⇉|⇋|⇌|⇚|⇛|⇠|⇢|↷|↶|↺|↻|-->|<--|∛|⤓|⤒|⤋|≥|⤊|≤|⤉|===|≡|⤈|≠|!==|≢|∈|∉|∋|∌|⊆|⊈|⊂|⊄|⊊|∝|∊|∍|∥|∦|∷|∺|∻|∽|∾|≁|≃|≂|≄|≅|≆|≇|≈|≉|≊|≋|≌|≍|≎|≐|≑|≒|≓|≖|≗|≘|≙|≚|≛|≜|≝|≞|≟|≣|≦|≧|≨|≩|≪|≫|≬|≭|≮|≯|≰|≱|≲|≳|≴|≵|≶|≷|≸|≹|≺|≻|≼|≽|≾|≿|⊀|⊁|⊃|⊅|⊇|⊉|⊋|⊏|⊐|⊑|⊒|⊜|⊩|⊬|⊮|⊰|⊱|⊲|⊳|⊴|⊵|⊶|⊷|⋍|⋐|⋑|⋕|⋖|⋗|⋘|⋙|⋚|⋛|⋜|⋝|⋞|⋟|⋠|⋡|⋢|⋣|⋤|⋥|⋦|⋧|⋨|⋩|⋪|⋫|⋬|⋭|⋲|⋳|⋴|⋵|⋶|⋷|⩚|⋹|⋺|⋻|⋼|⋽|⋾|⋿|⟈|⟉|⟒|⦷|⧀|⧁|⧡|⧣|⧤|⧥|⩦|⩧|⩪|⩫|⩬|⩭|⩮|⩯|⩰|⩱|⩲|⩳|⩵|⩶|⩷|⩸|⩹|⩺|⩻|⩼|⩽|⩾|⩿|⪀|⪁|⪂|⪃|⪄|⪅|⪆|⪇|⪈|⪉|⪊|⪋|⪌|⪍|⪎|⪏|⪐|⪑|⪒|⪓|⪔|⪕|⪖|⪗|⪘|⪙|⪚|⪛|⪜|⪝|⪞|⪟|⪠|⪡|⪢|⪣|⪤|⪥|⪦|⪧|⪨|⪩|⪪|⪫|⪬|⪭|⪮|⪯|⪰|⪱|⪲|⪳|⪴|⪵|⪶|⪷|⪸|⪹|⪺|⪻|⪼|⪽|⪾|⪿|⫀|⫁|⫂|⫃|⫄|⫅|⫆|⫇|⫈|⫉|⫊|⫋|⫌|⫍|⫎|⫏|⫐|⫑|⫒|⫓|⫔|⫕|⫖|⫗|⫘|⫙|⫷|⫸|⫹|⫺|⊢|⊣|⟂|⟱|⟰|⇵|↓|…|⁝|⋮|⋱|⋰|⋯|↑|>>>|⨟|⟗|⊕|⊖|⊞|⊟|⟖|∪|∨|⊔|⟕|∓|∔|∸|≏|⊎|⊻|⊽|⋎|⋓|⧺|⧻|⨈|⨢|⨣|⨤|⨥|⨦|⨧|⨨|⨩|⨪|⨫|⨬|⨭|⨮|⨹|⨺|⩁|⩂|⩅|⩊|⩌|⩏|⩐|⩒|⩔|⩖|⩗|⩛|⩝|⩡|⩢|⩣|⨝|▷|⌿|⊍|⫛|⩠|⋅|∘|⩟|⩞|∩|∧|⊗|⊘|⊙|⊚|⊛|⊠|⊡|⊓|∗|∙|∤|⅋|≀|⊼|⋄|⋆|⋇|⋉|⋊|⋋|⋌|⋏|⋒|⟑|⦸|⦼|⦾|⦿|⧶|⧷|⨇|⨰|⨱|⨲|⨳|⨴|⨵|⨶|⨷|⨸|⨻|⨼|⨽|⩀|⩃|⩄|⩋|⩍|⩎|⩑|⩓|⩕|⩘|⋸|⩜|∜|\^=|:=|\$=|÷|¬|\|\||±|\+\+|&&|¦|//|>>|<<|::|-=|\*=|\|>|<\||>:|<:|!=|==|<=|>=|/=|%=|->|=>|\\=|&=|\|=|×|\+=|:|<|\+|\^|\\|=|-|\$|~|\||\*|\?|!|/|%|&|>)[²³¹ʰʲʳʷʸˡˢˣᴬᴮᴰᴱᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾᴿᵀᵁᵂᵃᵇᵈᵉᵍᵏᵐᵒᵖᵗᵘᵛᵝᵞᵟᵠᵡᵢᵣᵤᵥᵦᵧᵨᵩᵪᶜᶠᶥᶦᶫᶰᶸᶻᶿ′″‴‵‶‷⁗⁰ⁱ⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿ₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₒₓₕₖₗₘₙₚₛₜⱼⱽ]*"> + <token type="Operator"/> + </rule> + <rule pattern="(\.>>>=|\.<-->|\.≕'|\.⊻=|\.⇚|\.//=|\.⥯|\.⥮|\.÷=|\.⥥|\.<<=|\.>>=|\.￪|\.⥣|\.⥡|\.￬|\.≔|\.⩴|\.√|\.⥠|\.⥝|\.→|\.↔|\.↚|\.↛|\.↞|\.↠|\.↢|\.↣|\.↦|\.↤|\.↮|\.⇎|\.⇍|\.⇏|\.⇐|\.⇒|\.⇔|\.⇴|\.⇶|\.⇷|\.⇸|\.⇹|\.⇺|\.⇻|\.⇼|\.⇽|\.⇾|\.⇿|\.⟵|\.⟶|\.⟷|\.⟹|\.⟺|\.⟻|\.⟼|\.⟽|\.⟾|\.⟿|\.⤀|\.⤁|\.⤂|\.⤃|\.⤄|\.⤅|\.⤆|\.⤇|\.⤌|\.⤍|\.⤎|\.⤏|\.⤐|\.⤑|\.⤔|\.⤕|\.⤖|\.⤗|\.⤘|\.⤝|\.⤞|\.⤟|\.⤠|\.⥄|\.⥅|\.⥆|\.⥇|\.⥈|\.⥊|\.⥋|\.⥎|\.⥐|\.⥒|\.⥓|\.⥖|\.⥗|\.⥚|\.⥛|\.⥞|\.⥟|\.⥢|\.⥤|\.⥦|\.⥧|\.⥨|\.⥩|\.⥪|\.⥫|\.⥬|\.⥭|\.⥰|\.⧴|\.⬱|\.⬰|\.⬲|\.⬳|\.⬴|\.⬵|\.⬶|\.⬷|\.⬸|\.⬹|\.⬺|\.⬻|\.⬼|\.⬽|\.⬾|\.⬿|\.⭀|\.⭁|\.⭂|\.⭃|\.⭄|\.⭇|\.⭈|\.⭉|\.⭊|\.⭋|\.⭌|\.￩|\.￫|\.⇜|\.⇝|\.↜|\.↝|\.↩|\.↪|\.↫|\.↬|\.↼|\.↽|\.⇀|\.⇁|\.⇄|\.⇆|\.⇇|\.⇉|\.⇋|\.⇌|\.⥜|\.⇛|\.⇠|\.⇢|\.↷|\.↶|\.↺|\.↻|\.-->|\.<--|\.∛|\.⥙|\.⥘|\.⥕|\.≥|\.⥔|\.≤|\.⥑|\.===|\.≡|\.⥏|\.≠|\.!==|\.≢|\.∈|\.∉|\.∋|\.∌|\.⊆|\.⊈|\.⊂|\.⊄|\.⊊|\.∝|\.∊|\.∍|\.∥|\.∦|\.∷|\.∺|\.∻|\.∽|\.∾|\.≁|\.≃|\.≂|\.≄|\.≅|\.≆|\.≇|\.≈|\.≉|\.≊|\.≋|\.≌|\.≍|\.≎|\.≐|\.≑|\.≒|\.≓|\.≖|\.≗|\.≘|\.≙|\.≚|\.≛|\.≜|\.≝|\.≞|\.≟|\.≣|\.≦|\.≧|\.≨|\.≩|\.≪|\.≫|\.≬|\.≭|\.≮|\.≯|\.≰|\.≱|\.≲|\.≳|\.≴|\.≵|\.≶|\.≷|\.≸|\.≹|\.≺|\.≻|\.≼|\.≽|\.≾|\.≿|\.⊀|\.⊁|\.⊃|\.⊅|\.⊇|\.⊉|\.⊋|\.⊏|\.⊐|\.⊑|\.⊒|\.⊜|\.⊩|\.⊬|\.⊮|\.⊰|\.⊱|\.⊲|\.⊳|\.⊴|\.⊵|\.⊶|\.⊷|\.⋍|\.⋐|\.⋑|\.⋕|\.⋖|\.⋗|\.⋘|\.⋙|\.⋚|\.⋛|\.⋜|\.⋝|\.⋞|\.⋟|\.⋠|\.⋡|\.⋢|\.⋣|\.⋤|\.⋥|\.⋦|\.⋧|\.⋨|\.⋩|\.⋪|\.⋫|\.⋬|\.⋭|\.⋲|\.⋳|\.⋴|\.⋵|\.⋶|\.⋷|\.⋸|\.⋹|\.⋺|\.⋻|\.⟕|\.⋽|\.⋾|\.⋿|\.⟈|\.⟉|\.⟒|\.⦷|\.⧀|\.⧁|\.⧡|\.⧣|\.⧤|\.⧥|\.⩦|\.⩧|\.⩪|\.⩫|\.⩬|\.⩭|\.⩮|\.⩯|\.⩰|\.⩱|\.⩲|\.⩳|\.⩵|\.⩶|\.⩷|\.⩸|\.⩹|\.⩺|\.⩻|\.⩼|\.⩽|\.⩾|\.⩿|\.⪀|\.⪁|\.⪂|\.⪃|\.⪄|\.⪅|\.⪆|\.⪇|\.⪈|\.⪉|\.⪊|\.⪋|\.⪌|\.⪍|\.⪎|\.⪏|\.⪐|\.⪑|\.⪒|\.⪓|\.⪔|\.⪕|\.⪖|\.⪗|\.⪘|\.⪙|\.⪚|\.⪛|\.⪜|\.⪝|\.⪞|\.⪟|\.⪠|\.⪡|\.⪢|\.⪣|\.⪤|\.⪥|\.⪦|\.⪧|\.⪨|\.⪩|\.⪪|\.⪫|\.⪬|\.⪭|\.⪮|\.⪯|\.⪰|\.⪱|\.⪲|\.⪳|\.⪴|\.⪵|\.⪶|\.⪷|\.⪸|\.⪹|\.⪺|\.⪻|\.⪼|\.⪽|\.⪾|\.⪿|\.⫀|\.⫁|\.⫂|\.⫃|\.⫄|\.⫅|\.⫆|\.⫇|\.⫈|\.⫉|\.⫊|\.⫋|\.⫌|\.⫍|\.⫎|\.⫏|\.⫐|\.⫑|\.⫒|\.⫓|\.⫔|\.⫕|\.⫖|\.⫗|\.⫘|\.⫙|\.⫷|\.⫸|\.⫹|\.⫺|\.⊢|\.⊣|\.⟂|\.⥍|\.⥌|\.⥉|\.⤓|\.…|\.⁝|\.⋮|\.⋱|\.⋰|\.⋯|\.⤒|\.⤋|\.⤊|\.⤉|\.⊕|\.⊖|\.⊞|\.⊟|\.⤈|\.∪|\.∨|\.⊔|\.⟱|\.∓|\.∔|\.∸|\.≏|\.⊎|\.⊻|\.⊽|\.⋎|\.⋓|\.⧺|\.⧻|\.⨈|\.⨢|\.⨣|\.⨤|\.⨥|\.⨦|\.⨧|\.⨨|\.⨩|\.⨪|\.⨫|\.⨬|\.⨭|\.⨮|\.⨹|\.⨺|\.⩁|\.⩂|\.⩅|\.⩊|\.⩌|\.⩏|\.⩐|\.⩒|\.⩔|\.⩖|\.⩗|\.⩛|\.⩝|\.⩡|\.⩢|\.⩣|\.⟰|\.⇵|\.⌿|\.↓|\.↑|\.>>>|\.⋅|\.∘|\.⨟|\.⟗|\.∩|\.∧|\.⊗|\.⊘|\.⊙|\.⊚|\.⊛|\.⊠|\.⊡|\.⊓|\.∗|\.∙|\.∤|\.⅋|\.≀|\.⊼|\.⋄|\.⋆|\.⋇|\.⋉|\.⋊|\.⋋|\.⋌|\.⋏|\.⋒|\.⟑|\.⦸|\.⦼|\.⦾|\.⦿|\.⧶|\.⧷|\.⨇|\.⨰|\.⨱|\.⨲|\.⨳|\.⨴|\.⨵|\.⨶|\.⨷|\.⨸|\.⨻|\.⨼|\.⨽|\.⩀|\.⩃|\.⩄|\.⩋|\.⩍|\.⩎|\.⩑|\.⩓|\.⩕|\.⩘|\.⩚|\.⩜|\.⩞|\.⩟|\.⩠|\.⫛|\.⊍|\.▷|\.⨝|\.⋼|\.⟖|\.∜|\.=>|\.//|\.>>|\.<<|\.\+=|\.×|\.-=|\.÷|\.¬|\.\*=|\./=|\.\+\+|\.\\=|\.¦|\.\^=|\.!=|\.\|>|\.<\||\.>:|\.<:|\.±|\.==|\.<=|\.>=|\.%=|\.&=|\.\|=|\.=|\.~|\.>|\.\\|\.<|\.-|\.\||\.\^|\.\*|\.!|\./|\.%|\.&|\.\+)[²³¹ʰʲʳʷʸˡˢˣᴬᴮᴰᴱᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾᴿᵀᵁᵂᵃᵇᵈᵉᵍᵏᵐᵒᵖᵗᵘᵛᵝᵞᵟᵠᵡᵢᵣᵤᵥᵦᵧᵨᵩᵪᶜᶠᶥᶦᶫᶰᶸᶻᶿ′″‴‵‶‷⁗⁰ⁱ⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿ₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₒₓₕₖₗₘₙₚₛₜⱼⱽ]*"> + <token type="Operator"/> + </rule> + <rule pattern="(\.\.\.|\.\.)"> + <token type="Operator"/> + </rule> + <rule pattern="'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="(?<=[.\w)\]])(\'[²³¹ʰʲʳʷʸˡˢˣᴬᴮᴰᴱᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾᴿᵀᵁᵂᵃᵇᵈᵉᵍᵏᵐᵒᵖᵗᵘᵛᵝᵞᵟᵠᵡᵢᵣᵤᵥᵦᵧᵨᵩᵪᶜᶠᶥᶦᶫᶰᶸᶻᶿ′″‴‵‶‷⁗⁰ⁱ⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿ₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₒₓₕₖₗₘₙₚₛₜⱼⱽ]*)+"> + <token type="Operator"/> + </rule> + <rule pattern="(raw)(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="tqrawstring"/> + </rule> + <rule pattern="(raw)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="rawstring"/> + </rule> + <rule pattern="(r)(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringRegex"/> + </bygroups> + <push state="tqregex"/> + </rule> + <rule pattern="(r)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringRegex"/> + </bygroups> + <push state="regex"/> + </rule> + <rule pattern="((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))?(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="tqstring"/> + </rule> + <rule pattern="((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))?(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))?(```)"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringBacktick"/> + </bygroups> + <push state="tqcommand"/> + </rule> + <rule pattern="((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))?(`)"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringBacktick"/> + </bygroups> + <push state="command"/> + </rule> + <rule pattern="((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))(\{)"> + <bygroups> + <token type="KeywordType"/> + <token type="Punctuation"/> + </bygroups> + <push state="curly"/> + </rule> + <rule pattern="(where)(\s+)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="(\{)"> + <token type="Punctuation"/> + <push state="curly"/> + </rule> + <rule pattern="(abstract[ \t]+type|primitive[ \t]+type|mutable[ \t]+struct|struct)([\s()]+)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*))"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="@(?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)"> + <token type="NameDecorator"/> + </rule> + <rule pattern="@(>>>=|<-->|≕'|⊻=|↽|⥯|⥮|⥥|⥣|⥡|⥠|⥝|⥜|⥙|⥘|⥕|//=|⥔|⥑|÷=|⥏|<<=|>>=|￪|⥍|⥌|￬|≔|⩴|√|⥉|⤓|→|↔|↚|↛|↞|↠|↢|↣|↦|↤|↮|⇎|⇍|⇏|⇐|⇒|⇔|⇴|⇶|⇷|⇸|⇹|⇺|⇻|⇼|⇽|⇾|⇿|⟵|⟶|⟷|⟹|⟺|⟻|⟼|⟽|⟾|⟿|⤀|⤁|⤂|⤃|⤄|⤅|⤆|⤇|⤌|⤍|⤎|⤏|⤐|⤑|⤔|⤕|⤖|⤗|⤘|⤝|⤞|⤟|⤠|⥄|⥅|⥆|⥇|⥈|⥊|⥋|⥎|⥐|⥒|⥓|⥖|⥗|⥚|⥛|⥞|⥟|⥢|⥤|⥦|⥧|⥨|⥩|⥪|⥫|⥬|⥭|⥰|⧴|⬱|⬰|⬲|⬳|⬴|⬵|⬶|⬷|⬸|⬹|⬺|⬻|⬼|⬽|⬾|⬿|⭀|⭁|⭂|⭃|⭄|⭇|⭈|⭉|⭊|⭋|⭌|￩|￫|⇜|⇝|↜|↝|↩|↪|↫|↬|↼|⤒|⇀|⇁|⇄|⇆|⇇|⇉|⇋|⇌|⇚|⇛|⇠|⇢|↷|↶|↺|↻|-->|<--|∛|⤋|⤊|⤉|≥|⤈|≤|⟱|===|≡|⟰|≠|!==|≢|∈|∉|∋|∌|⊆|⊈|⊂|⊄|⊊|∝|∊|∍|∥|∦|∷|∺|∻|∽|∾|≁|≃|≂|≄|≅|≆|≇|≈|≉|≊|≋|≌|≍|≎|≐|≑|≒|≓|≖|≗|≘|≙|≚|≛|≜|≝|≞|≟|≣|≦|≧|≨|≩|≪|≫|≬|≭|≮|≯|≰|≱|≲|≳|≴|≵|≶|≷|≸|≹|≺|≻|≼|≽|≾|≿|⊀|⊁|⊃|⊅|⊇|⊉|⊋|⊏|⊐|⊑|⊒|⊜|⊩|⊬|⊮|⊰|⊱|⊲|⊳|⊴|⊵|⊶|⊷|⋍|⋐|⋑|⋕|⋖|⋗|⋘|⋙|⋚|⋛|⋜|⋝|⋞|⋟|⋠|⋡|⋢|⋣|⋤|⋥|⋦|⋧|⋨|⋩|⋪|⋫|⋬|⋭|⋲|⋳|⋴|⋵|⋶|⩕|⋸|⋹|⋺|⋻|⋼|⋽|⋾|⋿|⟈|⟉|⟒|⦷|⧀|⧁|⧡|⧣|⧤|⧥|⩦|⩧|⩪|⩫|⩬|⩭|⩮|⩯|⩰|⩱|⩲|⩳|⩵|⩶|⩷|⩸|⩹|⩺|⩻|⩼|⩽|⩾|⩿|⪀|⪁|⪂|⪃|⪄|⪅|⪆|⪇|⪈|⪉|⪊|⪋|⪌|⪍|⪎|⪏|⪐|⪑|⪒|⪓|⪔|⪕|⪖|⪗|⪘|⪙|⪚|⪛|⪜|⪝|⪞|⪟|⪠|⪡|⪢|⪣|⪤|⪥|⪦|⪧|⪨|⪩|⪪|⪫|⪬|⪭|⪮|⪯|⪰|⪱|⪲|⪳|⪴|⪵|⪶|⪷|⪸|⪹|⪺|⪻|⪼|⪽|⪾|⪿|⫀|⫁|⫂|⫃|⫄|⫅|⫆|⫇|⫈|⫉|⫊|⫋|⫌|⫍|⫎|⫏|⫐|⫑|⫒|⫓|⫔|⫕|⫖|⫗|⫘|⫙|⫷|⫸|⫹|⫺|⊢|⊣|⟂|⇵|↓|↑|>>>|…|⁝|⋮|⋱|⋰|⋯|⨟|⟗|⟖|⟕|⊕|⊖|⊞|⊟|⨝|∪|∨|⊔|▷|∓|∔|∸|≏|⊎|⊻|⊽|⋎|⋓|⧺|⧻|⨈|⨢|⨣|⨤|⨥|⨦|⨧|⨨|⨩|⨪|⨫|⨬|⨭|⨮|⨹|⨺|⩁|⩂|⩅|⩊|⩌|⩏|⩐|⩒|⩔|⩖|⩗|⩛|⩝|⩡|⩢|⩣|⊍|⫛|⌿|⩠|⩟|⩞|⋅|∘|⩜|⩚|∩|∧|⊗|⊘|⊙|⊚|⊛|⊠|⊡|⊓|∗|∙|∤|⅋|≀|⊼|⋄|⋆|⋇|⋉|⋊|⋋|⋌|⋏|⋒|⟑|⦸|⦼|⦾|⦿|⧶|⧷|⨇|⨰|⨱|⨲|⨳|⨴|⨵|⨶|⨷|⨸|⨻|⨼|⨽|⩀|⩃|⩄|⩋|⩍|⩎|⩑|⩓|⋷|⩘|∜|\\=|:=|\$=|÷|¬|\|\||±|\+\+|&&|¦|::|\.\.|//|>>|<<|\|>|\+=|<\||>:|<:|!=|==|<=|>=|-=|\*=|->|=>|/=|&=|\|=|%=|\^=|×|~|>|<|\^|=|\.|\+|-|\$|:|\||\*|\?|!|/|%|&|\\)[²³¹ʰʲʳʷʸˡˢˣᴬᴮᴰᴱᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾᴿᵀᵁᵂᵃᵇᵈᵉᵍᵏᵐᵒᵖᵗᵘᵛᵝᵞᵟᵠᵡᵢᵣᵤᵥᵦᵧᵨᵩᵪᶜᶠᶥᶦᶫᶰᶸᶻᶿ′″‴‵‶‷⁗⁰ⁱ⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿ₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₒₓₕₖₗₘₙₚₛₜⱼⱽ]*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="(baremodule|continue|function|finally|module|import|elseif|return|export|global|macro|catch|where|begin|const|ccall|using|quote|break|while|local|else|let|isa|try|for|end|in|if|do)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(ProcessFailedException|InvalidStateException|ReadOnlyMemoryError|TaskFailedException|InterruptException|StackOverflowError|CompositeException|AbstractIrrational|SubstitutionString|ExponentialBackOff|UndefKeywordError|CapturedException|DimensionMismatch|AbstractUnitRange|SegmentationFault|PermutedDimsArray|AbstractVecOrMat|UndefInitializer|CartesianIndices|OutOfMemoryError|ComposedFunction|MissingException|StringIndexError|PartialQuickSort|AbstractDisplay|AbstractPattern|StridedVecOrMat|AbstractChannel|LineNumberNode|AbstractVector|CartesianIndex|AssertionError|IndexCartesian|ErrorException|AbstractMatrix|AbstractString|OverflowError|UndefRefError|LinearIndices|DenseVecOrMat|ArgumentError|StridedVector|StridedMatrix|AbstractArray|AbstractRange|ReentrantLock|AbstractMatch|AbstractFloat|VersionNumber|UndefVarError|RoundingMode|StridedArray|StepRangeLen|OrdinalRange|AbstractChar|AbstractDict|InexactError|DenseVector|WeakKeyDict|MethodError|AbstractSet|IndexLinear|BoundsError|TextDisplay|DomainError|DenseMatrix|SystemError|DivideError|NamedTuple|IndexStyle|Cptrdiff_t|Cuintmax_t|DenseArray|ComplexF16|Irrational|VecElement|Culonglong|RegexMatch|ComplexF32|ComplexF64|BitMatrix|BitVector|Exception|GlobalRef|UnitRange|QuoteNode|TypeError|IOContext|LoadError|Clonglong|Condition|StepRange|Cintmax_t|SubString|InitError|Cssize_t|VecOrMat|BigFloat|Unsigned|UnionAll|Rational|EOFError|BitArray|IOStream|IOBuffer|KeyError|LinRange|Cwchar_t|SubArray|Function|DataType|Cwstring|Csize_t|Float64|Missing|Float32|Complex|Cstring|Float16|Nothing|Cdouble|Cushort|UInt128|Integer|WeakRef|Channel|TypeVar|Cshort|Cfloat|NTuple|IdDict|BitSet|BigInt|UInt16|Symbol|UInt32|Vector|Signed|Vararg|Culong|String|Int128|Number|UInt64|Cuchar|Matrix|Module|Method|Tuple|Int16|Colon|Cuint|UInt8|Regex|Clong|Cvoid|Cchar|Int32|RawFD|Array|Union|Int64|Timer|Pipe|Type|HTML|Text|UInt|MIME|Char|Cint|Some|Expr|Real|Enum|Pair|Dims|Int8|Dict|Task|Bool|Any|Cmd|Int|Set|Ref|Ptr|Val|IO)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(RoundNearestTiesAway|RoundNearestTiesUp|InsertionSort|RoundFromZero|PROGRAM_FILE|RoundNearest|RoundToZero|ENDIAN_BOM|DEPOT_PATH|RoundDown|QuickSort|MergeSort|LOAD_PATH|VERSION|missing|nothing|devnull|RoundUp|C_NULL|stdout|stderr|NaN32|NaN16|Inf64|Inf32|Inf16|false|stdin|undef|NaN64|true|ARGS|ℯ|NaN|Inf|ENV|im|π|pi)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)"> + <token type="Name"/> + </rule> + <rule pattern="(\d+((_\d+)+)?\.(?!\.)(\d+((_\d+)+)?)?|\.\d+((_\d+)+)?)([eEf][+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+((_\d+)+)?[eEf][+-]?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0x[a-fA-F0-9]+((_[a-fA-F0-9]+)+)?(\.([a-fA-F0-9]+((_[a-fA-F0-9]+)+)?)?)?p[+-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0b[01]+((_[01]+)+)?"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0o[0-7]+((_[0-7]+)+)?"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0x[a-fA-F0-9]+((_[a-fA-F0-9]+)+)?"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d+((_\d+)+)?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(\.)"> + <token type="Operator"/> + </rule> + </state> + <state name="blockcomment"> + <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="command"> + <rule pattern="(`)((?:[a-zA-Z_¡-][a-zA-Z_0-9!¡-]*)|\d+)?"> + <bygroups> + <token type="LiteralStringBacktick"/> + <token type="LiteralStringAffix"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="\\[`$]"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="interp"/> + </rule> + <rule pattern="[^\\`$]+"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="."> + <token type="LiteralStringBacktick"/> + </rule> + </state> + <state name="tqrawstring"> + <rule pattern="""""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="([^"]|"[^"][^"])+"> + <token type="LiteralString"/> + </rule> + </state> + <state name="regex"> + <rule pattern="(")([imsxa]*)?"> + <bygroups> + <token type="LiteralStringRegex"/> + <token type="LiteralStringAffix"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="\\""> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralStringRegex"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/jungle.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/jungle.xml new file mode 100644 index 0000000..92c785d --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/jungle.xml @@ -0,0 +1,98 @@ +<lexer> + <config> + <name>Jungle</name> + <alias>jungle</alias> + <filename>*.jungle</filename> + <mime_type>text/x-jungle</mime_type> + </config> + <rules> + <state name="var"> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="\b(((re)?source|barrel)Path|excludeAnnotations|annotations|lang)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\bbase\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="\b(ind|zsm|hrv|ces|dan|dut|eng|fin|fre|deu|gre|hun|ita|nob|po[lr]|rus|sl[ov]|spa|swe|ara|heb|zh[st]|jpn|kor|tha|vie|bul|tur)"> + <token type="NameConstant"/> + </rule> + <rule pattern="\b((semi)?round|rectangle)(-\d+x\d+)?\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="[\.;\[\]\(\$]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="#(\n|[\w\W]*?[^#]\n)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="^(?=\S)"> + <token type="None"/> + <push state="instruction"/> + </rule> + <rule pattern="[\.;\[\]\(\)\$]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="instruction"> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="="> + <token type="Operator"/> + <push state="value"/> + </rule> + <rule pattern="(?=\S)"> + <token type="None"/> + <push state="var"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="value"> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="\$\("> + <token type="Punctuation"/> + <push state="var"/> + </rule> + <rule pattern="[;\[\]\(\)\$]"> + <token type="Punctuation"/> + </rule> + <rule pattern="#(\n|[\w\W]*?[^#]\n)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="[\w_\-\.\/\\]+"> + <token type="Text"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/kotlin.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/kotlin.xml new file mode 100644 index 0000000..87bc81c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/kotlin.xml @@ -0,0 +1,220 @@ +<lexer> + <config> + <name>Kotlin</name> + <alias>kotlin</alias> + <filename>*.kt</filename> + <mime_type>text/x-kotlin</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="string"> + <rule pattern="\\[tbnr'"\\\$]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\u[0-9a-fA-F]{4}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule> + <include state="string-interpol"/> + </rule> + <rule pattern="[^\n\\"$]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\$"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="package"> + <rule pattern="\S+"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + </state> + <state name="class"> + <rule pattern="\x60[^\x60]+?\x60"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule pattern="(?:[_\p{L}][\p{L}\p{N}]*|`@?[_\p{L}][\p{L}\p{N}]+`)"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="property"> + <rule pattern="\x60[^\x60]+?\x60"> + <token type="NameProperty"/> + <pop depth="1"/> + </rule> + <rule pattern="(?:[_\p{L}][\p{L}\p{N}]*|`@?[_\p{L}][\p{L}\p{N}]+`)"> + <token type="NameProperty"/> + <pop depth="1"/> + </rule> + </state> + <state name="string-interpol"> + <rule pattern="\$(?:[_\p{L}][\p{L}\p{N}]*|`@?[_\p{L}][\p{L}\p{N}]+`)"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="\${[^}\n]*}"> + <token type="LiteralStringInterpol"/> + </rule> + </state> + <state name="generics-specification"> + <rule pattern="<"> + <token type="Punctuation"/> + <push state="generics-specification"/> + </rule> + <rule pattern=">"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="[,:*?]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(in|out|reified)"> + <token type="Keyword"/> + </rule> + <rule pattern="\x60[^\x60]+?\x60"> + <token type="NameClass"/> + </rule> + <rule pattern="(?:[_\p{L}][\p{L}\p{N}]*|`@?[_\p{L}][\p{L}\p{N}]+`)"> + <token type="NameClass"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + <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]*\n?"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/[*].*?[*]/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="!==|!in|!is|==="> + <token type="Operator"/> + </rule> + <rule pattern="%=|&&|\*=|\+\+|\+=|--|-=|->|\.\.|\/=|::|<=|==|>=|!!|!=|\|\||\?[:.]"> + <token type="Operator"/> + </rule> + <rule pattern="[~!%^&*()+=|\[\]:;,.<>\/?-]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[{}]"> + <token type="Punctuation"/> + </rule> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="rawstring"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="(')(\\u[0-9a-fA-F]{4})(')"> + <bygroups> + <token type="LiteralStringChar"/> + <token type="LiteralStringEscape"/> + <token type="LiteralStringChar"/> + </bygroups> + </rule> + <rule pattern="'\\.'|'[^\\]'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F]+[Uu]?[Ll]?|[0-9]+(\.[0-9]*)?([eE][+-][0-9]+)?[fF]?[Uu]?[Ll]?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="(companion)(\s+)(object)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(class|interface|object)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="class"/> + </rule> + <rule pattern="(package|import)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="package"/> + </rule> + <rule pattern="(val|var)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="property"/> + </rule> + <rule pattern="(fun)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="function"/> + </rule> + <rule pattern="(abstract|actual|annotation|as|as\?|break|by|catch|class|companion|const|constructor|continue|crossinline|data|delegate|do|dynamic|else|enum|expect|external|false|field|file|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|it|lateinit|noinline|null|object|open|operator|out|override|package|param|private|property|protected|public|receiver|reified|return|sealed|set|setparam|super|suspend|tailrec|this|throw|true|try|typealias|typeof|val|value|var|vararg|when|where|while)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="@(?:[_\p{L}][\p{L}\p{N}]*|`@?[_\p{L}][\p{L}\p{N}]+`)"> + <token type="NameDecorator"/> + </rule> + <rule pattern="(?:[_\p{L}][\p{L}\p{N}]*|`@?[_\p{L}][\p{L}\p{N}]+`)"> + <token type="Name"/> + </rule> + </state> + <state name="function"> + <rule pattern="<"> + <token type="Punctuation"/> + <push state="generics-specification"/> + </rule> + <rule pattern="\x60[^\x60]+?\x60"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule pattern="(?:[_\p{L}][\p{L}\p{N}]*|`@?[_\p{L}][\p{L}\p{N}]+`)"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + <state name="rawstring"> + <rule pattern="""""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="(?:[^$"]+|\"{1,2}[^"])+"> + <token type="LiteralString"/> + </rule> + <rule> + <include state="string-interpol"/> + </rule> + <rule pattern="\$"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/lighttpd.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/lighttpd.xml new file mode 100644 index 0000000..1319e5c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/lighttpd.xml @@ -0,0 +1,42 @@ +<lexer> + <config> + <name>Lighttpd configuration file</name> + <alias>lighty</alias> + <alias>lighttpd</alias> + <mime_type>text/x-lighttpd-conf</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="#.*\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\S*"> + <token type="Name"/> + </rule> + <rule pattern="[a-zA-Z._-]+"> + <token type="Keyword"/> + </rule> + <rule pattern="\d+\.\d+\.\d+\.\d+(?:/\d+)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="=>|=~|\+=|==|=|\+"> + <token type="Operator"/> + </rule> + <rule pattern="\$[A-Z]+"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[(){}\[\],]"> + <token type="Punctuation"/> + </rule> + <rule pattern=""([^"\\]*(?:\\.[^"\\]*)*)""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/llvm.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/llvm.xml new file mode 100644 index 0000000..f24f152 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/llvm.xml @@ -0,0 +1,73 @@ +<lexer> + <config> + <name>LLVM</name> + <alias>llvm</alias> + <filename>*.ll</filename> + <mime_type>text/x-llvm</mime_type> + </config> + <rules> + <state name="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="([-a-zA-Z$._][\w\-$.]*|"[^"]*?")\s*:"> + <token type="NameLabel"/> + </rule> + <rule> + <include state="keyword"/> + </rule> + <rule pattern="%([-a-zA-Z$._][\w\-$.]*|"[^"]*?")"> + <token type="NameVariable"/> + </rule> + <rule pattern="@([-a-zA-Z$._][\w\-$.]*|"[^"]*?")"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="%\d+"> + <token type="NameVariableAnonymous"/> + </rule> + <rule pattern="@\d+"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="#\d+"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="!([-a-zA-Z$._][\w\-$.]*|"[^"]*?")"> + <token type="NameVariable"/> + </rule> + <rule pattern="!\d+"> + <token type="NameVariableAnonymous"/> + </rule> + <rule pattern="c?"[^"]*?""> + <token type="LiteralString"/> + </rule> + <rule pattern="0[xX][a-fA-F0-9]+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[=<>{}\[\]()*.,!]|x\b"> + <token type="Punctuation"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="(\n|\s)+"> + <token type="Text"/> + </rule> + <rule pattern=";.*?\n"> + <token type="Comment"/> + </rule> + </state> + <state name="keyword"> + <rule pattern="(inaccessiblemem_or_argmemonly|dereferenceable_or_null|externally_initialized|available_externally|linker_private_weak|inaccessiblememonly|local_unnamed_addr|sanitize_address|x86_vectorcallcc|noimplicitfloat|sanitize_thread|source_filename|sanitize_memory|preserve_mostcc|dereferenceable|arm_aapcs_vfpcc|zeroinitializer|extractelement|linker_private|cxx_fast_tlscc|x86_64_win64cc|intel_ocl_bicc|x86_fastcallcc|preserve_allcc|x86_thiscallcc|x86_stdcallcc|amdgpu_kernel|x86_64_sysvcc|addrspacecast|getelementptr|returns_twice|insertelement|shufflevector|msp430_intrcc|extractvalue|linkonce_odr|inteldialect|alwaysinline|blockaddress|noduplicates|thread_local|singlethread|localdynamic|unnamed_addr|avr_signalcc|unreachable|personality|arm_aapcscc|webkit_jscc|catchswitch|initialexec|insertvalue|noduplicate|nonlazybind|extern_weak|spir_kernel|attributes|sideeffect|cleanuppad|cleanupret|inlinehint|convergent|argmemonly|exactmatch|datalayout|landingpad|arm_apcscc|indirectbr|swifterror|ptx_device|ptx_kernel|x86_intrcc|avr_intrcc|alignstack|norecurse|amdgpu_vs|writeonly|localexec|amdgpu_ps|monotonic|amdgpu_gs|amdgpu_cs|allocsize|atomicrmw|swiftself|unordered|sspstrong|nocapture|addrspace|getresult|safestack|appending|noredzone|dllimport|dllexport|nobuiltin|jumptable|protected|spir_func|inbounds|musttail|external|volatile|inalloca|prologue|hhvm_ccc|noinline|readonly|readnone|linkonce|internal|catchret|samesize|returned|ptrtoint|inttoptr|noreturn|constant|nounwind|catchpad|anyregcc|weak_odr|distinct|release|optnone|uwtable|declare|optsize|swiftcc|noalias|private|minsize|default|fptrunc|zeroext|bitcast|nonnull|acq_rel|acquire|signext|builtin|cmpxchg|cleanup|section|largest|deplibs|seq_cst|common|hhvmcc|fptosi|opaque|triple|fptoui|target|filter|comdat|sitofp|module|switch|prefix|fastcc|coldcc|atomic|va_arg|notail|hidden|caller|global|invoke|define|sspreq|within|unwind|alloca|malloc|resume|select|uitofp|store|trunc|naked|byval|fence|fpext|begin|alias|exact|ghccc|ifunc|catch|undef|false|inreg|align|xchg|none|type|sext|call|null|cold|fcmp|icmp|tail|srem|free|load|nand|ashr|lshr|nnan|from|nest|frem|true|sret|urem|fdiv|zext|sdiv|udiv|ninf|arcp|fmul|fast|umax|fsub|umin|weak|fadd|ret|oeq|asm|add|dbg|sub|ccc|one|mul|olt|any|uge|nsz|ule|shl|ogt|ssp|and|sgt|nsw|nuw|min|max|sle|xor|sge|ult|phi|end|ole|une|ueq|uno|ord|oge|slt|ugt|eq|ne|to|gc|cc|or|br|c|x)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(ppc_fp128|metadata|x86_fp80|double|label|fp128|float|token|void|half)"> + <token type="KeywordType"/> + </rule> + <rule pattern="i[1-9]\d*"> + <token type="Keyword"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/lua.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/lua.xml new file mode 100644 index 0000000..903d458 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/lua.xml @@ -0,0 +1,158 @@ +<lexer> + <config> + <name>Lua</name> + <alias>lua</alias> + <filename>*.lua</filename> + <filename>*.wlua</filename> + <mime_type>text/x-lua</mime_type> + <mime_type>application/x-lua</mime_type> + </config> + <rules> + <state name="funcname"> + <rule> + <include state="ws"/> + </rule> + <rule pattern="[.:]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?:[^\W\d]\w*)(?=(?:(?:--\[(=*)\[[\w\W]*?\](\2)\])|(?:--.*$)|(?:\s+))*[.:])"> + <token type="NameClass"/> + </rule> + <rule pattern="(?:[^\W\d]\w*)"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="label"> + <rule> + <include state="ws"/> + </rule> + <rule pattern="::"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="(?:[^\W\d]\w*)"> + <token type="NameLabel"/> + </rule> + </state> + <state name="dqs"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="root"> + <rule pattern="#!.*"> + <token type="CommentPreproc"/> + </rule> + <rule> + <push state="base"/> + </rule> + </state> + <state name="ws"> + <rule pattern="(?:--\[(=*)\[[\w\W]*?\](\1)\])"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="(?:--.*$)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(?:\s+)"> + <token type="Text"/> + </rule> + </state> + <state name="goto"> + <rule> + <include state="ws"/> + </rule> + <rule pattern="(?:[^\W\d]\w*)"> + <token type="NameLabel"/> + <pop depth="1"/> + </rule> + </state> + <state name="sqs"> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\\']+"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="base"> + <rule> + <include state="ws"/> + </rule> + <rule pattern="(?i)0x[\da-f]*(\.[\da-f]*)?(p[+-]?\d+)?"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(?i)\d+e[+-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(?s)\[(=*)\[.*?\]\1\]"> + <token type="LiteralString"/> + </rule> + <rule pattern="::"> + <token type="Punctuation"/> + <push state="label"/> + </rule> + <rule pattern="\.{3}"> + <token type="Punctuation"/> + </rule> + <rule pattern="[=<>|~&+\-*/%#^]+|\.\."> + <token type="Operator"/> + </rule> + <rule pattern="[\[\]{}().,:;]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(and|or|not)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="(break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="goto\b"> + <token type="KeywordReserved"/> + <push state="goto"/> + </rule> + <rule pattern="(local)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(true|false|nil)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(function)\b"> + <token type="KeywordReserved"/> + <push state="funcname"/> + </rule> + <rule pattern="[A-Za-z_]\w*(\.[A-Za-z_]\w*)?"> + <token type="Name"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <combined state="stringescape" state="sqs"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <combined state="stringescape" state="dqs"/> + </rule> + </state> + <state name="stringescape"> + <rule pattern="\\([abfnrtv\\"\']|[\r\n]{1,2}|z\s*|x[0-9a-fA-F]{2}|\d{1,3}|u\{[0-9a-fA-F]+\})"> + <token type="LiteralStringEscape"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mathematica.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mathematica.xml new file mode 100644 index 0000000..5f57470 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mathematica.xml @@ -0,0 +1,56 @@ +<lexer> + <config> + <name>Mathematica</name> + <alias>mathematica</alias> + <alias>mma</alias> + <alias>nb</alias> + <filename>*.nb</filename> + <filename>*.cdf</filename> + <filename>*.nbp</filename> + <filename>*.ma</filename> + <mime_type>application/mathematica</mime_type> + <mime_type>application/vnd.wolfram.mathematica</mime_type> + <mime_type>application/vnd.wolfram.mathematica.package</mime_type> + <mime_type>application/vnd.wolfram.cdf</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="(?s)\(\*.*?\*\)"> + <token type="Comment"/> + </rule> + <rule pattern="([a-zA-Z]+[A-Za-z0-9]*`)"> + <token type="NameNamespace"/> + </rule> + <rule pattern="([A-Za-z0-9]*_+[A-Za-z0-9]*)"> + <token type="NameVariable"/> + </rule> + <rule pattern="#\d*"> + <token type="NameVariable"/> + </rule> + <rule pattern="([a-zA-Z]+[a-zA-Z0-9]*)"> + <token type="Name"/> + </rule> + <rule pattern="-?\d+\.\d*"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?\d*\.\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(!===|@@@|===|/;|:=|->|:>|/\.|=\.|~~|<=|@@|/@|&&|\|\||//|<>|;;|>=|-|@|!|\^|/|\*|\?|\+|&|<|>|=|\|)"> + <token type="Operator"/> + </rule> + <rule pattern="(,|;|\(|\)|\[|\]|\{|\})"> + <token type="Punctuation"/> + </rule> + <rule pattern="".*?""> + <token type="LiteralString"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/matlab.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/matlab.xml new file mode 100644 index 0000000..ebb4e2c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/matlab.xml @@ -0,0 +1,114 @@ +<lexer> + <config> + <name>Matlab</name> + <alias>matlab</alias> + <filename>*.m</filename> + <mime_type>text/matlab</mime_type> + </config> + <rules> + <state name="blockcomment"> + <rule pattern="^\s*%\}"> + <token type="CommentMultiline"/> + <pop depth="1"/> + </rule> + <rule pattern="^.*\n"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="."> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="deffunc"> + <rule pattern="(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)"> + <bygroups> + <token type="TextWhitespace"/> + <token type="Text"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + <token type="NameFunction"/> + <token type="Punctuation"/> + <token type="Text"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(\s*)([a-zA-Z_]\w*)"> + <bygroups> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="^!.*"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="%\{\s*\n"> + <token type="CommentMultiline"/> + <push state="blockcomment"/> + </rule> + <rule pattern="%.*$"> + <token type="Comment"/> + </rule> + <rule pattern="^\s*function"> + <token type="Keyword"/> + <push state="deffunc"/> + </rule> + <rule pattern="(properties|persistent|enumerated|otherwise|continue|function|classdef|methods|elseif|events|switch|return|global|parfor|catch|break|while|else|spmd|case|try|end|for|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(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"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\.\.\..*$"> + <token type="Comment"/> + </rule> + <rule pattern="-|==|~=|<|>|<=|>=|&&|&|~|\|\|?"> + <token type="Operator"/> + </rule> + <rule pattern="\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\"> + <token type="Operator"/> + </rule> + <rule pattern="\[|\]|\(|\)|\{|\}|:|@|\.|,"> + <token type="Punctuation"/> + </rule> + <rule pattern="=|:|;"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?<=[\w)\].])\'+"> + <token type="Operator"/> + </rule> + <rule pattern="(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+[eEf][+-]?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(?<![\w)\].])\'"> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^\']*\'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mcfunction.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mcfunction.xml new file mode 100644 index 0000000..b1ff183 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mcfunction.xml @@ -0,0 +1,182 @@ +<lexer> + <config> + <name>mcfunction</name> + <alias>mcfunction</alias> + <filename>*.mcfunction</filename> + <dot_all>true</dot_all> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="nbtobjectvalue"> + <rule pattern="("(\\\\|\\"|[^"])*"|[a-zA-Z0-9_]+)"> + <token type="NameTag"/> + <push state="nbtobjectattribute"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="nbtarrayvalue"> + <rule> + <include state="nbtvalue"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="\]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="nbtvalue"> + <rule> + <include state="simplevalue"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="nbtobjectvalue"/> + </rule> + <rule pattern="\["> + <token type="Punctuation"/> + <push state="nbtarrayvalue"/> + </rule> + </state> + <state name="argumentvalue"> + <rule> + <include state="simplevalue"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="[}\]]"> + <token type="Punctuation"/> + <pop depth="2"/> + </rule> + </state> + <state name="argumentlist"> + <rule pattern="(nbt)(={)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Punctuation"/> + </bygroups> + <push state="nbtobjectvalue"/> + </rule> + <rule pattern="([A-Za-z0-9/_!]+)(={)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Punctuation"/> + </bygroups> + <push state="argumentlist"/> + </rule> + <rule pattern="([A-Za-z0-9/_!]+)(=)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Punctuation"/> + </bygroups> + <push state="argumentvalue"/> + </rule> + <rule> + <include state="simplevalue"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="[}\]]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="#.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/?(geteduclientinfo|clearspawnpoint|defaultgamemode|transferserver|toggledownfall|immutableworld|detectredstone|setidletimeout|playanimation|classroommode|spreadplayers|testforblocks|setmaxplayers|setworldspawn|testforblock|worldbuilder|createagent|worldborder|camerashake|advancement|raytracefog|locatebiome|tickingarea|replaceitem|attributes|spawnpoint|difficulty|experience|scoreboard|whitelist|structure|playsound|stopsound|forceload|spectate|gamerule|function|schedule|wsserver|teleport|position|save-off|particle|setblock|datapack|mobevent|transfer|gamemode|save-all|bossbar|enchant|trigger|collect|execute|weather|teammsg|tpagent|banlist|dropall|publish|tellraw|testfor|save-on|destroy|ability|locate|summon|remove|effect|reload|ban-ip|recipe|pardon|detect|music|clear|clone|event|mixer|debug|title|ride|stop|list|turn|data|team|kick|loot|tell|help|give|flog|fill|move|time|seed|kill|save|item|deop|code|tag|ban|msg|say|tp|me|op|xp|w)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(@p|@r|@a|@e|@s|@c|@v)"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="\["> + <token type="Punctuation"/> + <push state="argumentlist"/> + </rule> + <rule pattern="{"> + <token type="Punctuation"/> + <push state="nbtobjectvalue"/> + </rule> + <rule pattern="~"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="([a-zA-Z_]+:)?[a-zA-Z_]+\b"> + <token type="Text"/> + </rule> + <rule pattern="([a-z]+)(\.)([0-9]+)\b"> + <bygroups> + <token type="Text"/> + <token type="Punctuation"/> + <token type="LiteralNumber"/> + </bygroups> + </rule> + <rule pattern="([<>=]|<=|>=)"> + <token type="Punctuation"/> + </rule> + <rule> + <include state="simplevalue"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + </state> + <state name="simplevalue"> + <rule pattern="(true|false)"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="[01]b"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="-?(0|[1-9]\d*)(\.\d+[eE](\+|-)?\d+|[eE](\+|-)?\d+|\.\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(-?\d+)(\.\.)(-?\d+)"> + <bygroups> + <token type="LiteralNumberInteger"/> + <token type="Punctuation"/> + <token type="LiteralNumberInteger"/> + </bygroups> + </rule> + <rule pattern="-?(0|[1-9]\d*)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'[^']+'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="([!#]?)(\w+)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + </rule> + </state> + <state name="nbtobjectattribute"> + <rule> + <include state="nbtvalue"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="2"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/meson.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/meson.xml new file mode 100644 index 0000000..130047d --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/meson.xml @@ -0,0 +1,85 @@ +<lexer> + <config> + <name>Meson</name> + <alias>meson</alias> + <alias>meson.build</alias> + <filename>meson.build</filename> + <filename>meson_options.txt</filename> + <mime_type>text/x-meson</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="#.*?$"> + <token type="Comment"/> + </rule> + <rule pattern="'''.*'''"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[1-9][0-9]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="0o[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0x[a-fA-F0-9]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule> + <include state="string"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="expr"/> + </rule> + <rule pattern="[a-zA-Z_][a-zA-Z_0-9]*"> + <token type="Name"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + </state> + <state name="string"> + <rule pattern="[']{3}([']{0,2}([^\\']|\\(.|\n)))*[']{3}"> + <token type="LiteralString"/> + </rule> + <rule pattern="'.*?(?<!\\)(\\\\)*?'"> + <token type="LiteralString"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(endforeach|continue|foreach|break|endif|else|elif|if)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="expr"> + <rule pattern="(in|and|or|not)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="(\*=|/=|%=|\+]=|-=|==|!=|\+|-|=)"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\]{}:().,?]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(false|true)\b"> + <token type="KeywordConstant"/> + </rule> + <rule> + <include state="builtins"/> + </rule> + <rule pattern="(target_machine|build_machine|host_machine|meson)\b"> + <token type="NameVariableMagic"/> + </rule> + </state> + <state name="builtins"> + <rule pattern="(?<!\.)(add_project_link_arguments|add_global_link_arguments|add_project_arguments|add_global_arguments|include_directories|configuration_data|declare_dependency|install_headers|both_libraries|install_subdir|add_test_setup|configure_file|static_library|shared_library|custom_target|add_languages|shared_module|set_variable|get_variable|find_library|find_program|build_target|install_data|environment|is_disabler|run_command|subdir_done|install_man|is_variable|subproject|dependency|join_paths|get_option|executable|generator|benchmark|disabler|project|message|library|summary|vcs_tag|warning|assert|subdir|range|files|error|test|jar)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<!\.)import\b"> + <token type="NameNamespace"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/metal.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/metal.xml new file mode 100644 index 0000000..62d04ba --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/metal.xml @@ -0,0 +1,270 @@ +<lexer> + <config> + <name>Metal</name> + <alias>metal</alias> + <filename>*.metal</filename> + <mime_type>text/x-metal</mime_type> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <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="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="(?<=\\)\n"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="if0"> + <rule pattern="^\s*#if.*?(?<!\\)\n"> + <token type="CommentPreproc"/> + <push/> + </rule> + <rule pattern="^\s*#el(?:se|if).*\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="^\s*#endif.*?(?<!\\)\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern=".*?\n"> + <token type="Comment"/> + </rule> + </state> + <state name="statements"> + <rule pattern="(namespace|constexpr|operator|template|using|this)\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="(\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]('?[0-9A-Fa-f]+)*)[LlUu]*"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0('?[0-7]+)+[LlUu]*"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[Bb][01]('?[01]+)*[LlUu]*"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="[0-9]('?[0-9]+)*[LlUu]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\*/"> + <token type="Error"/> + </rule> + <rule pattern="[~!%^&*+=|?:<>/-]"> + <token type="Operator"/> + </rule> + <rule pattern="[()\[\],.]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(continue|typedef|sizeof|extern|static|switch|struct|return|union|const|break|while|enum|else|case|for|do|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(bool|float|half|long|ptrdiff_t|size_t|unsigned|u?char|u?int((8|16|32|64)_t)?|u?short)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(bool|float|half|u?(char|int|long|short))(2|3|4)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="packed_(float|half|long|u?(char|int|short))(2|3|4)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(float|half)(2|3|4)x(2|3|4)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="atomic_u?int\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(rg?(8|16)(u|s)norm|rgba(8|16)(u|s)norm|srgba8unorm|rgb10a2|rg11b10f|rgb9e5)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(array|depth(2d|cube)(_array)?|depth2d_ms(_array)?|sampler|texture_buffer|texture(1|2)d(_array)?|texture2d_ms(_array)?|texture3d|texturecube(_array)?|uniform|visible_function_table)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(true|false|NULL)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(threadgroup_imageblock|threadgroup|constant|ray_data|device|thread)\b"> + <token type="Keyword"/> + </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="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="(fragment|kernel|vertex)?((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)"> + <bygroups> + <token type="Keyword"/> + <usingself state="root"/> + <token type="NameFunction"/> + <usingself state="root"/> + <usingself state="root"/> + <token type="Punctuation"/> + </bygroups> + <push state="function"/> + </rule> + <rule pattern="(fragment|kernel|vertex)?((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)"> + <bygroups> + <token type="Keyword"/> + <usingself state="root"/> + <token type="NameFunction"/> + <usingself state="root"/> + <usingself state="root"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule> + <push state="statement"/> + </rule> + </state> + <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*(?=[>{])"> + <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="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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/minizinc.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/minizinc.xml new file mode 100644 index 0000000..1ad6860 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/minizinc.xml @@ -0,0 +1,82 @@ +<lexer> + <config> + <name>MiniZinc</name> + <alias>minizinc</alias> + <alias>MZN</alias> + <alias>mzn</alias> + <filename>*.mzn</filename> + <filename>*.dzn</filename> + <filename>*.fzn</filename> + <mime_type>text/minizinc</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="\b(annotation|constraint|predicate|minimize|function|maximize|satisfy|include|record|output|solve|test|list|type|ann|par|any|var|op|of)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(string|tuple|float|array|bool|enum|int|set)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="\b(forall|where|endif|then|else|for|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(array_intersect|index_set_2of3|index_set_1of3|index_set_3of3|index_set_1of2|index_set_2of2|array_union|show_float|dom_array|int2float|set2array|index_set|dom_size|lb_array|is_fixed|ub_array|bool2int|show_int|array4d|array2d|array1d|array5d|array6d|array3d|product|length|assert|concat|trace|acosh|round|abort|log10|floor|sinh|tanh|atan|sqrt|asin|show|log2|card|ceil|cosh|join|pow|cos|max|log|exp|dom|sin|abs|fix|sum|tan|min|lb|ln|ub)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(not|<->|->|<-|\\/|xor|/\\)"> + <token type="Operator"/> + </rule> + <rule pattern="(<|>|<=|>=|==|=|!=)"> + <token type="Operator"/> + </rule> + <rule pattern="(\+|-|\*|/|div|mod)"> + <token type="Operator"/> + </rule> + <rule pattern="\b(intersect|superset|symdiff|subset|union|diff|in)\b"> + <token type="Operator"/> + </rule> + <rule pattern="(\\|\.\.|\+\+)"> + <token type="Operator"/> + </rule> + <rule pattern="[|()\[\]{},:;]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="([+-]?)\d+(\.(?!\.)\d*)?([eE][-+]?\d+)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="::\s*([^\W\d]\w*)(\s*\([^\)]*\))?"> + <token type="NameDecorator"/> + </rule> + <rule pattern="\b([^\W\d]\w*)\b(\()"> + <bygroups> + <token type="NameFunction"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="[^\W\d]\w*"> + <token type="NameOther"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mlir.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mlir.xml new file mode 100644 index 0000000..025c3dc --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mlir.xml @@ -0,0 +1,73 @@ +<lexer> + <config> + <name>MLIR</name> + <alias>mlir</alias> + <filename>*.mlir</filename> + <mime_type>text/x-mlir</mime_type> + </config> + <rules> + <state name="whitespace"> + <rule pattern="(\n|\s)+"> + <token type="Text"/> + </rule> + <rule pattern="//.*?\n"> + <token type="Comment"/> + </rule> + </state> + <state name="keyword"> + <rule pattern="(constant|return)"> + <token type="KeywordType"/> + </rule> + <rule pattern="(memref|tensor|vector|func|loc)"> + <token type="KeywordType"/> + </rule> + <rule pattern="bf16|f16|f32|f64|index"> + <token type="Keyword"/> + </rule> + <rule pattern="i[1-9]\d*"> + <token type="Keyword"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="c?"[^"]*?""> + <token type="LiteralString"/> + </rule> + <rule pattern="\^([-a-zA-Z$._][\w\-$.0-9]*)\s*"> + <token type="NameLabel"/> + </rule> + <rule pattern="([\w\d_$.]+)\s*="> + <token type="NameLabel"/> + </rule> + <rule> + <include state="keyword"/> + </rule> + <rule pattern="->"> + <token type="Punctuation"/> + </rule> + <rule pattern="@([\w_][\w\d_$.]*)"> + <token type="NameFunction"/> + </rule> + <rule pattern="[%#][\w\d_$.]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="([1-9?][\d?]*\s*x)+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="0[xX][a-fA-F0-9]+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[=<>{}\[\]()*.,!:]|x\b"> + <token type="Punctuation"/> + </rule> + <rule pattern="[\w\d]+"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/modula-2.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/modula-2.xml new file mode 100644 index 0000000..0bf37bc --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/modula-2.xml @@ -0,0 +1,245 @@ +<lexer> + <config> + <name>Modula-2</name> + <alias>modula2</alias> + <alias>m2</alias> + <filename>*.def</filename> + <filename>*.mod</filename> + <mime_type>text/x-modula2</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="dialecttags"> + <rule pattern="\(\*!m2pim\*\)"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="\(\*!m2iso\*\)"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="\(\*!m2r10\*\)"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="\(\*!objm2\*\)"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="\(\*!m2iso\+aglet\*\)"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="\(\*!m2pim\+gm2\*\)"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="\(\*!m2iso\+p1\*\)"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="\(\*!m2iso\+xds\*\)"> + <token type="CommentSpecial"/> + </rule> + </state> + <state name="unigraph_operators"> + <rule pattern="[+-]"> + <token type="Operator"/> + </rule> + <rule pattern="[*/]"> + <token type="Operator"/> + </rule> + <rule pattern="\\"> + <token type="Operator"/> + </rule> + <rule pattern="[=#<>]"> + <token type="Operator"/> + </rule> + <rule pattern="\^"> + <token type="Operator"/> + </rule> + <rule pattern="@"> + <token type="Operator"/> + </rule> + <rule pattern="&"> + <token type="Operator"/> + </rule> + <rule pattern="~"> + <token type="Operator"/> + </rule> + <rule pattern="`"> + <token type="Operator"/> + </rule> + </state> + <state name="string_literals"> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralString"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + </state> + <state name="identifiers"> + <rule pattern="([a-zA-Z_$][\w$]*)"> + <token type="Name"/> + </rule> + </state> + <state name="pragmas"> + <rule pattern="<\*.*?\*>"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\(\*\$.*?\*\)"> + <token type="CommentPreproc"/> + </rule> + </state> + <state name="comments"> + <rule pattern="^//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\(\*([^$].*?)\*\)"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="/\*(.*?)\*/"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\n+"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + <state name="suffixed_number_literals"> + <rule pattern="[0-7]+B"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="[0-7]+C"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="[0-9A-F]+H"> + <token type="LiteralNumberHex"/> + </rule> + </state> + <state name="plain_number_literals"> + <rule pattern="[0-9]+(\'[0-9]+)*\.[0-9]+(\'[0-9]+)*[eE][+-]?[0-9]+(\'[0-9]+)*"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+(\'[0-9]+)*\.[0-9]+(\'[0-9]+)*"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+(\'[0-9]+)*"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="digraph_punctuation"> + <rule pattern="\.\."> + <token type="Punctuation"/> + </rule> + <rule pattern="<<"> + <token type="Punctuation"/> + </rule> + <rule pattern=">>"> + <token type="Punctuation"/> + </rule> + <rule pattern="->"> + <token type="Punctuation"/> + </rule> + <rule pattern="\|#"> + <token type="Punctuation"/> + </rule> + <rule pattern="##"> + <token type="Punctuation"/> + </rule> + <rule pattern="\|\*"> + <token type="Punctuation"/> + </rule> + </state> + <state name="unigraph_punctuation"> + <rule pattern="[()\[\]{},.:;|]"> + <token type="Punctuation"/> + </rule> + <rule pattern="!"> + <token type="Punctuation"/> + </rule> + <rule pattern="\?"> + <token type="Punctuation"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="dialecttags"/> + </rule> + <rule> + <include state="pragmas"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule> + <include state="identifiers"/> + </rule> + <rule> + <include state="suffixed_number_literals"/> + </rule> + <rule> + <include state="prefixed_number_literals"/> + </rule> + <rule> + <include state="plain_number_literals"/> + </rule> + <rule> + <include state="string_literals"/> + </rule> + <rule> + <include state="digraph_punctuation"/> + </rule> + <rule> + <include state="digraph_operators"/> + </rule> + <rule> + <include state="unigraph_punctuation"/> + </rule> + <rule> + <include state="unigraph_operators"/> + </rule> + </state> + <state name="prefixed_number_literals"> + <rule pattern="0b[01]+(\'[01]+)*"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0[ux][0-9A-F]+(\'[0-9A-F]+)*"> + <token type="LiteralNumberHex"/> + </rule> + </state> + <state name="digraph_operators"> + <rule pattern="\*\."> + <token type="Operator"/> + </rule> + <rule pattern="\+>"> + <token type="Operator"/> + </rule> + <rule pattern="<>"> + <token type="Operator"/> + </rule> + <rule pattern="<="> + <token type="Operator"/> + </rule> + <rule pattern=">="> + <token type="Operator"/> + </rule> + <rule pattern="=="> + <token type="Operator"/> + </rule> + <rule pattern="::"> + <token type="Operator"/> + </rule> + <rule pattern=":="> + <token type="Operator"/> + </rule> + <rule pattern="\+\+"> + <token type="Operator"/> + </rule> + <rule pattern="--"> + <token type="Operator"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/monkeyc.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/monkeyc.xml new file mode 100644 index 0000000..7445a63 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/monkeyc.xml @@ -0,0 +1,153 @@ +<lexer> + <config> + <name>MonkeyC</name> + <alias>monkeyc</alias> + <filename>*.mc</filename> + <mime_type>text/x-monkeyc</mime_type> + </config> + <rules> + <state name="class"> + <rule pattern="([a-zA-Z_][\w_\.]*)(?:(\s+)(extends)(\s+)([a-zA-Z_][\w_\.]*))?"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="function"> + <rule pattern="initialize"> + <token type="NameFunctionMagic"/> + </rule> + <rule pattern="[a-zA-Z_][\w_\.]*"> + <token type="NameFunction"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="module"> + <rule pattern="[a-zA-Z_][\w_\.]*"> + <token type="NameNamespace"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="[^\S\n]+"> + <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> + <rule pattern=":[a-zA-Z_][\w_\.]*"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="[{}\[\]\(\),;:\.]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[&~\|\^!+\-*\/%=?]"> + <token type="Operator"/> + </rule> + <rule pattern="=>|[+-]=|&&|\|\||>>|<<|[<>]=?|[!=]="> + <token type="Operator"/> + </rule> + <rule pattern="\b(and|or|instanceof|has|extends|new)"> + <token type="OperatorWord"/> + </rule> + <rule pattern="(false|null|true|NaN)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(using)((?:\s|\\\\s)+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="import"/> + </rule> + <rule pattern="(class)((?:\s|\\\\s)+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + </bygroups> + <push state="class"/> + </rule> + <rule pattern="(function)((?:\s|\\\\s)+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + </bygroups> + <push state="function"/> + </rule> + <rule pattern="(module)((?:\s|\\\\s)+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + </bygroups> + <push state="module"/> + </rule> + <rule pattern="\b(if|else|for|switch|case|while|break|continue|default|do|try|catch|finally|return|throw|extends|function)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(const|enum|hidden|public|protected|private|static)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="\bvar\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="\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"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\b(me|self|\$)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^''])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="-?(0x[0-9a-fA-F]+l?)"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="-?([0-9]+(\.[0-9]+[df]?|[df]))\b"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?([0-9]+l?)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="import"> + <rule pattern="([a-zA-Z_][\w_\.]*)(?:(\s+)(as)(\s+)([a-zA-Z_][\w_]*))?"> + <bygroups> + <token type="NameNamespace"/> + <token type="Text"/> + <token type="KeywordNamespace"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/morrowindscript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/morrowindscript.xml new file mode 100644 index 0000000..724a19f --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/morrowindscript.xml @@ -0,0 +1,90 @@ +<lexer> + <config> + <name>MorrowindScript</name> + <alias>morrowind</alias> + <alias>mwscript</alias> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern=";.*$"> + <token type="Comment"/> + </rule> + <rule pattern="(["'])(?:(?=(\\?))\2.)*?\1"> + <token type="LiteralString"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[0-9]+\.[0-9]*(?!\.)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="types"/> + </rule> + <rule> + <include state="builtins"/> + </rule> + <rule> + <include state="punct"/> + </rule> + <rule> + <include state="operators"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\S+\s+"> + <token type="Text"/> + </rule> + <rule pattern="[a-zA-Z0-9_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(?i)(begin|if|else|elseif|endif|while|endwhile|return|to)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(?i)(end)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(?i)(end)\w+.*$"> + <token type="Text"/> + </rule> + <rule pattern="[\w+]->[\w+]"> + <token type="Operator"/> + </rule> + </state> + <state name="builtins"> + <rule pattern="(?i)(Activate|AddItem|AddSoulGem|AddSpell|AddToLevCreature|AddToLevItem|AddTopic|AIActivate|AIEscort|AIEscortCell|AIFollow|AiFollowCell|AITravel|AIWander|BecomeWerewolf|Cast|ChangeWeather|Choice|ClearForceJump|ClearForceMoveJump|ClearForceRun|ClearForceSneak|ClearInfoActor|Disable|DisableLevitation|DisablePlayerControls|DisablePlayerFighting|DisablePlayerJumping|DisablePlayerLooking|DisablePlayerMagic|DisablePlayerViewSwitch|DisableTeleporting|DisableVanityMode|DontSaveObject|Drop|Enable|EnableBirthMenu|EnableClassMenu|EnableInventoryMenu|EnableLevelUpMenu|EnableLevitation|EnableMagicMenu|EnableMapMenu|EnableNameMenu|EnablePlayerControls|EnablePlayerFighting|EnablePlayerJumping|EnablePlayerLooking|EnablePlayerMagic|EnablePlayerViewSwitch|EnableRaceMenu|EnableRest|EnableStatsMenu|EnableTeleporting|EnableVanityMode|Equip|ExplodeSpell|Face|FadeIn|FadeOut|FadeTo|Fall|ForceGreeting|ForceJump|ForceRun|ForceSneak|Flee|GotoJail|HurtCollidingActor|HurtStandingActor|Journal|Lock|LoopGroup|LowerRank|MenuTest|MessageBox|ModAcrobatics|ModAgility|ModAlarm|ModAlchemy|ModAlteration|ModArmorBonus|ModArmorer|ModAthletics|ModAttackBonus|ModAxe|ModBlock|ModBluntWeapon|ModCastPenalty|ModChameleon|ModConjuration|ModCurrentFatigue|ModCurrentHealth|ModCurrentMagicka|ModDefendBonus|ModDestruction|ModDisposition|ModEnchant|ModEndurance|ModFactionReaction|ModFatigue|ModFight|ModFlee|ModFlying|ModHandToHand|ModHealth|ModHeavyArmor|ModIllusion|ModIntelligence|ModInvisible|ModLightArmor|ModLongBlade|ModLuck|ModMagicka|ModMarksman|ModMediumArmor|ModMercantile|ModMysticism|ModParalysis|ModPCCrimeLevel|ModPCFacRep|ModPersonality|ModRegion|ModReputation|ModResistBlight|ModResistCorprus|ModResistDisease|ModResistFire|ModResistFrost|ModResistMagicka|ModResistNormalWeapons|ModResistParalysis|ModResistPoison|ModResistShock|ModRestoration|ModScale|ModSecurity|ModShortBlade|ModSilence|ModSneak|ModSpear|ModSpeechcraft|ModSpeed|ModStrength|ModSuperJump|ModSwimSpeed|ModUnarmored|ModWaterBreathing|ModWaterLevel|ModWaterWalking|ModWillpower|Move|MoveWorld|PayFine|PayFineThief|PCClearExpelled|PCExpell|PCForce1stPerson|PCForce3rdPerson|PCJoinFaction|PCLowerRank|PCRaiseRank|PlaceAtMe|PlaceAtPC|PlaceItem|PlaceItemCell|PlayBink|PlayGroup|PlayLoopSound3D|PlayLoopSound3DVP|PlaySound|PlaySound3D|PlaySound3DVP|PlaySoundVP|Position|PositionCell|RaiseRank|RemoveEffects|RemoveFromLevCreature|RemoveFromLevItem|RemoveItem|RemoveSoulgem|RemoveSpell|RemoveSpellEffects|ResetActors|Resurrect|Rotate|RotateWorld|Say|StartScript|[S|s]et|SetAcrobatics|SetAgility|SetAlarm|SetAlchemy|SetAlteration|SetAngle|SetArmorBonus|SetArmorer|SetAthletics|SetAtStart|SetAttackBonus|SetAxe|SetBlock|SetBluntWeapon|SetCastPenalty|SetChameleon|SetConjuration|SetDelete|SetDefendBonus|SetDestruction|SetDisposition|SetEnchant|SetEndurance|SetFactionReaction|SetFatigue|SetFight|SetFlee|SetFlying|SetHandToHand|SetHealth|SetHeavyArmor|SetIllusion|SetIntelligence|SetInvisible|SetJournalIndex|SetLightArmor|SetLevel|SetLongBlade|SetLuck|SetMagicka|SetMarksman|SetMediumArmor|SetMercantile|SetMysticism|SetParalysis|SetPCCCrimeLevel|SetPCFacRep|SetPersonality|SetPos|SetReputation|SetResistBlight|SetResistCorprus|SetResistDisease|SetResistFire|SetResistFrost|SetResistMagicka|SetResistNormalWeapons|SetResistParalysis|SetResistPoison|SetResistShock|SetRestoration|SetScale|SetSecurity|SetShortBlade|SetSilence|SetSneak|SetSpear|SetSpeechcraft|SetSpeed|SetStrength|SetSuperJump|SetSwimSpeed|SetUnarmored|SetWaterBreathing|SetWaterlevel|SetWaterWalking|SetWerewolfAcrobatics|SetWillpower|ShowMap|ShowRestMenu|SkipAnim|StartCombat|StopCombat|StopScript|StopSound|StreamMusic|TurnMoonRed|TurnMoonWhite|UndoWerewolf|Unlock|WakeUpPC|CenterOnCell|CenterOnExterior|FillMap|FixMe|ToggleAI|ToggleCollision|ToggleFogOfWar|ToggleGodMode|ToggleMenus|ToggleSky|ToggleWorld|ToggleVanityMode|CellChanged|GetAcrobatics|GetAgility|GetAIPackageDone|GetAlarm|GetAlchemy|GetAlteration|GetAngle|GetArmorBonus|GetArmorer|GetAthletics|GetAttackBonus|GetAttacked|GetArmorType,|GetAxe|GetBlightDisease|GetBlock|GetBluntWeapon|GetButtonPressed|GetCastPenalty|GetChameleon|GetCollidingActor|GetCollidingPC|GetCommonDisease|GetConjuration|GetCurrentAIPackage|GetCurrentTime|GetCurrentWeather|GetDeadCount|GetDefendBonus|GetDestruction|GetDetected|GetDisabled|GetDisposition|GetDistance|GetEffect|GetEnchant|GetEndurance|GetFatigue|GetFight|GetFlee|GetFlying|GetForceJump|GetForceRun|GetForceSneak|GetHandToHand|GetHealth|GetHealthGetRatio|GetHeavyArmor|GetIllusion|GetIntelligence|GetInterior|GetInvisible|GetItemCount|GetJournalIndex|GetLightArmor|GetLineOfSight|GetLOS|GetLevel|GetLocked|GetLongBlade|GetLuck|GetMagicka|GetMarksman|GetMasserPhase|GetSecundaPhase|GetMediumArmor|GetMercantile|GetMysticism|GetParalysis|GetPCCell|GetPCCrimeLevel|GetPCinJail|GetPCJumping|GetPCRank|GetPCRunning|GetPCSleep|GetPCSneaking|GetPCTraveling|GetPersonality|GetPlayerControlsDisabled|GetPlayerFightingDisabled|GetPlayerJumpingDisabled|GetPlayerLookingDisabled|GetPlayerMagicDisabled|GetPos|GetRace|GetReputation|GetResistBlight|GetResistCorprus|GetResistDisease|GetResistFire|GetResistFrost|GetResistMagicka|GetResistNormalWeapons|GetResistParalysis|GetResistPoison|GetResistShock|GetRestoration|GetScale|GetSecondsPassed|GetSecurity|GetShortBlade|GetSilence|GetSneak|GetSoundPlaying|GetSpear|GetSpeechcraft|GetSpeed|GetSpell|GetSpellEffects|GetSpellReadied|GetSquareRoot|GetStandingActor|GetStandingPC|GetStrength|GetSuperJump|GetSwimSpeed|GetTarget|GetUnarmored|GetVanityModeDisabled|GetWaterBreathing|GetWaterLevel|GetWaterWalking|GetWeaponDrawn|GetWeaponType|GetWerewolfKills|GetWillpower|GetWindSpeed|HasItemEquipped|HasSoulgem|HitAttemptOnMe|HitOnMe|IsWerewolf|MenuMode|OnActivate|OnDeath|OnKnockout|OnMurder|PCExpelled|PCGet3rdPerson|PCKnownWerewolf|Random|RepairedOnMe|SameFaction|SayDone|ScriptRunning|AllowWereWolfForceGreeting|Companion|MinimumProfit|NoFlee|NoHello|NoIdle|NoLore|OnPCAdd|OnPCDrop|OnPCEquip|OnPCHitMe|OnPCRepair|PCSkipEquip|OnPCSoulGemUse|StayOutside|CrimeGoldDiscount|CrimeGoldTurnIn|Day|DaysPassed|GameHour|Month|NPCVoiceDistance|PCRace|PCWerewolf|PCVampire|TimeScale|VampClan|Year)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?i)(sEffectWaterBreathing|sEffectSwiftSwim|sEffectWaterWalking|sEffectShield|sEffectFireShield|sEffectLightningShield|sEffectFrostShield|sEffectBurden|sEffectFeather|sEffectJump|sEffectLevitate|sEffectSlowFall|sEffectLock|sEffectOpen|sEffectFireDamage|sEffectShockDamage|sEffectFrostDamage|sEffectDrainAttribute|sEffectDrainHealth|sEffectDrainSpellpoints|sEffectDrainFatigue|sEffectDrainSkill|sEffectDamageAttribute|sEffectDamageHealth|sEffectDamageMagicka|sEffectDamageFatigue|sEffectDamageSkill|sEffectPoison|sEffectWeaknessToFire|sEffectWeaknessToFrost|sEffectWeaknessToShock|sEffectWeaknessToMagicka|sEffectWeaknessToCommonDisease|sEffectWeaknessToBlightDisease|sEffectWeaknessToCorprusDisease|sEffectWeaknessToPoison|sEffectWeaknessToNormalWeapons|sEffectDisintegrateWeapon|sEffectDisintegrateArmor|sEffectInvisibility|sEffectChameleon|sEffectLight|sEffectSanctuary|sEffectNightEye|sEffectCharm|sEffectParalyze|sEffectSilence|sEffectBlind|sEffectSound|sEffectCalmHumanoid|sEffectCalmCreature|sEffectFrenzyHumanoid|sEffectFrenzyCreature|sEffectDemoralizeHumanoid|sEffectDemoralizeCreature|sEffectRallyHumanoid|sEffectRallyCreature|sEffectDispel|sEffectSoultrap|sEffectTelekinesis|sEffectMark|sEffectRecall|sEffectDivineIntervention|sEffectAlmsiviIntervention|sEffectDetectAnimal|sEffectDetectEnchantment|sEffectDetectKey|sEffectSpellAbsorption|sEffectReflect|sEffectCureCommonDisease|sEffectCureBlightDisease|sEffectCureCorprusDisease|sEffectCurePoison|sEffectCureParalyzation|sEffectRestoreAttribute|sEffectRestoreHealth|sEffectRestoreSpellPoints|sEffectRestoreFatigue|sEffectRestoreSkill|sEffectFortifyAttribute|sEffectFortifyHealth|sEffectFortifySpellpoints|sEffectFortifyFatigue|sEffectFortifySkill|sEffectFortifyMagickaMultiplier|sEffectAbsorbAttribute|sEffectAbsorbHealth|sEffectAbsorbSpellPoints|sEffectAbsorbFatigue|sEffectAbsorbSkill|sEffectResistFire|sEffectResistFrost|sEffectResistShock|sEffectResistMagicka|sEffectResistCommonDisease|sEffectResistBlightDisease|sEffectResistCorprusDisease|sEffectResistPoison|sEffectResistNormalWeapons|sEffectResistParalysis|sEffectRemoveCurse|sEffectTurnUndead|sEffectSummonScamp|sEffectSummonClannfear|sEffectSummonDaedroth|sEffectSummonDremora|sEffectSummonAncestralGhost|sEffectSummonSkeletalMinion|sEffectSummonLeastBonewalker|sEffectSummonGreaterBonewalker|sEffectSummonBonelord|sEffectSummonWingedTwilight|sEffectSummonHunger|sEffectSummonGoldensaint|sEffectSummonFlameAtronach|sEffectSummonFrostAtronach|sEffectSummonStormAtronach|sEffectFortifyAttackBonus|sEffectCommandCreatures|sEffectCommandHumanoids|sEffectBoundDagger|sEffectBoundLongsword|sEffectBoundMace|sEffectBoundBattleAxe|sEffectBoundSpear|sEffectBoundLongbow|sEffectExtraSpell|sEffectBoundCuirass|sEffectBoundHelm|sEffectBoundBoots|sEffectBoundShield|sEffectBoundGloves|sEffectCorpus|sEffectVampirism|sEffectSummonCenturionSphere|sEffectSunDamage|sEffectStuntedMagicka)"> + <token type="NameBuiltin"/> + </rule> + </state> + <state name="types"> + <rule pattern="(?i)(short|long|float)\b"> + <token type="KeywordType"/> + </rule> + </state> + <state name="punct"> + <rule pattern="[()]"> + <token type="Punctuation"/> + </rule> + </state> + <state name="operators"> + <rule pattern="[#=,./%+\-?]"> + <token type="Operator"/> + </rule> + <rule pattern="(==|<=|<|>=|>|!=)"> + <token type="Operator"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mysql.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mysql.xml new file mode 100644 index 0000000..b6c2046 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/mysql.xml @@ -0,0 +1,121 @@ +<lexer> + <config> + <name>MySQL</name> + <alias>mysql</alias> + <alias>mariadb</alias> + <filename>*.sql</filename> + <mime_type>text/x-mysql</mime_type> + <mime_type>text/x-mariadb</mime_type> + <case_insensitive>true</case_insensitive> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="string"> + <rule pattern="[^']+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="''"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + </state> + <state name="double-string"> + <rule pattern="[^"]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="(#|--\s+).*\n?"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="multiline-comments"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[0-9]*\.[0-9]+(e[+-][0-9]+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="((?:_[a-z0-9]+)?)(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="((?:_[a-z0-9]+)?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <push state="double-string"/> + </rule> + <rule pattern="[+*/<>=~!@#%^&|`?-]"> + <token type="Operator"/> + </rule> + <rule pattern="\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> + <token type="KeywordType"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="\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"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(auto_increment|engine|charset|tables)\b"> + <token type="KeywordPseudo"/> + </rule> + <rule pattern="(true|false|null)"> + <token type="NameConstant"/> + </rule> + <rule pattern="([a-z_]\w*)(\s*)(\()"> + <bygroups> + <token type="NameFunction"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="[a-z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="@[a-z0-9]*[._]*[a-z0-9]*"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nasm.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nasm.xml new file mode 100644 index 0000000..a6107b5 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nasm.xml @@ -0,0 +1,124 @@ +<lexer> + <config> + <name>NASM</name> + <alias>nasm</alias> + <filename>*.asm</filename> + <filename>*.ASM</filename> + <mime_type>text/x-nasm</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="punctuation"> + <rule pattern="[,():\[\]]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="[&|^<>+*/%~-]+"> + <token type="Operator"/> + </rule> + <rule pattern="[$]+"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="seg|wrt|strict"> + <token type="OperatorWord"/> + </rule> + <rule pattern="byte|[dq]?word"> + <token type="KeywordType"/> + </rule> + </state> + <state name="root"> + <rule pattern="^\s*%"> + <token type="CommentPreproc"/> + <push state="preproc"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="[a-z$._?][\w$.?#@~]*:"> + <token type="NameLabel"/> + </rule> + <rule pattern="([a-z$._?][\w$.?#@~]*)(\s+)(equ)"> + <bygroups> + <token type="NameConstant"/> + <token type="KeywordDeclaration"/> + <token type="KeywordDeclaration"/> + </bygroups> + <push state="instruction-args"/> + </rule> + <rule pattern="BITS|USE16|USE32|SECTION|SEGMENT|ABSOLUTE|EXTERN|GLOBAL|ORG|ALIGN|STRUC|ENDSTRUC|COMMON|CPU|GROUP|UPPERCASE|IMPORT|EXPORT|LIBRARY|MODULE"> + <token type="Keyword"/> + <push state="instruction-args"/> + </rule> + <rule pattern="(?:res|d)[bwdqt]|times"> + <token type="KeywordDeclaration"/> + <push state="instruction-args"/> + </rule> + <rule pattern="[a-z$._?][\w$.?#@~]*"> + <token type="NameFunction"/> + <push state="instruction-args"/> + </rule> + <rule pattern="[\r\n]+"> + <token type="Text"/> + </rule> + </state> + <state name="instruction-args"> + <rule pattern=""(\\"|[^"\n])*"|'(\\'|[^'\n])*'|`(\\`|[^`\n])*`"> + <token type="LiteralString"/> + </rule> + <rule pattern="(?:0x[0-9a-f]+|$0[0-9a-f]*|[0-9]+[0-9a-f]*h)"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-7]+q"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="[01]+b"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="[0-9]+\.e?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule pattern="r[0-9][0-5]?[bwd]|[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[a-z$._?][\w$.?#@~]*"> + <token type="NameVariable"/> + </rule> + <rule pattern="[\r\n]+"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + </state> + <state name="preproc"> + <rule pattern="[^;\n]+"> + <token type="CommentPreproc"/> + </rule> + <rule pattern=";.*?\n"> + <token type="CommentSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern=";.*"> + <token type="CommentSingle"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/newspeak.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/newspeak.xml new file mode 100644 index 0000000..b932657 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/newspeak.xml @@ -0,0 +1,121 @@ +<lexer> + <config> + <name>Newspeak</name> + <alias>newspeak</alias> + <filename>*.ns2</filename> + <mime_type>text/x-newspeak</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\b(Newsqueak2)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="'[^']*'"> + <token type="LiteralString"/> + </rule> + <rule pattern="\b(class)(\s+)(\w+)(\s*)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameClass"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="\b(mixin|self|super|private|public|protected|nil|true|false)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(\w+\:)(\s*)([a-zA-Z_]\w+)"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="(\w+)(\s*)(=)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="<\w+>"> + <token type="CommentSpecial"/> + </rule> + <rule> + <include state="expressionstat"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + </state> + <state name="expressionstat"> + <rule pattern="(\d+\.\d*|\.\d+|\d+[fF])[fF]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern=":\w+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(\w+)(::)"> + <bygroups> + <token type="NameVariable"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="\w+:"> + <token type="NameFunction"/> + </rule> + <rule pattern="\w+"> + <token type="NameVariable"/> + </rule> + <rule pattern="\(|\)"> + <token type="Punctuation"/> + </rule> + <rule pattern="\[|\]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\{|\}"> + <token type="Punctuation"/> + </rule> + <rule pattern="(\^|\+|\/|~|\*|<|>|=|@|%|\||&|\?|!|,|-|:)"> + <token type="Operator"/> + </rule> + <rule pattern="\.|;"> + <token type="Punctuation"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="literals"/> + </rule> + </state> + <state name="literals"> + <rule pattern="\$."> + <token type="LiteralString"/> + </rule> + <rule pattern="'[^']*'"> + <token type="LiteralString"/> + </rule> + <rule pattern="#'[^']*'"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="#\w+:?"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="#(\+|\/|~|\*|<|>|=|@|%|\||&|\?|!|,|-)+"> + <token type="LiteralStringSymbol"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern=""[^"]*""> + <token type="Comment"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nginx.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nginx.xml new file mode 100644 index 0000000..46bdf57 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nginx.xml @@ -0,0 +1,98 @@ +<lexer> + <config> + <name>Nginx configuration file</name> + <alias>nginx</alias> + <filename>nginx.conf</filename> + <mime_type>text/x-nginx-conf</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="(include)(\s+)([^\s;]+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Name"/> + </bygroups> + </rule> + <rule pattern="[^\s;#]+"> + <token type="Keyword"/> + <push state="stmt"/> + </rule> + <rule> + <include state="base"/> + </rule> + </state> + <state name="block"> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="2"/> + </rule> + <rule pattern="[^\s;#]+"> + <token type="KeywordNamespace"/> + <push state="stmt"/> + </rule> + <rule> + <include state="base"/> + </rule> + </state> + <state name="stmt"> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="block"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="base"/> + </rule> + </state> + <state name="base"> + <rule pattern="#.*\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="on|off"> + <token type="NameConstant"/> + </rule> + <rule pattern="\$[^\s;#()]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="([a-z0-9.-]+)(:)([0-9]+)"> + <bygroups> + <token type="Name"/> + <token type="Punctuation"/> + <token type="LiteralNumberInteger"/> + </bygroups> + </rule> + <rule pattern="[a-z-]+/[a-z-+]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="[0-9]+[km]?\b"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(~)(\s*)([^\s{]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <token type="LiteralStringRegex"/> + </bygroups> + </rule> + <rule pattern="[:=~]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[^\s;#{}$]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="/[^\s;#]*"> + <token type="Name"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[$;]"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nim.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nim.xml new file mode 100644 index 0000000..a1bfcf7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nim.xml @@ -0,0 +1,207 @@ +<lexer> + <config> + <name>Nim</name> + <alias>nim</alias> + <alias>nimrod</alias> + <filename>*.nim</filename> + <filename>*.nimrod</filename> + <mime_type>text/x-nim</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="dqs"> + <rule pattern="\\([\\abcefnrtvl"\']|\n|x[a-f0-9]{2}|[0-9]{1,3})"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings"/> + </rule> + </state> + <state name="tdqs"> + <rule pattern=""""(?!")"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings"/> + </rule> + <rule> + <include state="nl"/> + </rule> + </state> + <state name="funcname"> + <rule pattern="((?![\d_])\w)(((?!_)\w)|(_(?!_)\w))*"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule pattern="`.+`"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + </state> + <state name="int-suffix"> + <rule pattern="\'i(32|64)"> + <token type="LiteralNumberIntegerLong"/> + </rule> + <rule pattern="\'i(8|16)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="float-suffix"> + <rule pattern="\'f(32|64)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="strings"> + <rule pattern="(?<!\$)\$(\d+|#|\w+)+"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^\\\'"$\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralString"/> + </rule> + <rule pattern="\$"> + <token type="LiteralString"/> + </rule> + </state> + <state name="nl"> + <rule pattern="\n"> + <token type="LiteralString"/> + </rule> + </state> + <state name="chars"> + <rule pattern="\\([\\abcefnrtvl"\']|x[a-f0-9]{2}|[0-9]{1,3})"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringChar"/> + <pop depth="1"/> + </rule> + <rule pattern="."> + <token type="LiteralStringChar"/> + </rule> + </state> + <state name="rdqs"> + <rule pattern=""(?!")"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern=""""> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings"/> + </rule> + </state> + <state name="float-number"> + <rule pattern="\.(?!\.)[0-9_]*"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="e[+-]?[0-9][0-9_]*"> + <token type="LiteralNumberFloat"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="#\[[\s\S]*?\]#"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="##.*$"> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="[*=><+\-/@$~&%!?|\\\[\]]"> + <token type="Operator"/> + </rule> + <rule pattern="\.\.|\.|,|\[\.|\.\]|\{\.|\.\}|\(\.|\.\)|\{|\}|\(|\)|:|\^|`|;"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?:[\w]+)""> + <token type="LiteralString"/> + <push state="rdqs"/> + </rule> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="tdqs"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="dqs"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringChar"/> + <push state="chars"/> + </rule> + <rule pattern="(a_?n_?d_?|o_?r_?|n_?o_?t_?|x_?o_?r_?|s_?h_?l_?|s_?h_?r_?|d_?i_?v_?|m_?o_?d_?|i_?n_?|n_?o_?t_?i_?n_?|i_?s_?|i_?s_?n_?o_?t_?)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="(p_?r_?o_?c_?\s)(?![(\[\]])"> + <token type="Keyword"/> + <push state="funcname"/> + </rule> + <rule pattern="(a_?d_?d_?r_?|a_?n_?d_?|a_?s_?|a_?s_?m_?|a_?t_?o_?m_?i_?c_?|b_?i_?n_?d_?|b_?l_?o_?c_?k_?|b_?r_?e_?a_?k_?|c_?a_?s_?e_?|c_?a_?s_?t_?|c_?o_?n_?c_?e_?p_?t_?|c_?o_?n_?s_?t_?|c_?o_?n_?t_?i_?n_?u_?e_?|c_?o_?n_?v_?e_?r_?t_?e_?r_?|d_?e_?f_?e_?r_?|d_?i_?s_?c_?a_?r_?d_?|d_?i_?s_?t_?i_?n_?c_?t_?|d_?i_?v_?|d_?o_?|e_?l_?i_?f_?|e_?l_?s_?e_?|e_?n_?d_?|e_?n_?u_?m_?|e_?x_?c_?e_?p_?t_?|e_?x_?p_?o_?r_?t_?|f_?i_?n_?a_?l_?l_?y_?|f_?o_?r_?|f_?u_?n_?c_?|i_?f_?|i_?n_?|y_?i_?e_?l_?d_?|i_?n_?t_?e_?r_?f_?a_?c_?e_?|i_?s_?|i_?s_?n_?o_?t_?|i_?t_?e_?r_?a_?t_?o_?r_?|l_?e_?t_?|m_?a_?c_?r_?o_?|m_?e_?t_?h_?o_?d_?|m_?i_?x_?i_?n_?|m_?o_?d_?|n_?o_?t_?|n_?o_?t_?i_?n_?|o_?b_?j_?e_?c_?t_?|o_?f_?|o_?r_?|o_?u_?t_?|p_?r_?o_?c_?|p_?t_?r_?|r_?a_?i_?s_?e_?|r_?e_?f_?|r_?e_?t_?u_?r_?n_?|s_?h_?a_?r_?e_?d_?|s_?h_?l_?|s_?h_?r_?|s_?t_?a_?t_?i_?c_?|t_?e_?m_?p_?l_?a_?t_?e_?|t_?r_?y_?|t_?u_?p_?l_?e_?|t_?y_?p_?e_?|w_?h_?e_?n_?|w_?h_?i_?l_?e_?|w_?i_?t_?h_?|w_?i_?t_?h_?o_?u_?t_?|x_?o_?r_?)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(f_?r_?o_?m_?|i_?m_?p_?o_?r_?t_?|i_?n_?c_?l_?u_?d_?e_?)\b"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="(v_?a_?r)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(i_?n_?t_?|i_?n_?t_?8_?|i_?n_?t_?1_?6_?|i_?n_?t_?3_?2_?|i_?n_?t_?6_?4_?|f_?l_?o_?a_?t_?|f_?l_?o_?a_?t_?3_?2_?|f_?l_?o_?a_?t_?6_?4_?|b_?o_?o_?l_?|c_?h_?a_?r_?|r_?a_?n_?g_?e_?|a_?r_?r_?a_?y_?|s_?e_?q_?|s_?e_?t_?|s_?t_?r_?i_?n_?g_?)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(n_?i_?l_?|t_?r_?u_?e_?|f_?a_?l_?s_?e_?)\b"> + <token type="KeywordPseudo"/> + </rule> + <rule pattern="\b_\b"> + <token type="Name"/> + </rule> + <rule pattern="\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*"> + <token type="Name"/> + </rule> + <rule pattern="[0-9][0-9_]*(?=([e.]|\'f(32|64)))"> + <token type="LiteralNumberFloat"/> + <push state="float-suffix" state="float-number"/> + </rule> + <rule pattern="0x[a-f0-9][a-f0-9_]*"> + <token type="LiteralNumberHex"/> + <push state="int-suffix"/> + </rule> + <rule pattern="0b[01][01_]*"> + <token type="LiteralNumberBin"/> + <push state="int-suffix"/> + </rule> + <rule pattern="0o[0-7][0-7_]*"> + <token type="LiteralNumberOct"/> + <push state="int-suffix"/> + </rule> + <rule pattern="[0-9][0-9_]*"> + <token type="LiteralNumberInteger"/> + <push state="int-suffix"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern=".+$"> + <token type="Error"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nix.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nix.xml new file mode 100644 index 0000000..0ed040c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/nix.xml @@ -0,0 +1,258 @@ +<lexer> + <config> + <name>Nix</name> + <alias>nixos</alias> + <alias>nix</alias> + <filename>*.nix</filename> + <mime_type>text/x-nix</mime_type> + </config> + <rules> + <state name="space"> + <rule pattern="[ \t\r\n]+"> + <token type="Text"/> + </rule> + </state> + <state name="paren"> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="scope"> + <rule pattern="}:"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="in(?![a-zA-Z0-9_'-])"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule pattern="\${"> + <token type="LiteralStringInterpol"/> + <push state="interpol"/> + </rule> + <rule> + <include state="root"/> + </rule> + <rule pattern="(=|\?|,)"> + <token type="Operator"/> + </rule> + </state> + <state name="builtins"> + <rule pattern="throw(?![a-zA-Z0-9_'-])"> + <token type="NameException"/> + </rule> + <rule pattern="(dependencyClosure|fetchTarball|filterSource|currentTime|removeAttrs|baseNameOf|derivation|toString|builtins|getAttr|hasAttr|getEnv|isNull|abort|dirOf|toXML|map)(?![a-zA-Z0-9_'-])"> + <token type="NameBuiltin"/> + </rule> + </state> + <state name="literals"> + <rule pattern="(false|true|null)(?![a-zA-Z0-9_'-])"> + <token type="NameConstant"/> + </rule> + <rule> + <include state="uri"/> + </rule> + <rule> + <include state="path"/> + </rule> + <rule> + <include state="int"/> + </rule> + <rule> + <include state="float"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="import(?![a-zA-Z0-9_'-])"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="(inherit|assert|with|then|else|rec|if)(?![a-zA-Z0-9_'-])"> + <token type="Keyword"/> + </rule> + </state> + <state name="list"> + <rule pattern="\]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="operators"> + <rule pattern=" [/-] "> + <token type="Operator"/> + </rule> + <rule pattern="(\.)(\${)"> + <bygroups> + <token type="Operator"/> + <token type="LiteralStringInterpol"/> + </bygroups> + <push state="interpol"/> + </rule> + <rule pattern="(\?)(\s*)(\${)"> + <bygroups> + <token type="Operator"/> + <token type="Text"/> + <token type="LiteralStringInterpol"/> + </bygroups> + <push state="interpol"/> + </rule> + <rule pattern="(&&|>=|<=|\+\+|->|!=|\|\||//|==|@|!|\+|\?|<|\.|>|\*)"> + <token type="Operator"/> + </rule> + <rule pattern="[;:]"> + <token type="Punctuation"/> + </rule> + </state> + <state name="comment"> + <rule pattern="\*/"> + <token type="CommentMultiline"/> + <pop depth="1"/> + </rule> + <rule pattern=".|\n"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="interpol"> + <rule pattern="}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="path"> + <rule pattern="[a-zA-Z0-9._+-]*(/[a-zA-Z0-9._+-]+)+"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="~(/[a-zA-Z0-9._+-]+)+/?"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="<[a-zA-Z0-9._+-]+(/[a-zA-Z0-9._+-]+)*>"> + <token type="LiteralStringRegex"/> + </rule> + </state> + <state name="float"> + <rule pattern="-?(([1-9][0-9]*\.[0-9]*)|(0?\.[0-9]+))([Ee][+-]?[0-9]+)?(?![a-zA-Z0-9_'-])"> + <token type="LiteralNumberFloat"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="builtins"/> + </rule> + <rule> + <include state="literals"/> + </rule> + <rule> + <include state="operators"/> + </rule> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="paren"/> + </rule> + <rule pattern="\["> + <token type="Punctuation"/> + <push state="list"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="qstring"/> + </rule> + <rule pattern="''"> + <token type="LiteralStringSingle"/> + <push state="istring"/> + </rule> + <rule pattern="{"> + <token type="Punctuation"/> + <push state="scope"/> + </rule> + <rule pattern="let(?![a-zA-Z0-9_'-])"> + <token type="Keyword"/> + <push state="scope"/> + </rule> + <rule> + <include state="id"/> + </rule> + <rule> + <include state="space"/> + </rule> + </state> + <state name="int"> + <rule pattern="-?[0-9]+(?![a-zA-Z0-9_'-])"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="uri"> + <rule pattern="[a-zA-Z][a-zA-Z0-9+.-]*:[a-zA-Z0-9%/?:@&=+$,_.!~*'-]+"> + <token type="LiteralStringDoc"/> + </rule> + </state> + <state name="qstring"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="\${"> + <token type="LiteralStringInterpol"/> + <push state="interpol"/> + </rule> + <rule pattern="\\."> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern=".|\n"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="istring"> + <rule pattern="''\$"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="'''"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="''\\."> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="''"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\${"> + <token type="LiteralStringInterpol"/> + <push state="interpol"/> + </rule> + <rule pattern="\$."> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern=".|\n"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="id"> + <rule pattern="[a-zA-Z_][a-zA-Z0-9_'-]*"> + <token type="Name"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/objective-c.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/objective-c.xml new file mode 100644 index 0000000..0dc9328 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/objective-c.xml @@ -0,0 +1,510 @@ +<lexer> + <config> + <name>Objective-C</name> + <alias>objective-c</alias> + <alias>objectivec</alias> + <alias>obj-c</alias> + <alias>objc</alias> + <filename>*.m</filename> + <filename>*.h</filename> + <mime_type>text/x-objective-c</mime_type> + </config> + <rules> + <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="(?<=\\)\n"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="literal_number"> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="literal_number_inner"/> + </rule> + <rule pattern="\)"> + <token type="Literal"/> + <pop depth="1"/> + </rule> + <rule> + <include state="statement"/> + </rule> + </state> + <state name="if0"> + <rule pattern="^\s*#if.*?(?<!\\)\n"> + <token type="CommentPreproc"/> + <push/> + </rule> + <rule pattern="^\s*#el(?:se|if).*\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="^\s*#endif.*?(?<!\\)\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern=".*?\n"> + <token type="Comment"/> + </rule> + </state> + <state name="root"> + <rule pattern="^([-+])(\s*)(\(.*?\))?(\s*)([a-zA-Z$_][\w$]*:?)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <usingself state="root"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + <push state="method"/> + </rule> + <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> + <state name="statements"> + <rule pattern="@""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="@(YES|NO)"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="@'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="@(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="@(\d+\.\d*|\.\d+|\d+[fF])[fF]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="@0x[0-9a-fA-F]+[Ll]?"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="@0[0-7]+[Ll]?"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="@\d+[Ll]?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="@\("> + <token type="Literal"/> + <push state="literal_number"/> + </rule> + <rule pattern="@\["> + <token type="Literal"/> + <push state="literal_array"/> + </rule> + <rule pattern="@\{"> + <token type="Literal"/> + <push state="literal_dictionary"/> + </rule> + <rule pattern="(unsafe_unretained|__bridge_transfer|@autoreleasepool|__autoreleasing|@synchronized|@synthesize|@protected|@selector|@required|@optional|readwrite|@property|nonatomic|@finally|__bridge|@dynamic|__strong|readonly|@private|__block|@public|@encode|release|assign|retain|atomic|@throw|@catch|__weak|setter|getter|typeof|strong|inout|class|@try|@end|weak|copy|out|in)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(instancetype|IBOutlet|IBAction|unichar|Class|BOOL|IMP|SEL|id)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="@(true|false|YES|NO)\n"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(YES|NO|nil|self|super)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(Boolean|UInt8|SInt8|UInt16|SInt16|UInt32|SInt32)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(TRUE|FALSE)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(@interface|@implementation)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="#pop" state="oc_classname"/> + </rule> + <rule pattern="(@class|@protocol)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="#pop" state="oc_forward_classname"/> + </rule> + <rule pattern="@"> + <token type="Punctuation"/> + </rule> + <rule pattern="(L?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralString"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')"> + <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="[~!%^&*+=|?:<>/-]"> + <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|unsigned|signed|void)\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="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="method"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="\.\.\."> + <token type="Punctuation"/> + </rule> + <rule pattern="(\(.*?\))(\s*)([a-zA-Z$_][\w$]*)"> + <bygroups> + <usingself state="root"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="[a-zA-Z$_][\w$]*:"> + <token type="NameFunction"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="function"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="literal_array"> + <rule pattern="\["> + <token type="Punctuation"/> + <push state="literal_array_inner"/> + </rule> + <rule pattern="\]"> + <token type="Literal"/> + <pop depth="1"/> + </rule> + <rule> + <include state="statement"/> + </rule> + </state> + <state name="oc_classname"> + <rule pattern="([a-zA-Z$_][\w$]*)(\s*:\s*)([a-zA-Z$_][\w$]*)?(\s*)(\{)"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + <token type="NameClass"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="#pop" state="oc_ivars"/> + </rule> + <rule pattern="([a-zA-Z$_][\w$]*)(\s*:\s*)([a-zA-Z$_][\w$]*)?"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="([a-zA-Z$_][\w$]*)(\s*)(\([a-zA-Z$_][\w$]*\))(\s*)(\{)"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + <token type="NameLabel"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="#pop" state="oc_ivars"/> + </rule> + <rule pattern="([a-zA-Z$_][\w$]*)(\s*)(\([a-zA-Z$_][\w$]*\))"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + <token type="NameLabel"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="([a-zA-Z$_][\w$]*)(\s*)(\{)"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <push state="#pop" state="oc_ivars"/> + </rule> + <rule pattern="([a-zA-Z$_][\w$]*)"> + <token type="NameClass"/> + <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="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="literal_number_inner"> + <rule pattern="\("> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="statement"/> + </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="oc_forward_classname"> + <rule pattern="([a-zA-Z$_][\w$]*)(\s*,\s*)"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + </bygroups> + <push state="oc_forward_classname"/> + </rule> + <rule pattern="([a-zA-Z$_][\w$]*)(\s*;?)"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + <state name="literal_array_inner"> + <rule pattern="\["> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="\]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="statement"/> + </rule> + </state> + <state name="literal_dictionary"> + <rule pattern="\}"> + <token type="Literal"/> + <pop depth="1"/> + </rule> + <rule> + <include state="statement"/> + </rule> + </state> + <state name="oc_ivars"> + <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="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|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="[^\\"\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ocaml.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ocaml.xml new file mode 100644 index 0000000..77f67ac --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ocaml.xml @@ -0,0 +1,145 @@ +<lexer> + <config> + <name>OCaml</name> + <alias>ocaml</alias> + <filename>*.ml</filename> + <filename>*.mli</filename> + <filename>*.mll</filename> + <filename>*.mly</filename> + <mime_type>text/x-ocaml</mime_type> + </config> + <rules> + <state name="escape-sequence"> + <rule pattern="\\[\\"\'ntbr]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\[0-9]{3}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\x[0-9a-fA-F]{2}"> + <token type="LiteralStringEscape"/> + </rule> + </state> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="false|true|\(\)|\[\]"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="\b([A-Z][\w\']*)(?=\s*\.)"> + <token type="NameNamespace"/> + <push state="dotted"/> + </rule> + <rule pattern="\b([A-Z][\w\']*)"> + <token type="NameClass"/> + </rule> + <rule pattern="\(\*(?![)])"> + <token type="Comment"/> + <push state="comment"/> + </rule> + <rule pattern="\b(as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|false|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|object|of|open|private|raise|rec|sig|struct|then|to|true|try|type|value|val|virtual|when|while|with)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(~|\}|\|]|\||\{<|\{|`|_|]|\[\||\[>|\[<|\[|\?\?|\?|>\}|>]|>|=|<-|<|;;|;|:>|:=|::|:|\.\.|\.|->|-\.|-|,|\+|\*|\)|\(|&&|&|#|!=)"> + <token type="Operator"/> + </rule> + <rule pattern="([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]"> + <token type="Operator"/> + </rule> + <rule pattern="\b(and|asr|land|lor|lsl|lxor|mod|or)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="\b(unit|int|float|bool|string|char|list|array)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[^\W\d][\w']*"> + <token type="Name"/> + </rule> + <rule pattern="-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)"> + <token type="LiteralNumberFloat"/> + </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_]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'.'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'"> + <token type="Keyword"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="[~?][a-z][\w\']*:"> + <token type="NameVariable"/> + </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> + <state name="string"> + <rule pattern="[^\\"]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule> + <include state="escape-sequence"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <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\']*(?=\s*\.)"> + <token type="NameNamespace"/> + </rule> + <rule pattern="[A-Z][\w\']*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-z_][\w\']*"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/octave.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/octave.xml new file mode 100644 index 0000000..0515d28 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/octave.xml @@ -0,0 +1,101 @@ +<lexer> + <config> + <name>Octave</name> + <alias>octave</alias> + <filename>*.m</filename> + <mime_type>text/octave</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="[%#].*$"> + <token type="Comment"/> + </rule> + <rule pattern="^\s*function"> + <token type="Keyword"/> + <push state="deffunc"/> + </rule> + <rule pattern="(unwind_protect_cleanup|end_unwind_protect|unwind_protect|end_try_catch|endproperties|endclassdef|endfunction|persistent|properties|endmethods|otherwise|endevents|endswitch|__FILE__|continue|classdef|__LINE__|endwhile|function|methods|elseif|return|static|events|global|endfor|switch|until|endif|while|catch|break|case|else|set|end|try|for|get|do|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(history_timestamp_format_string|suppress_verbose_help_message|is_rooted_relative_filename|chisquare_test_independence|available_graphics_toolkits|print_struct_array_contents|re_read_readline_init_file|ignore_function_time_stamp|chisquare_test_homogeneity|sigterm_dumps_octave_core|save_header_format_string|sighup_dumps_octave_core|octave_core_file_options|confirm_recursive_rmdir|crash_dumps_octave_core|program_invocation_name|read_readline_init_file|echo_executing_commands|kolmogorov_smirnov_test|page_output_immediately|completion_append_char|output_max_field_width|kolmogorov_smirnov_cdf|print_empty_dimensions|octave_core_file_limit|struct_levels_to_print|make_absolute_filename|octave_core_file_name|default_save_options|isequalwithequalnans|is_absolute_filename|max_recursion_depth|native_float_format|kruskal_wallis_test|undo_string_escapes|commutation_matrix|fixed_point_format|debug_on_interrupt|completion_matches|duplication_matrix|sparse_auto_mutate|waitforbuttonpress|restoredefaultpath|is_duplicate_entry|page_screen_output|octave_config_info|do_string_escapes|f_test_regression|t_test_regression|command_line_path|debug_on_warning|is_valid_file_id|string_fill_char|find_dir_in_path|graphics_toolkit|mouse_wheel_zoom|file_in_loadpath|compare_versions|sylvester_matrix|silent_functions|output_precision|makeinfo_program|whos_line_format|split_long_rows|history_control|regexptranslate|validatestring|debug_on_error|hotelling_test|save_precision|gnuplot_binary|doc_cache_file|autoreg_matrix|saving_history|durbinlevinson|stdnormal_pdf|beep_on_error|bartlett_test|empirical_inv|wilcoxon_test|empirical_cdf|stdnormal_cdf|namelengthmax|daspk_options|lsode_options|empirical_pdf|empirical_rnd|dasrt_options|dassl_options|stdnormal_inv|stdnormal_rnd|discrete_rnd|logistic_cdf|discrete_cdf|logistic_inv|program_name|logistic_pdf|is_leap_year|spectral_adf|logistic_rnd|rectangle_sw|quad_options|mcnemar_test|file_in_path|info_program|rectangle_lw|spectral_xdf|tilde_expand|history_file|history_size|discrete_inv|discrete_pdf|laplace_cdf|refreshdata|common_size|dellistener|ishermitian|mahalanobis|print_usage|laplace_inv|parseparams|triangle_lw|laplace_rnd|triangle_sw|addproperty|semilogyerr|matrix_type|addlistener|orderfields|issymmetric|list_primes|isdebugmode|laplace_pdf|semilogxerr|periodogram|ezcontourf|fileattrib|freqz_plot|polyreduce|treelayout|inferiorto|size_equal|genvarname|onenormest|svd_driver|divergence|filemarker|fieldnames|cholupdate|cholinsert|choldelete|cellslices|errno_list|triplequad|ls_command|accumarray|cauchy_cdf|yulewalker|plotmatrix|polyaffine|cauchy_inv|studentize|ctranspose|nargoutchk|ishghandle|isdefinite|matlabroot|cauchy_rnd|cauchy_pdf|statistics|welch_test|superiorto|iscomplex|run_count|sprandsym|circshift|mfilename|fileparts|intersect|inputname|factorial|inpolygon|wilkinson|ifftshift|structfun|lsqnonneg|arch_test|addtodate|substruct|localtime|yes_or_no|vectorize|cholshift|lasterror|polyderiv|transpose|fractdiff|mislocked|playaudio|isvarname|delaunayn|convhulln|loglogerr|getrusage|griddatan|saveaudio|swapbytes|isnumeric|synthesis|functions|ellipsoid|subsindex|pqpnonneg|shell_cmd|sign_test|islogical|isstrprop|isinteger|info_file|regexprep|spconvert|spaugment|etreeplot|loadaudio|iscellstr|ezcontour|shiftdim|isglobal|readlink|treeplot|ishandle|sombrero|repelems|ismethod|fullfile|isargout|sortrows|ipermute|skewness|endgrent|errorbar|endpwent|polyvalm|sinewave|setfield|powerset|dbstatus|setgrent|sinetone|ismatrix|gui_mode|kurtosis|setaudio|toeplitz|spearman|textscan|textread|tempname|getgrent|issparse|semilogy|getgrgid|getgrnam|getpwent|optimset|strftime|optimget|semilogx|isvector|getfield|strptime|getpwnam|dsearchn|setpwent|specular|savepath|dlmwrite|subsasgn|gradient|symbfact|planerot|allchild|griddata|getpwuid|typecast|linkprop|urlwrite|runtests|diffpara|isobject|issorted|isstruct|keyboard|delaunay|typeinfo|run_test|datetick|surfnorm|strncmpi|nonzeros|lastwarn|cylinder|bincoeff|cumtrapz|hadamard|randperm|csvwrite|cplxpair|untabify|warranty|realsqrt|polyarea|gammainc|logspace|cor_test|corrcoef|issquare|copyfile|isscalar|convhull|var_test|poisscdf|accumdim|contrast|contourf|contourc|linspace|ismember|ancestor|nchoosek|arch_fit|arch_rnd|legendre|computer|arma_rnd|arrayfun|subspace|isfinite|luupdate|qrupdate|tsearchn|strtrunc|isletter|colormap|poissinv|qrinsert|colorbar|voronoin|poisspdf|mrdivide|interpft|closereq|poissrnd|strsplit|wavwrite|bicgstab|mldivide|bitshift|isxdigit|autoload|strmatch|assignin|movefile|celldisp|fftshift|blackman|meshgrid|rundemos|argnames|qrdelete|brighten|calendar|isfigure|bartlett|spparms|spstats|weekday|blkdiag|sprandn|binornd|binopdf|binoinv|binocdf|bicubic|betarnd|betapdf|wavread|betainv|cloglog|betacdf|whitebg|wienrnd|nargchk|colperm|voronoi|nbincdf|nbininv|nbinpdf|asctime|compass|nbinrnd|version|condest|contour|balance|besselh|besseli|besselj|besselk|bessely|lookfor|bitpack|newplot|builtin|ccolamd|cellfun|lognrnd|warning|waitpid|lognpdf|logninv|cstrcat|csvread|vertcat|logncdf|spinmap|unifrnd|unifpdf|cholinv|interpn|datenum|datestr|normcdf|datevec|dblquad|unifinv|deblank|normest|norminv|toupper|normpdf|unifcdf|detrend|tmpfile|diffuse|unidrnd|normrnd|nthroot|symlink|spencer|display|subsref|strvcat|unidpdf|dsearch|strncmp|strcmpi|squeeze|sprintf|dbclear|sizemax|spdiags|dbstack|pathdef|rmfield|unidinv|rethrow|example|reshape|dbwhere|unidcdf|realmin|realmax|readdir|rdivide|loadobj|ezmeshc|dlmread|ezpolar|permute|ezsurfc|pathsep|nfields|nargout|munlock|feather|fftconv|fftfilt|mkstemp|license|shading|methods|qrshift|findall|findobj|findstr|trisurf|triplot|flipdim|logical|ldivide|lasterr|trimesh|regexpi|polyfit|isindex|isfloat|isfield|isempty|polyint|polyout|polyval|postpad|horzcat|spalloc|setdiff|getppid|ppjumps|getpgrp|geteuid|getegid|genpath|strfind|kendall|frewind|freport|scatter|tempdir|fprintf|formula|fnmatch|filesep|rainbow|saveobj|tsearch|urlread|betainc|reallog|surface|realpow|hamming|gammaln|hanning|hggroup|isalnum|isprime|isalpha|isascii|iscntrl|drawnow|isdigit|subplot|isgraph|rectint|hygecdf|hygeinv|hygepdf|hygernd|idivide|cumprod|cputime|imagesc|imfinfo|strjust|complex|imwrite|strtrim|columns|islower|isprint|ispunct|polygcd|cellstr|isspace|isupper|strread|refresh|residue|toascii|isequal|tolower|addpath|csymamd|invhilb|strtok|imshow|imread|substr|strchr|summer|isprop|hidden|hankel|gunzip|symvar|isunix|ginput|geornd|strcat|geopdf|geoinv|geocdf|gamrnd|krylov|gampdf|gaminv|gamcdf|fsolve|flipud|legend|fliplr|figure|t_test|factor|ezsurf|ezplot|ezmesh|exprnd|exppdf|expinv|expcdf|eomday|loglog|delete|deconv|unique|unmkpp|unpack|unwrap|u_test|copper|vander|compan|clabel|wblcdf|manova|center|wblinv|wblpdf|meansq|median|stairs|wblrnd|spring|blanks|bitset|mexext|bitget|sprand|spones|moment|bitcmp|mpoles|spline|binary|autumn|winter|assert|xlabel|ylabel|zlabel|z_test|ndgrid|bsxfun|usleep|unlink|uminus|colamd|colloc|tmpnam|cummax|sphere|system|cummin|struct|strcmp|stdout|stderr|sscanf|source|orient|sizeof|dbdown|pareto|single|pascal|setenv|dbstop|rmpath|dbtype|pcolor|resize|rename|rehash|dmperm|putenv|filter|printf|pclose|givens|gmtime|rotdim|plotyy|lookup|nargin|mtimes|mpower|mkfifo|setxor|mktime|length|regexp|isreal|isieee|ischar|iscell|isbool|intmin|intmax|inline|ifelse|sparse|getuid|getpid|ppplot|getgid|getenv|prepad|primes|sprank|fwrite|fskipl|probit|fscanf|qqplot|quadcc|quadgk|strrep|symamd|quiver|qzhess|symrcm|fflush|ferror|saveas|fclose|fclear|betaln|erfinv|finite|record|evalin|double|cumsum|bitxor|bitmax|bitand|repmat|atexit|ribbon|rindex|lgamma|roundb|rosser|isnull|untar|ftell|hypot|roots|schur|ranks|input|range|randi|quadv|quadl|kbhit|rcond|prism|print|ppval|ppint|ppder|fseek|randp|polar|shift|randn|randg|rande|fread|lstat|perms|fputs|slice|peaks|merge|pchip|round|patch|sqrtm|minus|mkdir|ocean|speed|fopen|speye|spfun|lower|fgets|mlock|ndims|luinc|fgetl|meshz|meshc|lsode|feval|bitor|numel|fdisp|ifftn|magic|nzmax|logit|fcntl|pause|acosh|popen|power|ismac|isdir|class|isnan|acoth|etree|image|hurst|acsch|housh|isinf|angle|histc|reset|rmdir|scanf|asech|surfc|surfl|gtext|sleep|dassl|stdin|gplot|dasrt|table|daspk|sumsq|asinh|times|convn|umask|uname|uplus|upper|atanh|title|errno|zeros|trace|trapz|fzero|false|close|freqz|acosd|fplot|acotd|acscd|anova|ascii|asecd|asind|atand|white|caxis|erfcx|etime|error|exist|clock|colon|gamma|comet|union|ctime|usage|floor|cross|unzip|index|cotd|fmod|cosd|cscd|cool|unix|conv|vech|exec|cond|view|curl|deal|demo|eval|expm|erfc|type|cast|csch|bone|beep|what|fail|barh|coth|axis|axes|fcdf|fill|xlim|trnd|triu|cosh|area|finv|airy|conj|flag|fpdf|tril|whos|ceil|load|frnd|cbrt|exit|imag|beta|tpdf|chol|tinv|path|gcbf|gcbo|text|test|true|atan|disp|glpk|tcdf|diff|tand|asin|diag|gray|grid|stat|svds|size|gzip|surf|rows|hilb|dbup|hist|asec|rats|quit|hold|isna|eigs|acsc|puts|pack|info|fftn|fftw|prod|find|full|acot|ispc|char|plus|pipe|stft|stem|acos|line|ones|logm|hess|ifft|cell|mean|menu|feof|kron|norm|argv|mesh|time|mget|mkpp|mode|mput|news|null|real|pinv|fork|orth|sech|perl|sign|quad|link|sind|rand|sinc|pink|plot|poly|date|sinh|kill|secd|rank|sqrt|rose|home|sort|tanh|glob|rref|xor|get|all|and|run|tan|svd|rat|syl|min|max|pwd|sin|nnz|not|inv|pie|abs|var|pcr|gcd|fft|sec|eig|dot|arg|det|set|sum|tic|toc|vec|inf|Inf|eye|nan|NaN|who|amd|cos|zip|cot|bar|csc|box|erf|cgs|ols|clf|exp|ver|fix|cor|cov|cut|dir|dos|ftp|gca|any|eps|pcg|gcf|tar|gls|hot|clc|hsv|iqr|isa|jet|std|cat|sqp|lcm|spy|log|now|mod|cla|rem|lu|eq|ge|pi|or|ne|qp|qr|lt|qz|le|gt|e)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(OCTAVE_VERSION|WIFCONTINUED|WEXITSTATUS|WIFSIGNALED|OCTAVE_HOME|PAGER_FLAGS|IMAGE_PATH|WIFSTOPPED|WUNTRACED|WIFEXITED|WCOREDUMP|WCONTINUE|EXEC_PATH|S_ISSOCK|WTERMSIG|SEEK_CUR|SEEK_END|SEEK_SET|WSTOPSIG|S_ISFIFO|S_ISREG|S_ISLNK|S_ISCHR|S_ISBLK|WNOHANG|S_ISDIR|EDITOR|PAGER|SIG|NA|I)\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="-=|!=|!|/=|--"> + <token type="Operator"/> + </rule> + <rule pattern="-|==|~=|<|>|<=|>=|&&|&|~|\|\|?"> + <token type="Operator"/> + </rule> + <rule pattern="\*=|\+=|\^=|\/=|\\=|\*\*|\+\+|\.\*\*"> + <token type="Operator"/> + </rule> + <rule pattern="\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\](){}:@.,]"> + <token type="Punctuation"/> + </rule> + <rule pattern="=|:|;"> + <token type="Punctuation"/> + </rule> + <rule pattern=""[^"]*""> + <token type="LiteralString"/> + </rule> + <rule pattern="(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+[eEf][+-]?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(?<=[\w)\].])\'+"> + <token type="Operator"/> + </rule> + <rule pattern="(?<![\w)\].])\'"> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^']*'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="deffunc"> + <rule pattern="(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)"> + <bygroups> + <token type="TextWhitespace"/> + <token type="Text"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + <token type="NameFunction"/> + <token type="Punctuation"/> + <token type="Text"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(\s*)([a-zA-Z_]\w*)"> + <bygroups> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/onesenterprise.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/onesenterprise.xml new file mode 100644 index 0000000..530bad7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/onesenterprise.xml @@ -0,0 +1,92 @@ +<lexer> + <config> + <name>OnesEnterprise</name> + <alias>ones</alias> + <alias>onesenterprise</alias> + <alias>1S</alias> + <alias>1S:Enterprise</alias> + <filename>*.EPF</filename> + <filename>*.epf</filename> + <filename>*.ERF</filename> + <filename>*.erf</filename> + <mime_type>application/octet-stream</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="//(.*?)\n"> + <token type="Comment"/> + </rule> + <rule pattern="(#область|#region|#конецобласти|#endregion|#если|#if|#иначе|#else|#конецесли|#endif).*"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="(&наклиенте|&atclient|&насервере|&atserver|&насерверебезконтекста|&atservernocontext|&наклиентенасерверебезконтекста|&atclientatservernocontext).*"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="(>=|<=|<>|\+|-|=|>|<|\*|/|%)"> + <token type="Operator"/> + </rule> + <rule pattern="(;|,|\)|\(|\.)"> + <token type="Punctuation"/> + </rule> + <rule pattern="(истина|ложь|или|false|true|не|and|not|и|or)\b"> + <token type="Operator"/> + </rule> + <rule pattern="(иначеесли|конецесли|иначе|тогда|если|elsif|endif|else|then|if)\b"> + <token type="Operator"/> + </rule> + <rule pattern="(конеццикла|каждого|цикл|пока|для|while|enddo|по|each|из|for|do|in|to)\b"> + <token type="Operator"/> + </rule> + <rule pattern="(продолжить|прервать|возврат|перейти|continue|return|break|goto)\b"> + <token type="Operator"/> + </rule> + <rule pattern="(конецпроцедуры|конецфункции|процедура|функция|endprocedure|endfunction|procedure|function)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(экспорт|новый|перем|знач|export|new|val|var)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(вызватьисключение|конецпопытки|исключение|попытка|endtry|except|raise|try)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(выполнить|вычислить|execute|eval)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="[_а-яА-Я0-9][а-яА-Я0-9]*"> + <token type="Name"/> + </rule> + <rule pattern="[_\w][\w]*"> + <token type="Name"/> + </rule> + </state> + <state name="string"> + <rule pattern=""""> + <token type="LiteralString"/> + </rule> + <rule pattern=""C?"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="[^"]+"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/openscad.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/openscad.xml new file mode 100644 index 0000000..84d0fe1 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/openscad.xml @@ -0,0 +1,96 @@ +<lexer> + <config> + <name>OpenSCAD</name> + <alias>openscad</alias> + <filename>*.scad</filename> + <mime_type>text/x-scad</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="[^\S\n]+"> + <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> + <rule pattern="[{}\[\]\(\),;:]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[*!#%\-+=?/]"> + <token type="Operator"/> + </rule> + <rule pattern="<|<=|==|!=|>=|>|&&|\|\|"> + <token type="Operator"/> + </rule> + <rule pattern="\$(f[asn]|t|vp[rtd]|children)"> + <token type="NameVariableMagic"/> + </rule> + <rule pattern="(undef|PI)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(use|include)((?:\s|\\\\s)+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="includes"/> + </rule> + <rule pattern="(module)(\s*)([^\s\(]+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(function)(\s*)([^\s\(]+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="\b(true|false)\b"> + <token type="Literal"/> + </rule> + <rule pattern="\b(function|module|include|use|for|intersection_for|if|else|return)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(circle|square|polygon|text|sphere|cube|cylinder|polyhedron|translate|rotate|scale|resize|mirror|multmatrix|color|offset|hull|minkowski|union|difference|intersection|abs|sign|sin|cos|tan|acos|asin|atan|atan2|floor|round|ceil|ln|log|pow|sqrt|exp|rands|min|max|concat|lookup|str|chr|search|version|version_num|norm|cross|parent_module|echo|import|import_dxf|dxf_linear_extrude|linear_extrude|rotate_extrude|surface|projection|render|dxf_cross|dxf_dim|let|assign|len)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\bchildren\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="-?\d+(\.\d+)?(e[+-]?\d+)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="includes"> + <rule pattern="(<)([^>]*)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="CommentPreprocFile"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pacmanconf.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pacmanconf.xml new file mode 100644 index 0000000..caf7236 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pacmanconf.xml @@ -0,0 +1,37 @@ +<lexer> + <config> + <name>PacmanConf</name> + <alias>pacmanconf</alias> + <filename>pacman.conf</filename> + </config> + <rules> + <state name="root"> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="^\s*\[.*?\]\s*$"> + <token type="Keyword"/> + </rule> + <rule pattern="(\w+)(\s*)(=)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="^(\s*)(\w+)(\s*)$"> + <bygroups> + <token type="Text"/> + <token type="NameAttribute"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(\$repo|\$arch|%o|%u)\b"> + <token type="NameVariable"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/perl.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/perl.xml new file mode 100644 index 0000000..8ac02ab --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/perl.xml @@ -0,0 +1,400 @@ +<lexer> + <config> + <name>Perl</name> + <alias>perl</alias> + <alias>pl</alias> + <filename>*.pl</filename> + <filename>*.pm</filename> + <filename>*.t</filename> + <mime_type>text/x-perl</mime_type> + <mime_type>application/x-perl</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="root"> + <rule pattern="\A\#!.+?$"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="\#.*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="^=[a-zA-Z0-9]+\s+.*?\n=cut"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="(continue|foreach|unless|return|elsif|CHECK|while|BEGIN|reset|print|until|next|else|INIT|then|last|redo|case|our|new|for|END|if|do|my)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(format)(\s+)(\w+)(\s*)(=)(\s*\n)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Name"/> + <token type="Text"/> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + <push state="format"/> + </rule> + <rule pattern="(eq|lt|gt|le|ge|ne|not|and|or|cmp)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="s/(\\\\|\\[^\\]|[^\\/])*/(\\\\|\\[^\\]|[^\\/])*/[egimosx]*"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="s!(\\\\|\\!|[^!])*!(\\\\|\\!|[^!])*![egimosx]*"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="s\\(\\\\|[^\\])*\\(\\\\|[^\\])*\\[egimosx]*"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="s@(\\\\|\\[^\\]|[^\\@])*@(\\\\|\\[^\\]|[^\\@])*@[egimosx]*"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="s%(\\\\|\\[^\\]|[^\\%])*%(\\\\|\\[^\\]|[^\\%])*%[egimosx]*"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="s\{(\\\\|\\[^\\]|[^\\}])*\}\s*"> + <token type="LiteralStringRegex"/> + <push state="balanced-regex"/> + </rule> + <rule pattern="s<(\\\\|\\[^\\]|[^\\>])*>\s*"> + <token type="LiteralStringRegex"/> + <push state="balanced-regex"/> + </rule> + <rule pattern="s\[(\\\\|\\[^\\]|[^\\\]])*\]\s*"> + <token type="LiteralStringRegex"/> + <push state="balanced-regex"/> + </rule> + <rule pattern="s\((\\\\|\\[^\\]|[^\\)])*\)\s*"> + <token type="LiteralStringRegex"/> + <push state="balanced-regex"/> + </rule> + <rule pattern="m?/(\\\\|\\[^\\]|[^\\/\n])*/[gcimosx]*"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="m(?=[/!\\{<\[(@%$])"> + <token type="LiteralStringRegex"/> + <push state="balanced-regex"/> + </rule> + <rule pattern="((?<==~)|(?<=\())\s*/(\\\\|\\[^\\]|[^\\/])*/[gcimosx]*"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(getprotobynumber|getprotobyname|getservbyport|getservbyname|gethostbyname|gethostbyaddr|getnetbyaddr|getnetbyname|setprotoent|setpriority|getsockname|getprotoent|getpriority|getpeername|endprotoent|setsockopt|endhostent|setservent|socketpair|getsockopt|endservent|sethostent|getservent|gethostent|getnetent|wantarray|localtime|quotemeta|setnetent|prototype|endnetent|rewinddir|endpwent|endgrent|getpwent|getpwnam|getgrgid|dbmclose|continue|closedir|shutdown|setpwent|shmwrite|syswrite|truncate|formline|setgrent|getgrent|readpipe|getgrnam|readlink|readline|getpwuid|getlogin|telldir|opendir|shmread|readdir|getpgrp|getppid|waitpid|binmode|reverse|sprintf|unshift|symlink|seekdir|sysopen|defined|dbmopen|sysread|sysseek|connect|lcfirst|ucfirst|setpgrp|syscall|import|chroot|system|gmtime|unlink|unpack|semget|semctl|select|msgrcv|length|printf|listen|scalar|caller|rindex|substr|splice|rename|msgctl|msgget|delete|msgsnd|exists|values|socket|fileno|format|accept|shmget|shmctl|ioctl|alarm|atan2|utime|untie|bless|chdir|chmod|undef|umask|chomp|times|close|crypt|srand|split|mkdir|sleep|lstat|study|rmdir|local|fcntl|flock|write|shift|index|semop|chown|tell|join|send|warn|kill|wait|grep|glob|bind|last|pack|getc|fork|link|seek|push|rand|read|exit|sort|exec|open|eval|sqrt|redo|stat|chop|next|each|dump|time|recv|tied|goto|keys|pipe|map|tie|cos|die|eof|pop|sin|pos|oct|ref|exp|int|ord|log|our|hex|abs|vec|chr|uc|tr|my|lc)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(<<)([\'"]?)([a-zA-Z_]\w*)(\2;?\n.*?\n)(\3)(\n)"> + <bygroups> + <token type="LiteralString"/> + <token type="LiteralString"/> + <token type="LiteralStringDelimiter"/> + <token type="LiteralString"/> + <token type="LiteralStringDelimiter"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="__END__"> + <token type="CommentPreproc"/> + <push state="end-part"/> + </rule> + <rule pattern="\$\^[ADEFHILMOPSTWX]"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="\$[\\\"\[\]'&`+*.,;=%~?@$!<>(^|/-](?!\w)"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="[$@%#]+"> + <token type="NameVariable"/> + <push state="varname"/> + </rule> + <rule pattern="0_?[0-7]+(_[0-7]+)*"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0b[01]+(_[01]+)*"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="(?i)(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(?i)\d+(_\d*)*e[+-]?\d+(_\d*)*"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+(_\d+)*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="'(\\\\|\\[^\\]|[^'\\])*'"> + <token type="LiteralString"/> + </rule> + <rule pattern=""(\\\\|\\[^\\]|[^"\\])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="`(\\\\|\\[^\\]|[^`\\])*`"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="<([^\s>]+)>"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="(q|qq|qw|qr|qx)\{"> + <token type="LiteralStringOther"/> + <push state="cb-string"/> + </rule> + <rule pattern="(q|qq|qw|qr|qx)\("> + <token type="LiteralStringOther"/> + <push state="rb-string"/> + </rule> + <rule pattern="(q|qq|qw|qr|qx)\["> + <token type="LiteralStringOther"/> + <push state="sb-string"/> + </rule> + <rule pattern="(q|qq|qw|qr|qx)\<"> + <token type="LiteralStringOther"/> + <push state="lt-string"/> + </rule> + <rule pattern="(q|qq|qw|qr|qx)([\W_])(.|\n)*?\2"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="(package)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(use|require|no)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(sub)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="funcname"/> + </rule> + <rule pattern="(package|require|use|no)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(\[\]|\*\*|::|<<|>>|>=|<=>|<=|={3}|!=|=~|!~|&&?|\|\||\.{1,3})"> + <token type="Operator"/> + </rule> + <rule pattern="[-+/*%=<>&^|!\\~]=?"> + <token type="Operator"/> + </rule> + <rule pattern="[()\[\]:;,<>/?{}]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?=\w)"> + <token type="Name"/> + <push state="name"/> + </rule> + </state> + <state name="cb-string"> + <rule pattern="\\[{}\\]"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\{"> + <token type="LiteralStringOther"/> + <push state="cb-string"/> + </rule> + <rule pattern="\}"> + <token type="LiteralStringOther"/> + <pop depth="1"/> + </rule> + <rule pattern="[^{}\\]+"> + <token type="LiteralStringOther"/> + </rule> + </state> + <state name="balanced-regex"> + <rule pattern="/(\\\\|\\[^\\]|[^\\/])*/[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="!(\\\\|\\[^\\]|[^\\!])*![egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="\\(\\\\|[^\\])*\\[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="\{(\\\\|\\[^\\]|[^\\}])*\}[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="<(\\\\|\\[^\\]|[^\\>])*>[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="\[(\\\\|\\[^\\]|[^\\\]])*\][egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="\((\\\\|\\[^\\]|[^\\)])*\)[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="@(\\\\|\\[^\\]|[^\\@])*@[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="%(\\\\|\\[^\\]|[^\\%])*%[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="\$(\\\\|\\[^\\]|[^\\$])*\$[egimosx]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + </state> + <state name="lt-string"> + <rule pattern="\\[<>\\]"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\<"> + <token type="LiteralStringOther"/> + <push state="lt-string"/> + </rule> + <rule pattern="\>"> + <token type="LiteralStringOther"/> + <pop depth="1"/> + </rule> + <rule pattern="[^<>]+"> + <token type="LiteralStringOther"/> + </rule> + </state> + <state name="format"> + <rule pattern="\.\n"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\n]*\n"> + <token type="LiteralStringInterpol"/> + </rule> + </state> + <state name="funcname"> + <rule pattern="[a-zA-Z_]\w*[!?]?"> + <token type="NameFunction"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(\([$@%]*\))(\s*)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern=".*?\{"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="end-part"> + <rule pattern=".+"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="varname"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\)|,"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\w+::"> + <token type="NameNamespace"/> + </rule> + <rule pattern="[\w:]+"> + <token type="NameVariable"/> + <pop depth="1"/> + </rule> + </state> + <state name="name"> + <rule pattern="[a-zA-Z_]\w*(::[a-zA-Z_]\w*)*(::)?(?=\s*->)"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-zA-Z_]\w*(::[a-zA-Z_]\w*)*::"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + <rule pattern="[\w:]+"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule pattern="[A-Z_]+(?=\W)"> + <token type="NameConstant"/> + <pop depth="1"/> + </rule> + <rule pattern="(?=\W)"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="rb-string"> + <rule pattern="\\[()\\]"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\("> + <token type="LiteralStringOther"/> + <push state="rb-string"/> + </rule> + <rule pattern="\)"> + <token type="LiteralStringOther"/> + <pop depth="1"/> + </rule> + <rule pattern="[^()]+"> + <token type="LiteralStringOther"/> + </rule> + </state> + <state name="sb-string"> + <rule pattern="\\[\[\]\\]"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="\["> + <token type="LiteralStringOther"/> + <push state="sb-string"/> + </rule> + <rule pattern="\]"> + <token type="LiteralStringOther"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\[\]]+"> + <token type="LiteralStringOther"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/php.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/php.xml new file mode 100644 index 0000000..69e9e85 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/php.xml @@ -0,0 +1,211 @@ +<lexer> + <config> + <name>PHP</name> + <alias>php</alias> + <alias>php3</alias> + <alias>php4</alias> + <alias>php5</alias> + <filename>*.php</filename> + <filename>*.php[345]</filename> + <filename>*.inc</filename> + <mime_type>text/x-php</mime_type> + <case_insensitive>true</case_insensitive> + <dot_all>true</dot_all> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <state name="magicfuncs"> + <rule pattern="(__callStatic|__set_state|__construct|__debugInfo|__toString|__destruct|__invoke|__wakeup|__clone|__sleep|__isset|__unset|__call|__get|__set)\b"> + <token type="NameFunctionMagic"/> + </rule> + </state> + <state name="magicconstants"> + <rule pattern="(__NAMESPACE__|__FUNCTION__|__METHOD__|__CLASS__|__TRAIT__|__LINE__|__FILE__|__DIR__)\b"> + <token type="NameConstant"/> + </rule> + </state> + <state name="classname"> + <rule pattern="(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="functionname"> + <rule> + <include state="magicfuncs"/> + </rule> + <rule pattern="(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="[^{$"\\]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\\([nrt"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\$(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*(\[\S+?\]|->(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)?"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="(\{\$\{)(.*?)(\}\})"> + <bygroups> + <token type="LiteralStringInterpol"/> + <usingself state="root"/> + <token type="LiteralStringInterpol"/> + </bygroups> + </rule> + <rule pattern="(\{)(\$.*?)(\})"> + <bygroups> + <token type="LiteralStringInterpol"/> + <usingself state="root"/> + <token type="LiteralStringInterpol"/> + </bygroups> + </rule> + <rule pattern="(\$\{)(\S+)(\})"> + <bygroups> + <token type="LiteralStringInterpol"/> + <token type="NameVariable"/> + <token type="LiteralStringInterpol"/> + </bygroups> + </rule> + <rule pattern="[${\\]"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="root"> + <rule pattern="\?>"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="(<<<)([\'"]?)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)(\2\n.*?\n\s*)(\3)(;?)(\n)"> + <bygroups> + <token type="LiteralString"/> + <token type="LiteralString"/> + <token type="LiteralStringDelimiter"/> + <token type="LiteralString"/> + <token type="LiteralStringDelimiter"/> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="#.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*\*/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="/\*\*.*?\*/"> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="(->|::)(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)"> + <bygroups> + <token type="Operator"/> + <token type="Text"/> + <token type="NameAttribute"/> + </bygroups> + </rule> + <rule pattern="[~!%^&*+=|:.<>/@-]+"> + <token type="Operator"/> + </rule> + <rule pattern="\?"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\]{}();,]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="(class)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="classname"/> + </rule> + <rule pattern="(function)(\s*)(?=\()"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(function)(\s+)(&?)(\s*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + <push state="functionname"/> + </rule> + <rule pattern="(const)(\s+)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameConstant"/> + </bygroups> + </rule> + <rule pattern="(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"> + <token type="Keyword"/> + </rule> + <rule pattern="(true|false|null)\b"> + <token type="KeywordConstant"/> + </rule> + <rule> + <include state="magicconstants"/> + </rule> + <rule pattern="\$\{\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*\}"> + <token type="NameVariable"/> + </rule> + <rule pattern="\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*"> + <token type="NameVariable"/> + </rule> + <rule pattern="(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*"> + <token type="NameOther"/> + </rule> + <rule pattern="(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+e[+-]?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0x[a-f0-9_]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d[\d_]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="0b[01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="'([^'\\]*(?:\\.[^'\\]*)*)'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="`([^`\\]*(?:\\.[^`\\]*)*)`"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pig.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pig.xml new file mode 100644 index 0000000..5acd773 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pig.xml @@ -0,0 +1,105 @@ +<lexer> + <config> + <name>Pig</name> + <alias>pig</alias> + <filename>*.pig</filename> + <mime_type>text/x-pig</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="/\*[\w\W]*?\*/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="\\"> + <token type="Text"/> + </rule> + <rule pattern="\'(?:\\[ntbrf\\\']|\\u[0-9a-f]{4}|[^\'\\\n\r])*\'"> + <token type="LiteralString"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="types"/> + </rule> + <rule> + <include state="builtins"/> + </rule> + <rule> + <include state="punct"/> + </rule> + <rule> + <include state="operators"/> + </rule> + <rule pattern="[0-9]*\.[0-9]+(e[0-9]+)?[fd]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0x[0-9a-f]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9]+L?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="([a-z_]\w*)(\s*)(\()"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="[()#:]"> + <token type="Text"/> + </rule> + <rule pattern="[^(:#\'")\s]+"> + <token type="Text"/> + </rule> + <rule pattern="\S+\s+"> + <token type="Text"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(assert|and|any|all|arrange|as|asc|bag|by|cache|CASE|cat|cd|cp|%declare|%default|define|dense|desc|describe|distinct|du|dump|eval|exex|explain|filter|flatten|foreach|full|generate|group|help|if|illustrate|import|inner|input|into|is|join|kill|left|limit|load|ls|map|matches|mkdir|mv|not|null|onschema|or|order|outer|output|parallel|pig|pwd|quit|register|returns|right|rm|rmf|rollup|run|sample|set|ship|split|stderr|stdin|stdout|store|stream|through|union|using|void)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="builtins"> + <rule pattern="(AVG|BinStorage|cogroup|CONCAT|copyFromLocal|copyToLocal|COUNT|cross|DIFF|MAX|MIN|PigDump|PigStorage|SIZE|SUM|TextLoader|TOKENIZE)\b"> + <token type="NameBuiltin"/> + </rule> + </state> + <state name="types"> + <rule pattern="(bytearray|BIGINTEGER|BIGDECIMAL|chararray|datetime|double|float|int|long|tuple)\b"> + <token type="KeywordType"/> + </rule> + </state> + <state name="punct"> + <rule pattern="[;(){}\[\]]"> + <token type="Punctuation"/> + </rule> + </state> + <state name="operators"> + <rule pattern="[#=,./%+\-?]"> + <token type="Operator"/> + </rule> + <rule pattern="(eq|gt|lt|gte|lte|neq|matches)\b"> + <token type="Operator"/> + </rule> + <rule pattern="(==|<=|<|>=|>|!=)"> + <token type="Operator"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pkgconfig.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pkgconfig.xml new file mode 100644 index 0000000..875dcba --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pkgconfig.xml @@ -0,0 +1,73 @@ +<lexer> + <config> + <name>PkgConfig</name> + <alias>pkgconfig</alias> + <filename>*.pc</filename> + </config> + <rules> + <state name="curly"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule pattern="\w+"> + <token type="NameAttribute"/> + </rule> + </state> + <state name="spvalue"> + <rule> + <include state="interp"/> + </rule> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern="[^${}#\n]+"> + <token type="Text"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="root"> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="^(\w+)(=)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="^([\w.]+)(:)"> + <bygroups> + <token type="NameTag"/> + <token type="Punctuation"/> + </bygroups> + <push state="spvalue"/> + </rule> + <rule> + <include state="interp"/> + </rule> + <rule pattern="[^${}#=:\n.]+"> + <token type="Text"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="interp"> + <rule pattern="\$\$"> + <token type="Text"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="curly"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pl_pgsql.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pl_pgsql.xml new file mode 100644 index 0000000..e3e813a --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pl_pgsql.xml @@ -0,0 +1,119 @@ +<lexer> + <config> + <name>PL/pgSQL</name> + <alias>plpgsql</alias> + <mime_type>text/x-plpgsql</mime_type> + <case_insensitive>true</case_insensitive> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="root"> + <rule pattern="\%[a-z]\w*\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern=":="> + <token type="Operator"/> + </rule> + <rule pattern="\<\<[a-z]\w*\>\>"> + <token type="NameLabel"/> + </rule> + <rule pattern="\#[a-z]\w*\b"> + <token type="KeywordPseudo"/> + </rule> + <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="(bigint|bigserial|bit|bit\s+varying|bool|boolean|box|bytea|char|character|character\s+varying|cidr|circle|date|decimal|double\s+precision|float4|float8|inet|int|int2|int4|int8|integer|interval|json|jsonb|line|lseg|macaddr|money|numeric|path|pg_lsn|point|polygon|real|serial|serial2|serial4|serial8|smallint|smallserial|text|time|timestamp|timestamptz|timetz|tsquery|tsvector|txid_snapshot|uuid|varbit|varchar|with\s+time\s+zone|without\s+time\s+zone|xml|anyarray|anyelement|anyenum|anynonarray|anyrange|cstring|fdw_handler|internal|language_handler|opaque|record|void)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(CURRENT_TIMESTAMP|CHARACTERISTICS|CURRENT_CATALOG|CURRENT_SCHEMA|LOCALTIMESTAMP|XMLATTRIBUTES|AUTHORIZATION|CONFIGURATION|CURRENT_TIME|CURRENT_ROLE|CURRENT_USER|CURRENT_DATE|MATERIALIZED|SESSION_USER|SERIALIZABLE|CONCURRENTLY|XMLSERIALIZE|DIAGNOSTICS|UNCOMMITTED|UNENCRYPTED|TRANSACTION|INSENSITIVE|CONSTRAINTS|CONVERSION|ORDINALITY|LC_COLLATE|DEALLOCATE|CONSTRAINT|CONNECTION|PRIVILEGES|PROCEDURAL|STANDALONE|DICTIONARY|XMLELEMENT|STATISTICS|DEFERRABLE|DELIMITERS|REPEATABLE|TABLESPACE|REFERENCES|CHECKPOINT|WHITESPACE|ASYMMETRIC|ASSIGNMENT|CHARACTER|INCLUDING|SYMMETRIC|IMMUTABLE|IMMEDIATE|XMLCONCAT|INTERSECT|ISOLATION|DELIMITER|COLLATION|TIMESTAMP|INCREMENT|ENCRYPTED|PROCEDURE|COMMITTED|SUBSTRING|EXCEPTION|VALIDATOR|UNBOUNDED|PARTITION|ATTRIBUTE|INITIALLY|EXCLUSIVE|SAVEPOINT|XMLEXISTS|ASSERTION|EXTENSION|STATEMENT|RETURNING|LEAKPROOF|RECURSIVE|FUNCTIONS|AGGREGATE|LOCALTIME|FOLLOWING|PRECEDING|PRECISION|SEQUENCES|XMLFOREST|TEMPORARY|EXCLUDING|DATABASE|XMLPARSE|CONTINUE|INHERITS|UNLOGGED|DEFAULTS|COMMENTS|DEFERRED|MINVALUE|TRAILING|VARIADIC|COALESCE|INTERVAL|OVERLAPS|MAXVALUE|IMPLICIT|DISTINCT|VOLATILE|DOCUMENT|SMALLINT|OPERATOR|SEQUENCE|CONSTANT|CASCADED|IDENTITY|ENCODING|SNAPSHOT|TRUNCATE|ROLLBACK|PREPARED|LANGUAGE|UNLISTEN|TEMPLATE|BACKWARD|VALIDATE|NATIONAL|REASSIGN|GREATEST|LC_CTYPE|EXTERNAL|PASSWORD|SECURITY|LOCATION|PRESERVE|FUNCTION|RELATIVE|POSITION|SQLSTATE|ABSOLUTE|RESTRICT|BOOLEAN|FORWARD|UNKNOWN|FOREIGN|RECHECK|NOTHING|NOTNULL|EXTRACT|NATURAL|GRANTED|EXPLAIN|EXECUTE|HANDLER|EXCLUDE|NUMERIC|TRUSTED|VERSION|TRIGGER|VERBOSE|WITHOUT|WRAPPER|OPTIONS|DISCARD|VARYING|DISABLE|DEFINER|DEFAULT|INDEXES|PRIMARY|DECLARE|DECIMAL|PROGRAM|RETURNS|CURRENT|XMLROOT|CONTENT|COMMENT|INSTEAD|COLLATE|INTEGER|CLUSTER|SESSION|VARCHAR|INVOKER|CATALOG|CASCADE|OVERLAY|RESTART|BETWEEN|REPLICA|PARTIAL|REPLACE|FOREACH|LATERAL|PASSING|PERFORM|LEADING|ANALYZE|ANALYSE|SIMILAR|REFRESH|MAPPING|RELEASE|PLACING|REVERSE|REINDEX|STORAGE|INHERIT|PREPARE|UPDATE|VACUUM|RENAME|ISNULL|VALUES|MINUTE|INSERT|INLINE|SCROLL|REVOKE|HEADER|HAVING|TABLES|SYSTEM|GLOBAL|FREEZE|UNIQUE|SCHEMA|SEARCH|FILTER|NOTIFY|SECOND|NOWAIT|FAMILY|NULLIF|EXISTS|EXCEPT|OBJECT|SELECT|ESCAPE|OFFSET|WINDOW|WITHIN|ENABLE|DOUBLE|OPTION|DOMAIN|DELETE|CURSOR|CREATE|SERVER|COMMIT|COLUMN|SIMPLE|CALLED|BINARY|BIGINT|PARSER|STABLE|BEFORE|NOTICE|ALWAYS|STDOUT|RETURN|POLICY|STRICT|ACTION|ACCESS|LISTEN|ABORT|PLANS|MONTH|PRIOR|OWNER|OWNED|OUTER|ORDER|QUOTE|RANGE|TREAT|TYPES|NULLS|UNION|NCHAR|NAMES|UNTIL|MATCH|LOCAL|USING|LIMIT|LEVEL|LEAST|LARGE|LABEL|RESET|VALUE|INPUT|INOUT|INNER|INDEX|RIGHT|ILIKE|VIEWS|GROUP|TABLE|GRANT|WHERE|FORCE|FLOAT|FIRST|FETCH|FALSE|EVENT|WRITE|CYCLE|CROSS|XMLPI|CLOSE|CLASS|SYSID|SETOF|SHARE|CHECK|WHILE|CHAIN|ALIAS|CACHE|ELSIF|BEGIN|ARRAY|START|QUERY|RAISE|STDIN|ALTER|AFTER|ADMIN|STRIP|VALID|WORK|ALSO|RULE|ROWS|OPEN|ROLE|TEMP|LOOP|REAL|TEXT|THEN|TIME|READ|SOME|OVER|EXIT|BOTH|ONLY|TRIM|TRUE|CASE|OIDS|TYPE|CAST|ZONE|NULL|YEAR|NONE|CHAR|NEXT|NAME|MOVE|MODE|LOCK|USER|LOAD|LIKE|LEFT|LAST|COST|JOIN|DATA|INTO|DESC|DROP|ELSE|HOUR|VIEW|HOLD|FULL|WHEN|FROM|EACH|ENUM|WITH|SHOW|COPY|OUT|FOR|ADD|XML|ALL|INT|DEC|DAY|SET|CSV|KEY|AND|ANY|NOT|YES|ROW|END|ASC|REF|GET|BIT|OFF|TO|OR|BY|ON|OF|AS|NO|AT|IS|DO|IN|IF)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="[+*/<>=~!@#%^&|`?-]+"> + <token type="Operator"/> + </rule> + <rule pattern="::"> + <token type="Operator"/> + </rule> + <rule pattern="\$\d+"> + <token type="NameVariable"/> + </rule> + <rule pattern="([0-9]*\.[0-9]*|[0-9]+)(e[+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="((?:E|U&)?)(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="string"/> + </rule> + <rule pattern="((?:U&)?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringName"/> + </bygroups> + <push state="quoted-ident"/> + </rule> + <rule pattern="[a-z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern=":(['"]?)[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> + <state name="string"> + <rule pattern="[^']+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="''"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + </state> + <state name="quoted-ident"> + <rule pattern="[^"]+"> + <token type="LiteralStringName"/> + </rule> + <rule pattern=""""> + <token type="LiteralStringName"/> + </rule> + <rule pattern="""> + <token type="LiteralStringName"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/plutus_core.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/plutus_core.xml new file mode 100644 index 0000000..4ff5a97 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/plutus_core.xml @@ -0,0 +1,105 @@ +<lexer> + <config> + <name>Plutus Core</name> + <alias>plutus-core</alias> + <alias>plc</alias> + <filename>*.plc</filename> + <mime_type>text/x-plutus-core</mime_type> + <mime_type>application/x-plutus-core</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(\(|\))"> + <token type="Punctuation"/> + </rule> + <rule pattern="(\[|\])"> + <token type="Punctuation"/> + </rule> + <rule pattern="({|})"> + <token type="Punctuation"/> + </rule> + <rule pattern="([+-]?\d+)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(#([a-fA-F0-9][a-fA-F0-9])+)"> + <token type="LiteralString"/> + </rule> + <rule pattern="(\(\))"> + <token type="NameConstant"/> + </rule> + <rule pattern="(True|False)"> + <token type="NameConstant"/> + </rule> + <rule pattern="(con |abs |iwrap |unwrap |lam |builtin |delay |force |error)"> + <token type="Keyword"/> + </rule> + <rule pattern="(fun |all |ifix |lam |con )"> + <token type="Keyword"/> + </rule> + <rule pattern="(type|fun )"> + <token type="Keyword"/> + </rule> + <rule pattern="(program )(\S+)"> + <bygroups> + <token type="Keyword"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(unit|bool|integer|bytestring|string)"> + <token type="KeywordType"/> + </rule> + <rule pattern="(addInteger |subtractInteger |multiplyInteger |divideInteger |quotientInteger |remainderInteger |modInteger |equalsInteger |lessThanInteger |lessThanEqualsInteger )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(appendByteString |consByteString |sliceByteString |lengthOfByteString |indexByteString |equalsByteString |lessThanByteString |lessThanEqualsByteString )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(sha2_256 |sha3_256 |blake2b_256 |verifySignature )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(appendString |equalsString |encodeUtf8 |decodeUtf8 )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(ifThenElse )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(chooseUnit )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(trace )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(fstPair |sndPair )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(chooseList |mkCons |headList |tailList |nullList )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(chooseData |constrData |mapData |listData |iData |bData |unConstrData |unMapData |unListData |unIData |unBData |equalsData )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(mkPairData |mkNilData |mkNilPairData )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="([a-zA-Z][a-zA-Z0-9_']*)"> + <token type="Name"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^\\"]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pony.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pony.xml new file mode 100644 index 0000000..4efa9db --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/pony.xml @@ -0,0 +1,135 @@ +<lexer> + <config> + <name>Pony</name> + <alias>pony</alias> + <filename>*.pony</filename> + </config> + <rules> + <state name="string"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\""> + <token type="LiteralString"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralString"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="//.*\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="nested_comment"/> + </rule> + <rule pattern=""""(?:.|\n)*?""""> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="\'.*\'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="=>|[]{}:().~;,|&!^?[]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(addressof|digestof|consume|isnt|and|not|as|is|or)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="!=|==|<<|>>|[-+/*%=<>]"> + <token type="Operator"/> + </rule> + <rule pattern="(compile_intrinsic|compile_error|continue|recover|return|repeat|lambda|elseif|object|#share|match|#send|#read|ifdef|until|embed|while|where|error|break|with|else|#any|this|then|tag|for|trn|try|ref|use|var|val|let|end|iso|box|in|if|do)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(actor|class|struct|primitive|interface|trait|type)((?:\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="typename"/> + </rule> + <rule pattern="(new|fun|be)((?:\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="methodname"/> + </rule> + <rule pattern="(DisposableActor|NullablePointer|AsioEventNotify|UnsignedInteger|RuntimeOptions|DoNotOptimise|FloatingPoint|SignedInteger|ReadElement|ArrayValues|StringBytes|StringRunes|InputNotify|InputStream|AsioEventID|ByteSeqIter|AmbientAuth|Comparable|ArrayPairs|Stringable|OutStream|SourceLoc|ArrayKeys|StdStream|Equatable|AsioEvent|Iterator|Platform|Unsigned|Greater|Compare|Integer|Pointer|ReadSeq|ByteSeq|String|Number|Signed|Float|USize|Stdin|ILong|ISize|HasEq|Array|ULong|Equal|I128|U128|Bool|Less|Real|None|Seq|I64|Any|F32|F64|U64|U32|I32|Int|I16|U16|Env|I8|U8)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="_?[A-Z]\w*"> + <token type="NameClass"/> + </rule> + <rule pattern="string\(\)"> + <token type="NameOther"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0x[0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="_\d*"> + <token type="Name"/> + </rule> + <rule pattern="_?[a-z][\w\'_]*"> + <token type="Name"/> + </rule> + </state> + <state name="typename"> + <rule pattern="(iso|trn|ref|val|box|tag)?((?:\s)*)(_?[A-Z]\w*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + <state name="methodname"> + <rule pattern="(iso|trn|ref|val|box|tag)?((?:\s)*)(_?[a-z]\w*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + <state name="nested_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> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/postscript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/postscript.xml new file mode 100644 index 0000000..15a3422 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/postscript.xml @@ -0,0 +1,89 @@ +<lexer> + <config> + <name>PostScript</name> + <alias>postscript</alias> + <alias>postscr</alias> + <filename>*.ps</filename> + <filename>*.eps</filename> + <mime_type>application/postscript</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="^%!.+\n"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="%%.*\n"> + <token type="CommentSpecial"/> + </rule> + <rule pattern="(^%.*\n){2,}"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="%.*\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\("> + <token type="LiteralString"/> + <push state="stringliteral"/> + </rule> + <rule pattern="[{}<>\[\]]"> + <token type="Punctuation"/> + </rule> + <rule pattern="<[0-9A-Fa-f]+>(?=[()<>\[\]{}/%\s])"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9]+\#(\-|\+)?([0-9]+\.?|[0-9]*\.[0-9]+|[0-9]+\.[0-9]*)((e|E)[0-9]+)?(?=[()<>\[\]{}/%\s])"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="(\-|\+)?([0-9]+\.?|[0-9]*\.[0-9]+|[0-9]+\.[0-9]*)((e|E)[0-9]+)?(?=[()<>\[\]{}/%\s])"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(\-|\+)?[0-9]+(?=[()<>\[\]{}/%\s])"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\/[^()<>\[\]{}/%\s]+(?=[()<>\[\]{}/%\s])"> + <token type="NameVariable"/> + </rule> + <rule pattern="[^()<>\[\]{}/%\s]+(?=[()<>\[\]{}/%\s])"> + <token type="NameFunction"/> + </rule> + <rule pattern="(false|true)(?=[()<>\[\]{}/%\s])"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(eq|ne|g[et]|l[et]|and|or|not|if(?:else)?|for(?:all)?)(?=[()<>\[\]{}/%\s])"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(dictstackoverflow|undefinedfilename|currentlinewidth|undefinedresult|currentmatrix|defaultmatrix|invertmatrix|concatmatrix|currentpoint|setlinewidth|syntaxerror|idtransform|identmatrix|setrgbcolor|stringwidth|setlinejoin|getinterval|itransform|strokepath|pathforall|rangecheck|setlinecap|dtransform|transform|translate|setmatrix|typecheck|undefined|scalefont|closepath|findfont|showpage|rcurveto|grestore|truncate|pathbbox|charpath|rlineto|rmoveto|ceiling|newpath|setdash|setfont|restore|curveto|setgray|stroke|pstack|matrix|length|lineto|repeat|rotate|moveto|shfill|concat|gsave|aload|scale|array|round|stack|index|begin|print|floor|exch|quit|clip|copy|bind|loop|idiv|fill|show|roll|exit|load|dict|save|arcn|sqrt|exec|rand|atan|end|div|abs|run|def|cvs|exp|cvi|sin|cos|get|dup|mod|put|sub|pop|add|neg|mul|arc|log|ln|gt)(?=[()<>\[\]{}/%\s])"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + <state name="stringliteral"> + <rule pattern="[^()\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringEscape"/> + <push state="escape"/> + </rule> + <rule pattern="\("> + <token type="LiteralString"/> + <push/> + </rule> + <rule pattern="\)"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="escape"> + <rule pattern="[0-8]{3}|n|r|t|b|f|\\|\(|\)"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/povray.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/povray.xml new file mode 100644 index 0000000..f37dab9 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/povray.xml @@ -0,0 +1,58 @@ +<lexer> + <config> + <name>POVRay</name> + <alias>pov</alias> + <filename>*.pov</filename> + <filename>*.inc</filename> + <mime_type>text/x-povray</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="/\*[\w\W]*?\*/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="//.*\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(?s)"(?:\\.|[^"\\])+""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="#(statistics|include|version|declare|default|warning|define|elseif|ifndef|switch|fclose|render|fopen|undef|error|debug|while|local|macro|range|ifdef|break|write|else|case|read|for|end|if)\b"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\b(atmospheric_attenuation|cylindrical_mapping|spherical_mapping|max_intersections|quadratic_spline|ultra_wide_angle|low_error_factor|distance_maximum|recursion_limit|irid_wavelength|volume_rendered|max_trace_level|global_settings|number_of_waves|vol_with_light|planar_mapping|gray_threshold|nearest_count|minimum_reuse|test_camera_4|assumed_gamma|ambient_light|volume_object|test_camera_3|max_iteration|linear_spline|fade_distance|test_camera_2|falloff_angle|test_camera_1|triangle_wave|orthographic|linear_sweep|hypercomplex|cubic_spline|eccentricity|material_map|vaxis_rotate|scallop_wave|quick_colour|aa_threshold|blur_samples|conic_sweep|error_bound|interpolate|file_exists|attenuating|quick_color|texture_map|focal_point|box_mapping|pigment_map|perspective|water_level|adc_bailout|hf_gray_16|use_colour|clipped_by|turb_depth|reflection|atmosphere|phong_size|turbulence|area_light|fog_offset|vnormalize|normal_map|sky_sphere|fade_power|brick_size|colour_map|background|statistics|brilliance|brightness|scattering|confidence|agate_turb|looks_like|quaternion|bounded_by|shadowless|reciprocal|black_hole|refraction|no_shadow|spotlight|transform|translate|roughness|tightness|use_index|incidence|sine_wave|arc_angle|image_map|threshold|slope_map|direction|thickness|composite|component|color_map|panoramic|ramp_wave|radiosity|use_color|max_value|bump_size|precision|frequency|dust_type|hierarchy|strength|gradient|pattern1|fog_type|pattern2|specular|constant|flatness|control0|wrinkles|control1|pattern3|adaptive|caustics|bump_map|exponent|metallic|transmit|aa_level|point_at|map_type|emitting|variance|location|distance|aperture|texture|leopard|ripples|ambient|warning|diffuse|look_at|rainbow|radians|u_steps|quilted|degrees|average|vrotate|default|declare|inverse|samples|include|pigment|version|falloff|spotted|crackle|checker|spiral2|vlength|spiral1|fisheye|octaves|hexagon|fog_alt|granite|omnimax|glowing|v_steps|radius|concat|spiral|smooth|hollow|offset|normal|finish|bumpy1|filter|colour|mortar|rotate|lambda|bumpy3|bumpy2|strcmp|linear|switch|substr|repeat|vcross|strupr|strlen|strlwr|render|matrix|marble|radial|mandel|jitter|tiles|dents|atanh|break|range|track|asinh|brick|waves|bumps|atan2|sturm|debug|onion|rgbft|angle|right|tile2|crand|acosh|error|scale|alpha|while|false|agate|ifdef|phong|phase|clock|width|slice|omega|color|floor|count|green|atan|blue|bozo|seed|case|sqrt|rgbt|warp|rgbf|ceil|cosh|rand|cube|vdot|dust|else|flip|asin|type|tanh|halo|wood|true|open|once|acos|sinh|irid|max|mod|min|all|log|off|ior|tga|iff|pgm|ttf|asc|png|tan|gif|abs|fog|sys|exp|end|val|pot|pow|div|ppm|pwr|red|cos|chr|rgb|sqr|sin|yes|str|int|sky|if|no|on|pi|up|t)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(smooth_triangle|superellipsoid|julia_fractal|bicubic_patch|light_source|height_field|intersection|difference|cylinder|triangle|polygon|quartic|quadric|camera|sphere|object|merge|plane|lathe|torus|prism|cubic|union|poly|mesh|disc|cone|text|blob|box|sor)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[\[\](){}<>;,]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[-+*/=]"> + <token type="Operator"/> + </rule> + <rule pattern="\b(x|y|z|u|v)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/powerquery.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/powerquery.xml new file mode 100644 index 0000000..0ff1e35 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/powerquery.xml @@ -0,0 +1,51 @@ +<lexer> + <config> + <name>PowerQuery</name> + <alias>powerquery</alias> + <alias>pq</alias> + <filename>*.pq</filename> + <mime_type>text/x-powerquery</mime_type> + <case_insensitive>true</case_insensitive> + <dot_all>true</dot_all> + </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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="(and|as|each|else|error|false|if|in|is|let|meta|not|null|or|otherwise|section|shared|then|true|try|type)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(#binary|#date|#datetime|#datetimezone|#duration|#infinity|#nan|#sections|#shared|#table|#time)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(([a-zA-Z]|_)[\w|._]*|#"[^"]+")"> + <token type="Name"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F][0-9a-fA-F_]*[lL]?"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="([0-9]+\.[0-9]+|\.[0-9]+)([eE][0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[\(\)\[\]\{\}]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\.\.|\.\.\.|=>|<=|>=|<>|[@!?,;=<>\+\-\*\/&]"> + <token type="Operator"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/powershell.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/powershell.xml new file mode 100644 index 0000000..d7bd02a --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/powershell.xml @@ -0,0 +1,150 @@ +<lexer> + <config> + <name>PowerShell</name> + <alias>powershell</alias> + <alias>posh</alias> + <alias>ps1</alias> + <alias>psm1</alias> + <alias>psd1</alias> + <filename>*.ps1</filename> + <filename>*.psm1</filename> + <filename>*.psd1</filename> + <mime_type>text/x-powershell</mime_type> + <case_insensitive>true</case_insensitive> + <dot_all>true</dot_all> + </config> + <rules> + <state name="root"> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="child"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="^(\s*#[#\s]*)(\.(?:component|description|example|externalhelp|forwardhelpcategory|forwardhelptargetname|functionality|inputs|link|notes|outputs|parameter|remotehelprunspace|role|synopsis))([^\n]*$)"> + <bygroups> + <token type="Comment"/> + <token type="LiteralStringDoc"/> + <token type="Comment"/> + </bygroups> + </rule> + <rule pattern="#[^\n]*?$"> + <token type="Comment"/> + </rule> + <rule pattern="(&lt;|<)#"> + <token type="CommentMultiline"/> + <push state="multline"/> + </rule> + <rule pattern="(?i)([A-Z]:)"> + <token type="Name"/> + </rule> + <rule pattern="@"\n"> + <token type="LiteralStringHeredoc"/> + <push state="heredoc-double"/> + </rule> + <rule pattern="@'\n.*?\n'@"> + <token type="LiteralStringHeredoc"/> + </rule> + <rule pattern="`[\'"$@-]"> + <token type="Punctuation"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="'([^']|'')*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="(\$|@@|@)((global|script|private|env):)?\w+"> + <token type="NameVariable"/> + </rule> + <rule pattern="[a-z]\w*-[a-z]\w*\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(while|validateset|validaterange|validatepattern|validatelength|validatecount|until|trap|switch|return|ref|process|param|parameter|in|if|global:|function|foreach|for|finally|filter|end|elseif|else|dynamicparam|do|default|continue|cmdletbinding|break|begin|alias|\?|%|#script|#private|#local|#global|mandatory|parametersetname|position|valuefrompipeline|valuefrompipelinebypropertyname|valuefromremainingarguments|helpmessage|try|catch|throw)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="-(and|as|band|bnot|bor|bxor|casesensitive|ccontains|ceq|cge|cgt|cle|clike|clt|cmatch|cne|cnotcontains|cnotlike|cnotmatch|contains|creplace|eq|exact|f|file|ge|gt|icontains|ieq|ige|igt|ile|ilike|ilt|imatch|ine|inotcontains|inotlike|inotmatch|ireplace|is|isnot|le|like|lt|match|ne|not|notcontains|notlike|notmatch|or|regex|replace|wildcard)\b"> + <token type="Operator"/> + </rule> + <rule pattern="(ac|asnp|cat|cd|cfs|chdir|clc|clear|clhy|cli|clp|cls|clv|cnsn|compare|copy|cp|cpi|cpp|curl|cvpa|dbp|del|diff|dir|dnsn|ebp|echo|epal|epcsv|epsn|erase|etsn|exsn|fc|fhx|fl|foreach|ft|fw|gal|gbp|gc|gci|gcm|gcs|gdr|ghy|gi|gjb|gl|gm|gmo|gp|gps|gpv|group|gsn|gsnp|gsv|gu|gv|gwmi|h|history|icm|iex|ihy|ii|ipal|ipcsv|ipmo|ipsn|irm|ise|iwmi|iwr|kill|lp|ls|man|md|measure|mi|mount|move|mp|mv|nal|ndr|ni|nmo|npssc|nsn|nv|ogv|oh|popd|ps|pushd|pwd|r|rbp|rcjb|rcsn|rd|rdr|ren|ri|rjb|rm|rmdir|rmo|rni|rnp|rp|rsn|rsnp|rujb|rv|rvpa|rwmi|sajb|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spjb|spps|spsv|start|sujb|sv|swmi|tee|trcm|type|wget|where|wjb|write)\s"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\[[a-z_\[][\w. `,\[\]]*\]"> + <token type="NameConstant"/> + </rule> + <rule pattern="-[a-z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="\w+"> + <token type="Name"/> + </rule> + <rule pattern="[.,;@{}\[\]$()=+*/\\&%!~?^`|<>-]|::"> + <token type="Punctuation"/> + </rule> + </state> + <state name="child"> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="multline"> + <rule pattern="[^#&.]+"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="#(>|&gt;)"> + <token type="CommentMultiline"/> + <pop depth="1"/> + </rule> + <rule pattern="\.(component|description|example|externalhelp|forwardhelpcategory|forwardhelptargetname|functionality|inputs|link|notes|outputs|parameter|remotehelprunspace|role|synopsis)"> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="[#&.]"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="string"> + <rule pattern="`[0abfnrtv'\"$`]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^$`"]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\$\("> + <token type="Punctuation"/> + <push state="child"/> + </rule> + <rule pattern=""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[`$]"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + <state name="heredoc-double"> + <rule pattern="\n"@"> + <token type="LiteralStringHeredoc"/> + <pop depth="1"/> + </rule> + <rule pattern="\$\("> + <token type="Punctuation"/> + <push state="child"/> + </rule> + <rule pattern="[^@\n]+"]"> + <token type="LiteralStringHeredoc"/> + </rule> + <rule pattern="."> + <token type="LiteralStringHeredoc"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/prolog.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/prolog.xml new file mode 100644 index 0000000..391bae3 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/prolog.xml @@ -0,0 +1,115 @@ +<lexer> + <config> + <name>Prolog</name> + <alias>prolog</alias> + <filename>*.ecl</filename> + <filename>*.prolog</filename> + <filename>*.pro</filename> + <filename>*.pl</filename> + <mime_type>text/x-prolog</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="nested-comment"/> + </rule> + <rule pattern="%.*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="0\'."> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="0b[01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0o[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0x[0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d\d?\'[a-zA-Z0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[\[\](){}|.,;!]"> + <token type="Punctuation"/> + </rule> + <rule pattern=":-|-->"> + <token type="Punctuation"/> + </rule> + <rule pattern=""(?:\\x[0-9a-fA-F]+\\|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\[0-7]+\\|\\["\nabcefnrstv]|[^\\"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(?:''|[^'])*'"> + <token type="LiteralStringAtom"/> + </rule> + <rule pattern="is\b"> + <token type="Operator"/> + </rule> + <rule pattern="(<|>|=<|>=|==|=:=|=|/|//|\*|\+|-)(?=\s|[a-zA-Z0-9\[])"> + <token type="Operator"/> + </rule> + <rule pattern="(mod|div|not)\b"> + <token type="Operator"/> + </rule> + <rule pattern="_"> + <token type="Keyword"/> + </rule> + <rule pattern="([a-z]+)(:)"> + <bygroups> + <token type="NameNamespace"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="([a-zÀ---][\w$À---]*)(\s*)(:-|-->)"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </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="LiteralStringAtom"/> + </rule> + <rule pattern="[#&*+\-./:<=>?@\\^~¡-¿‐-〿]+"> + <token type="LiteralStringAtom"/> + </rule> + <rule pattern="[A-Z_]\w*"> + <token type="NameVariable"/> + </rule> + <rule pattern="\s+|[ --�]"> + <token type="Text"/> + </rule> + </state> + <state name="nested-comment"> + <rule pattern="\*/"> + <token type="CommentMultiline"/> + <pop depth="1"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push/> + </rule> + <rule pattern="[^*/]+"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="[*/]"> + <token type="CommentMultiline"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/promql.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/promql.xml new file mode 100644 index 0000000..e95e333 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/promql.xml @@ -0,0 +1,123 @@ +<lexer> + <config> + <name>PromQL</name> + <alias>promql</alias> + <filename>*.promql</filename> + </config> + <rules> + <state name="range"> + <rule pattern="\]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="[1-9][0-9]*[smhdwy]"> + <token type="LiteralString"/> + </rule> + </state> + <state name="function"> + <rule pattern="\)"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule pattern="\("> + <token type="Operator"/> + <push/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="(group_right|group_left|ignoring|without|offset|bool|on|by)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(count_values|quantile|bottomk|stdvar|stddev|count|group|topk|sum|min|max|avg)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(histogram_quantile|quantile_over_time|absent_over_time|stdvar_over_time|stddev_over_time|count_over_time|predict_linear|label_replace|max_over_time|avg_over_time|sum_over_time|days_in_month|min_over_time|day_of_month|holt_winters|day_of_week|label_join|sort_desc|clamp_max|timestamp|clamp_min|increase|changes|resets|vector|absent|idelta|minute|scalar|log10|delta|month|floor|deriv|round|irate|rate|year|sort|log2|sqrt|ceil|time|hour|abs|exp|ln)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="[1-9][0-9]*[smhdwy]"> + <token type="LiteralString"/> + </rule> + <rule pattern="-?[0-9]+\.[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="-?[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="#.*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(\+|\-|\*|\/|\%|\^)"> + <token type="Operator"/> + </rule> + <rule pattern="==|!=|>=|<=|<|>"> + <token type="Operator"/> + </rule> + <rule pattern="and|or|unless"> + <token type="OperatorWord"/> + </rule> + <rule pattern="[_a-zA-Z][a-zA-Z0-9_]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(["\'])(.*?)(["\'])"> + <bygroups> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="\("> + <token type="Operator"/> + <push state="function"/> + </rule> + <rule pattern="\)"> + <token type="Operator"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="labels"/> + </rule> + <rule pattern="\["> + <token type="Punctuation"/> + <push state="range"/> + </rule> + </state> + <state name="labels"> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern=","> + <token type="Punctuation"/> + </rule> + <rule pattern="([_a-zA-Z][a-zA-Z0-9_]*?)(\s*?)(=~|!=|=|!~)(\s*?)("|')(.*?)("|')"> + <bygroups> + <token type="NameLabel"/> + <token type="TextWhitespace"/> + <token type="Operator"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/protobuf.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/protobuf.xml new file mode 100644 index 0000000..98ae7c8 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/protobuf.xml @@ -0,0 +1,118 @@ +<lexer> + <config> + <name>Protocol Buffer</name> + <alias>protobuf</alias> + <alias>proto</alias> + <filename>*.proto</filename> + </config> + <rules> + <state name="root"> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern="[,;{}\[\]()<>]"> + <token type="Punctuation"/> + </rule> + <rule pattern="/(\\\n)?/(\n|(.|\n)*?[^\\]\n)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/(\\\n)?\*(.|\n)*?\*(\\\n)?/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="\b(extensions|required|repeated|optional|returns|default|option|packed|import|ctype|oneof|max|rpc|to)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(sfixed32|sfixed64|fixed32|fixed64|sint32|sint64|double|string|uint32|uint64|int32|float|int64|bytes|bool)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(package)(\s+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="package"/> + </rule> + <rule pattern="(message|extend)(\s+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + </bygroups> + <push state="message"/> + </rule> + <rule pattern="(enum|group|service)(\s+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + </bygroups> + <push state="type"/> + </rule> + <rule pattern="\".*?\""> + <token type="LiteralString"/> + </rule> + <rule pattern="\'.*?\'"> + <token type="LiteralString"/> + </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="(\-?(inf|nan))\b"> + <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="Operator"/> + </rule> + <rule pattern="([a-zA-Z_][\w.]*)([ \t]*)(=)"> + <bygroups> + <token type="Name"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="[a-zA-Z_][\w.]*"> + <token type="Name"/> + </rule> + </state> + <state name="package"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="message"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="type"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/puppet.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/puppet.xml new file mode 100644 index 0000000..fbb587c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/puppet.xml @@ -0,0 +1,100 @@ +<lexer> + <config> + <name>Puppet</name> + <alias>puppet</alias> + <filename>*.pp</filename> + </config> + <rules> + <state name="strings"> + <rule pattern=""([^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'(\\'|[^'])*'"> + <token type="LiteralString"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="comments"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="names"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule> + <include state="operators"/> + </rule> + <rule> + <include state="strings"/> + </rule> + <rule pattern="[]{}:(),;[]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + </state> + <state name="comments"> + <rule pattern="\s*#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="/(\\\n)?[*](.|\n)*?[*](\\\n)?/"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="operators"> + <rule pattern="(=>|\?|<|>|=|\+|-|/|\*|~|!|\|)"> + <token type="Operator"/> + </rule> + <rule pattern="(in|and|or|not)\b"> + <token type="OperatorWord"/> + </rule> + </state> + <state name="names"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameAttribute"/> + </rule> + <rule pattern="(\$\S+)(\[)(\S+)(\])"> + <bygroups> + <token type="NameVariable"/> + <token type="Punctuation"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="\$\S+"> + <token type="NameVariable"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+[eE][+-]?[0-9]+j?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[0-7]+j?"> + <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+j?"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(?i)(nagios_servicedependency|nagios_serviceescalation|nagios_hostdependency|nagios_hostescalation|nagios_serviceextinfo|nagios_contactgroup|nagios_servicegroup|ssh_authorized_key|nagios_hostextinfo|nagios_timeperiod|nagios_hostgroup|macauthorization|create_resources|inline_template|scheduled_task|nagios_contact|nagios_command|nagios_service|nagios_host|configured|versioncmp|selboolean|filebucket|shellquote|selmodule|extlookup|unmounted|interface|contained|resources|fqdn_rand|installed|mailalias|directory|subscribe|loglevel|computer|maillist|schedule|generate|template|regsubst|inherits|present|sprintf|service|stopped|running|package|realize|defined|mounted|warning|yumrepo|k5login|include|default|notice|purged|latest|router|search|sshkey|define|notify|absent|before|augeas|import|tagged|split|undef|mount|check|alert|class|audit|debug|alias|stage|elsif|false|zpool|emerg|noop|sha1|vlan|exec|fail|file|else|host|info|cron|role|link|zone|tidy|true|node|case|user|crit|err|mcx|zfs|md5|tag|if)\b"> + <token type="Keyword"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/python.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/python.xml new file mode 100644 index 0000000..e928672 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/python.xml @@ -0,0 +1,589 @@ +<lexer> + <config> + <name>Python</name> + <alias>python</alias> + <alias>py</alias> + <alias>sage</alias> + <alias>python3</alias> + <alias>py3</alias> + <filename>*.py</filename> + <filename>*.pyi</filename> + <filename>*.pyw</filename> + <filename>*.jy</filename> + <filename>*.sage</filename> + <filename>*.sc</filename> + <filename>SConstruct</filename> + <filename>SConscript</filename> + <filename>*.bzl</filename> + <filename>BUCK</filename> + <filename>BUILD</filename> + <filename>BUILD.bazel</filename> + <filename>WORKSPACE</filename> + <filename>*.tac</filename> + <mime_type>text/x-python</mime_type> + <mime_type>application/x-python</mime_type> + <mime_type>text/x-python3</mime_type> + <mime_type>application/x-python3</mime_type> + </config> + <rules> + <state name="numbers"> + <rule pattern="(\d(?:_?\d)*\.(?:\d(?:_?\d)*)?|(?:\d(?:_?\d)*)?\.\d(?:_?\d)*)([eE][+-]?\d(?:_?\d)*)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d(?:_?\d)*[eE][+-]?\d(?:_?\d)*j?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[oO](?:_?[0-7])+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[bB](?:_?[01])+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0[xX](?:_?[a-fA-F0-9])+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d(?:_?\d)*"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="expr"> + <rule pattern="(?i)(rf|fr)(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="rfstringescape" state="tdqf"/> + </rule> + <rule pattern="(?i)(rf|fr)(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="rfstringescape" state="tsqf"/> + </rule> + <rule pattern="(?i)(rf|fr)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="rfstringescape" state="dqf"/> + </rule> + <rule pattern="(?i)(rf|fr)(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="rfstringescape" state="sqf"/> + </rule> + <rule pattern="([fF])(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="fstringescape" state="tdqf"/> + </rule> + <rule pattern="([fF])(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="fstringescape" state="tsqf"/> + </rule> + <rule pattern="([fF])(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="fstringescape" state="dqf"/> + </rule> + <rule pattern="([fF])(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="fstringescape" state="sqf"/> + </rule> + <rule pattern="(?i)(rb|br|r)(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <push state="tdqs"/> + </rule> + <rule pattern="(?i)(rb|br|r)(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="tsqs"/> + </rule> + <rule pattern="(?i)(rb|br|r)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <push state="dqs"/> + </rule> + <rule pattern="(?i)(rb|br|r)(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="sqs"/> + </rule> + <rule pattern="([uUbB]?)(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="stringescape" state="tdqs"/> + </rule> + <rule pattern="([uUbB]?)(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="stringescape" state="tsqs"/> + </rule> + <rule pattern="([uUbB]?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="stringescape" state="dqs"/> + </rule> + <rule pattern="([uUbB]?)(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="stringescape" state="sqs"/> + </rule> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule pattern="!=|==|<<|>>|:=|[-~+/*%=<>&^|.]"> + <token type="Operator"/> + </rule> + <rule pattern="[]{}:(),;[]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(in|is|and|or|not)\b"> + <token type="OperatorWord"/> + </rule> + <rule> + <include state="expr-keywords"/> + </rule> + <rule> + <include state="builtins"/> + </rule> + <rule> + <include state="magicfuncs"/> + </rule> + <rule> + <include state="magicvars"/> + </rule> + <rule> + <include state="name"/> + </rule> + </state> + <state name="fstrings-double"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="\{"> + <token type="LiteralStringInterpol"/> + <push state="expr-inside-fstring"/> + </rule> + <rule pattern="[^\\\'"{}\n]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(yield from|nonlocal|continue|finally|except|lambda|assert|global|return|raise|yield|while|break|await|async|pass|else|elif|with|try|for|del|as|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(False|True|None)\b"> + <token type="KeywordConstant"/> + </rule> + </state> + <state name="dqs"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\"|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings-double"/> + </rule> + </state> + <state name="fromimport"> + <rule pattern="(\s+)(import)\b"> + <bygroups> + <token type="Text"/> + <token type="KeywordNamespace"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="\."> + <token type="NameNamespace"/> + </rule> + <rule pattern="None\b"> + <token type="NameBuiltinPseudo"/> + <pop depth="1"/> + </rule> + <rule pattern="[_\p{L}][_\p{L}\p{N}]*"> + <token type="NameNamespace"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="builtins"> + <rule pattern="(?<!\.)(staticmethod|classmethod|memoryview|__import__|issubclass|isinstance|frozenset|bytearray|enumerate|reversed|property|compile|complex|delattr|hasattr|setattr|globals|getattr|divmod|filter|locals|format|object|sorted|slice|print|bytes|range|input|tuple|round|super|float|eval|list|dict|repr|type|vars|hash|next|bool|open|iter|oct|pow|min|zip|max|map|bin|len|set|any|dir|all|abs|str|sum|chr|int|hex|ord|id)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<!\.)(self|Ellipsis|NotImplemented|cls)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(?<!\.)(PendingDeprecationWarning|ConnectionAbortedError|ConnectionRefusedError|UnicodeTranslateError|ConnectionResetError|ModuleNotFoundError|NotImplementedError|FloatingPointError|StopAsyncIteration|UnicodeDecodeError|DeprecationWarning|UnicodeEncodeError|NotADirectoryError|ProcessLookupError|ZeroDivisionError|IsADirectoryError|FileNotFoundError|UnboundLocalError|KeyboardInterrupt|ChildProcessError|EnvironmentError|IndentationError|InterruptedError|BlockingIOError|ArithmeticError|ConnectionError|BrokenPipeError|FileExistsError|ResourceWarning|PermissionError|RuntimeWarning|ReferenceError|AttributeError|AssertionError|UnicodeWarning|RecursionError|StopIteration|BaseException|OverflowError|SyntaxWarning|FutureWarning|GeneratorExit|ImportWarning|UnicodeError|TimeoutError|WindowsError|RuntimeError|BytesWarning|SystemError|UserWarning|MemoryError|ImportError|LookupError|BufferError|SyntaxError|SystemExit|ValueError|IndexError|NameError|Exception|TypeError|TabError|EOFError|KeyError|VMSError|Warning|OSError|IOError)\b"> + <token type="NameException"/> + </rule> + </state> + <state name="classname"> + <rule pattern="[_\p{L}][_\p{L}\p{N}]*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="import"> + <rule pattern="(\s+)(as)(\s+)"> + <bygroups> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="\."> + <token type="NameNamespace"/> + </rule> + <rule pattern="[_\p{L}][_\p{L}\p{N}]*"> + <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="tsqs"> + <rule pattern="'''"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings-single"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="strings-double"> + <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsaux%]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="\{((\w+)((\.\w+)|(\[[^\]]+\]))*)?(\![sra])?(\:(.?[<>=\^])?[-+ ]?#?0?(\d+)?,?(\.\d+)?[E-GXb-gnosx%]?)?\}"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^\\\'"%{\n]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="%|(\{{1,2})"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="tdqf"> + <rule pattern="""""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule> + <include state="fstrings-double"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="expr-inside-fstring-inner"> + <rule pattern="[{([]"> + <token type="Punctuation"/> + <push state="expr-inside-fstring-inner"/> + </rule> + <rule pattern="[])}]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule> + <include state="expr"/> + </rule> + </state> + <state name="sqs"> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\'|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings-single"/> + </rule> + </state> + <state name="funcname"> + <rule> + <include state="magicfuncs"/> + </rule> + <rule pattern="[_\p{L}][_\p{L}\p{N}]*"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="expr-keywords"> + <rule pattern="(yield from|async for|lambda|yield|await|else|for|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(False|True|None)\b"> + <token type="KeywordConstant"/> + </rule> + </state> + <state name="name"> + <rule pattern="@[_\p{L}][_\p{L}\p{N}]*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="@"> + <token type="Operator"/> + </rule> + <rule pattern="[_\p{L}][_\p{L}\p{N}]*"> + <token type="Name"/> + </rule> + </state> + <state name="magicfuncs"> + <rule pattern="(__instancecheck__|__subclasscheck__|__getattribute__|__length_hint__|__rfloordiv__|__ifloordiv__|__itruediv__|__contains__|__floordiv__|__rtruediv__|__reversed__|__setitem__|__complex__|__rdivmod__|__delattr__|__rmatmul__|__ilshift__|__prepare__|__delitem__|__rrshift__|__imatmul__|__rlshift__|__setattr__|__truediv__|__getitem__|__missing__|__getattr__|__irshift__|__rshift__|__format__|__invert__|__matmul__|__divmod__|__delete__|__aenter__|__lshift__|__await__|__bytes__|__anext__|__aiter__|__aexit__|__round__|__float__|__enter__|__index__|__iadd__|__ipow__|__rpow__|__iter__|__init__|__ixor__|__rmul__|__rmod__|__imul__|__imod__|__iand__|__hash__|__rsub__|__exit__|__rxor__|__bool__|__call__|__rand__|__next__|__radd__|__isub__|__repr__|__set__|__add__|__new__|__neg__|__xor__|__and__|__mul__|__mod__|__sub__|__len__|__str__|__ror__|__ior__|__pos__|__del__|__get__|__dir__|__abs__|__int__|__pow__|__eq__|__gt__|__le__|__lt__|__ne__|__or__|__ge__)\b"> + <token type="NameFunctionMagic"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="\A#!.+$"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="\\"> + <token type="Text"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule pattern="(def)((?:\s|\\\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="funcname"/> + </rule> + <rule pattern="(class)((?:\s|\\\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="classname"/> + </rule> + <rule pattern="(from)((?:\s|\\\s)+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="fromimport"/> + </rule> + <rule pattern="(import)((?:\s|\\\s)+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="import"/> + </rule> + <rule> + <include state="expr"/> + </rule> + </state> + <state name="fstrings-single"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="\{"> + <token type="LiteralStringInterpol"/> + <push state="expr-inside-fstring"/> + </rule> + <rule pattern="[^\\\'"{}\n]+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="magicvars"> + <rule pattern="(__annotations__|__kwdefaults__|__qualname__|__objclass__|__defaults__|__closure__|__globals__|__weakref__|__module__|__class__|__bases__|__slots__|__file__|__code__|__name__|__func__|__dict__|__self__|__mro__|__doc__)\b"> + <token type="NameVariableMagic"/> + </rule> + </state> + <state name="tsqf"> + <rule pattern="'''"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule> + <include state="fstrings-single"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="strings-single"> + <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsaux%]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="\{((\w+)((\.\w+)|(\[[^\]]+\]))*)?(\![sra])?(\:(.?[<>=\^])?[-+ ]?#?0?(\d+)?,?(\.\d+)?[E-GXb-gnosx%]?)?\}"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^\\\'"%{\n]+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="%|(\{{1,2})"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="rfstringescape"> + <rule pattern="\{\{"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\}\}"> + <token type="LiteralStringEscape"/> + </rule> + </state> + <state name="sqf"> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\'|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="fstrings-single"/> + </rule> + </state> + <state name="dqf"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\"|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="fstrings-double"/> + </rule> + </state> + <state name="expr-inside-fstring"> + <rule pattern="[{([]"> + <token type="Punctuation"/> + <push state="expr-inside-fstring-inner"/> + </rule> + <rule pattern="(=\s*)?(\![sraf])?\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule pattern="(=\s*)?(\![sraf])?:"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule> + <include state="expr"/> + </rule> + </state> + <state name="tdqs"> + <rule pattern="""""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings-double"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="fstringescape"> + <rule> + <include state="rfstringescape"/> + </rule> + <rule> + <include state="stringescape"/> + </rule> + </state> + <state name="stringescape"> + <rule pattern="\\([\\abfnrtv"\']|\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> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/python_2.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/python_2.xml new file mode 100644 index 0000000..3297a22 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/python_2.xml @@ -0,0 +1,356 @@ +<lexer> + <config> + <name>Python 2</name> + <alias>python2</alias> + <alias>py2</alias> + <mime_type>text/x-python2</mime_type> + <mime_type>application/x-python2</mime_type> + </config> + <rules> + <state name="tdqs"> + <rule pattern="""""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings-double"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringDouble"/> + </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="magicfuncs"> + <rule pattern="(__instancecheck__|__subclasscheck__|__getattribute__|__rfloordiv__|__ifloordiv__|__setslice__|__getslice__|__contains__|__reversed__|__floordiv__|__rtruediv__|__itruediv__|__delslice__|__rlshift__|__rrshift__|__delitem__|__rdivmod__|__nonzero__|__missing__|__delattr__|__setattr__|__irshift__|__complex__|__setitem__|__getitem__|__truediv__|__unicode__|__ilshift__|__getattr__|__delete__|__coerce__|__invert__|__lshift__|__divmod__|__rshift__|__enter__|__index__|__float__|__iadd__|__rsub__|__init__|__imul__|__rpow__|__repr__|__rmul__|__isub__|__iter__|__rmod__|__ixor__|__call__|__imod__|__long__|__hash__|__rxor__|__idiv__|__iand__|__rdiv__|__ipow__|__rcmp__|__rand__|__exit__|__radd__|__str__|__cmp__|__pos__|__pow__|__oct__|__new__|__neg__|__mul__|__mod__|__set__|__xor__|__sub__|__len__|__and__|__get__|__rop__|__add__|__ior__|__div__|__iop__|__int__|__abs__|__hex__|__ror__|__del__|__eq__|__or__|__ne__|__lt__|__le__|__ge__|__gt__|__op__)\b"> + <token type="NameFunctionMagic"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(yield from|continue|finally|lambda|assert|global|except|return|print|yield|while|break|raise|elif|pass|exec|else|with|try|for|del|as|if)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="tsqs"> + <rule pattern="'''"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule> + <include state="strings-single"/> + </rule> + <rule pattern="\n"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="stringescape"> + <rule pattern="\\([\\abfnrtv"\']|\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="numbers"> + <rule pattern="(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+[eE][+-]?[0-9]+j?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[0-7]+j?"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[bB][01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0[xX][a-fA-F0-9]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\d+L"> + <token type="LiteralNumberIntegerLong"/> + </rule> + <rule pattern="\d+j?"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="import"> + <rule pattern="(?:[ \t]|\\\n)+"> + <token type="Text"/> + </rule> + <rule pattern="as\b"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern=","> + <token type="Operator"/> + </rule> + <rule pattern="[a-zA-Z_][\w.]*"> + <token type="NameNamespace"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="magicvars"> + <rule pattern="(__metaclass__|__defaults__|__globals__|__closure__|__weakref__|__module__|__slots__|__class__|__bases__|__file__|__func__|__dict__|__name__|__self__|__code__|__mro__|__doc__)\b"> + <token type="NameVariableMagic"/> + </rule> + </state> + <state name="fromimport"> + <rule pattern="(?:[ \t]|\\\n)+"> + <token type="Text"/> + </rule> + <rule pattern="import\b"> + <token type="KeywordNamespace"/> + <pop depth="1"/> + </rule> + <rule pattern="None\b"> + <token type="NameBuiltinPseudo"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-zA-Z_.][\w.]*"> + <token type="NameNamespace"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="strings-single"> + <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^\\\'"%\n]+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="%"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="funcname"> + <rule> + <include state="magicfuncs"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="classname"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="backtick"> + <rule pattern="`.*?`"> + <token type="LiteralStringBacktick"/> + </rule> + </state> + <state name="strings-double"> + <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="[^\\\'"%\n]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[\'"\\]"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="%"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="dqs"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\"|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings-double"/> + </rule> + </state> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDoc"/> + </bygroups> + </rule> + <rule pattern="[^\S\n]+"> + <token type="Text"/> + </rule> + <rule pattern="\A#!.+$"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </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="!=|==|<<|>>|[-~+/*%=<>&^|.]"> + <token type="Operator"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule pattern="(def)((?:\s|\\\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="funcname"/> + </rule> + <rule pattern="(class)((?:\s|\\\s)+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="classname"/> + </rule> + <rule pattern="(from)((?:\s|\\\s)+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="fromimport"/> + </rule> + <rule pattern="(import)((?:\s|\\\s)+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="import"/> + </rule> + <rule> + <include state="builtins"/> + </rule> + <rule> + <include state="magicfuncs"/> + </rule> + <rule> + <include state="magicvars"/> + </rule> + <rule> + <include state="backtick"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <push state="tdqs"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="tsqs"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <push state="dqs"/> + </rule> + <rule pattern="([rR]|[uUbB][rR]|[rR][uUbB])(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <push state="sqs"/> + </rule> + <rule pattern="([uUbB]?)(""")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="stringescape" state="tdqs"/> + </rule> + <rule pattern="([uUbB]?)(''')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="stringescape" state="tsqs"/> + </rule> + <rule pattern="([uUbB]?)(")"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringDouble"/> + </bygroups> + <combined state="stringescape" state="dqs"/> + </rule> + <rule pattern="([uUbB]?)(')"> + <bygroups> + <token type="LiteralStringAffix"/> + <token type="LiteralStringSingle"/> + </bygroups> + <combined state="stringescape" state="sqs"/> + </rule> + <rule> + <include state="name"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + </state> + <state name="sqs"> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\'|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="strings-single"/> + </rule> + </state> + <state name="builtins"> + <rule pattern="(?<!\.)(staticmethod|classmethod|__import__|isinstance|basestring|issubclass|frozenset|raw_input|bytearray|enumerate|property|callable|reversed|execfile|hasattr|setattr|compile|complex|delattr|unicode|globals|getattr|unichr|reduce|xrange|buffer|intern|filter|locals|divmod|coerce|sorted|reload|object|slice|round|float|super|input|bytes|apply|tuple|range|iter|dict|long|type|hash|vars|next|file|exit|open|repr|eval|bool|list|bin|pow|zip|ord|oct|min|set|any|max|map|all|len|sum|int|dir|hex|chr|abs|cmp|str|id)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<!\.)(self|None|Ellipsis|NotImplemented|False|True|cls)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(?<!\.)(PendingDeprecationWarning|UnicodeTranslateError|NotImplementedError|UnicodeDecodeError|DeprecationWarning|UnicodeEncodeError|FloatingPointError|ZeroDivisionError|UnboundLocalError|KeyboardInterrupt|EnvironmentError|IndentationError|OverflowWarning|ArithmeticError|ReferenceError|AttributeError|AssertionError|RuntimeWarning|UnicodeWarning|GeneratorExit|SyntaxWarning|StandardError|BaseException|OverflowError|FutureWarning|ImportWarning|StopIteration|UnicodeError|WindowsError|RuntimeError|ImportError|UserWarning|LookupError|SyntaxError|SystemError|MemoryError|SystemExit|ValueError|IndexError|NameError|Exception|TypeError|EOFError|KeyError|VMSError|TabError|IOError|Warning|OSError)\b"> + <token type="NameException"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/qbasic.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/qbasic.xml new file mode 100644 index 0000000..193fe18 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/qbasic.xml @@ -0,0 +1,173 @@ +<lexer> + <config> + <name>QBasic</name> + <alias>qbasic</alias> + <alias>basic</alias> + <filename>*.BAS</filename> + <filename>*.bas</filename> + <mime_type>text/basic</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\n+"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="^(\s*)(\d*)(\s*)(REM .*)$"> + <bygroups> + <token type="TextWhitespace"/> + <token type="NameLabel"/> + <token type="TextWhitespace"/> + <token type="CommentSingle"/> + </bygroups> + </rule> + <rule pattern="^(\s*)(\d+)(\s*)"> + <bygroups> + <token type="TextWhitespace"/> + <token type="NameLabel"/> + <token type="TextWhitespace"/> + </bygroups> + </rule> + <rule pattern="(?=[\s]*)(\w+)(?=[\s]*=)"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="(?=[^"]*)\'.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern=""[^\n"]*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="(END)(\s+)(FUNCTION|IF|SELECT|SUB)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="TextWhitespace"/> + <token type="KeywordReserved"/> + </bygroups> + </rule> + <rule pattern="(DECLARE)(\s+)([A-Z]+)(\s+)(\S+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="TextWhitespace"/> + <token type="NameVariable"/> + <token type="TextWhitespace"/> + <token type="Name"/> + </bygroups> + </rule> + <rule pattern="(DIM)(\s+)(SHARED)(\s+)([^\s(]+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="TextWhitespace"/> + <token type="NameVariable"/> + <token type="TextWhitespace"/> + <token type="NameVariableGlobal"/> + </bygroups> + </rule> + <rule pattern="(DIM)(\s+)([^\s(]+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="TextWhitespace"/> + <token type="NameVariableGlobal"/> + </bygroups> + </rule> + <rule pattern="^(\s*)([a-zA-Z_]+)(\s*)(\=)"> + <bygroups> + <token type="TextWhitespace"/> + <token type="NameVariableGlobal"/> + <token type="TextWhitespace"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="(GOTO|GOSUB)(\s+)(\w+\:?)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="TextWhitespace"/> + <token type="NameLabel"/> + </bygroups> + </rule> + <rule pattern="(SUB)(\s+)(\w+\:?)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="TextWhitespace"/> + <token type="NameLabel"/> + </bygroups> + </rule> + <rule> + <include state="declarations"/> + </rule> + <rule> + <include state="functions"/> + </rule> + <rule> + <include state="metacommands"/> + </rule> + <rule> + <include state="operators"/> + </rule> + <rule> + <include state="statements"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule pattern="[a-zA-Z_]\w*[$@#&!]"> + <token type="NameVariableGlobal"/> + </rule> + <rule pattern="[a-zA-Z_]\w*\:"> + <token type="NameLabel"/> + </rule> + <rule pattern="\-?\d*\.\d+[@|#]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\-?\d+[@|#]"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\-?\d+#?"> + <token type="LiteralNumberIntegerLong"/> + </rule> + <rule pattern="\-?\d+#?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="!=|==|:=|\.=|<<|>>|[-~+/\\*%=<>&^|?:!.]"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\]{}(),;]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[\w]+"> + <token type="NameVariableGlobal"/> + </rule> + </state> + <state name="declarations"> + <rule pattern="\b(DATA|LET)(?=\(|\b)"> + <token type="KeywordDeclaration"/> + </rule> + </state> + <state name="functions"> + <rule pattern="\b(ABS|ASC|ATN|CDBL|CHR\$|CINT|CLNG|COMMAND\$|COS|CSNG|CSRLIN|CVD|CVDMBF|CVI|CVL|CVS|CVSMBF|DATE\$|ENVIRON\$|EOF|ERDEV|ERDEV\$|ERL|ERR|EXP|FILEATTR|FIX|FRE|FREEFILE|HEX\$|INKEY\$|INP|INPUT\$|INSTR|INT|IOCTL\$|LBOUND|LCASE\$|LEFT\$|LEN|LOC|LOF|LOG|LPOS|LTRIM\$|MID\$|MKD\$|MKDMBF\$|MKI\$|MKL\$|MKS\$|MKSMBF\$|OCT\$|PEEK|PEN|PLAY|PMAP|POINT|POS|RIGHT\$|RND|RTRIM\$|SADD|SCREEN|SEEK|SETMEM|SGN|SIN|SPACE\$|SPC|SQR|STICK|STR\$|STRIG|STRING\$|TAB|TAN|TIME\$|TIMER|UBOUND|UCASE\$|VAL|VARPTR|VARPTR\$|VARSEG)(?=\(|\b)"> + <token type="KeywordReserved"/> + </rule> + </state> + <state name="metacommands"> + <rule pattern="\b(\$DYNAMIC|\$INCLUDE|\$STATIC)(?=\(|\b)"> + <token type="KeywordConstant"/> + </rule> + </state> + <state name="operators"> + <rule pattern="\b(AND|EQV|IMP|NOT|OR|XOR)(?=\(|\b)"> + <token type="OperatorWord"/> + </rule> + </state> + <state name="statements"> + <rule pattern="\b(BEEP|BLOAD|BSAVE|CALL|CALL\ ABSOLUTE|CALL\ INTERRUPT|CALLS|CHAIN|CHDIR|CIRCLE|CLEAR|CLOSE|CLS|COLOR|COM|COMMON|CONST|DATA|DATE\$|DECLARE|DEF\ FN|DEF\ SEG|DEFDBL|DEFINT|DEFLNG|DEFSNG|DEFSTR|DEF|DIM|DO|LOOP|DRAW|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|NEXT|FUNCTION|GET|GOSUB|GOTO|IF|THEN|INPUT|INPUT\ \#|IOCTL|KEY|KEY|KILL|LET|LINE|LINE\ INPUT|LINE\ INPUT\ \#|LOCATE|LOCK|UNLOCK|LPRINT|LSET|MID\$|MKDIR|NAME|ON\ COM|ON\ ERROR|ON\ KEY|ON\ PEN|ON\ PLAY|ON\ STRIG|ON\ TIMER|ON\ UEVENT|ON|OPEN|OPEN\ COM|OPTION\ BASE|OUT|PAINT|PALETTE|PCOPY|PEN|PLAY|POKE|PRESET|PRINT|PRINT\ \#|PRINT\ USING|PSET|PUT|PUT|RANDOMIZE|READ|REDIM|REM|RESET|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SCREEN|SEEK|SELECT\ CASE|SHARED|SHELL|SLEEP|SOUND|STATIC|STOP|STRIG|SUB|SWAP|SYSTEM|TIME\$|TIMER|TROFF|TRON|TYPE|UEVENT|UNLOCK|VIEW|WAIT|WHILE|WEND|WIDTH|WINDOW|WRITE)\b"> + <token type="KeywordReserved"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="\b(ACCESS|ALIAS|ANY|APPEND|AS|BASE|BINARY|BYVAL|CASE|CDECL|DOUBLE|ELSE|ELSEIF|ENDIF|INTEGER|IS|LIST|LOCAL|LONG|LOOP|MOD|NEXT|OFF|ON|OUTPUT|RANDOM|SIGNAL|SINGLE|STEP|STRING|THEN|TO|UNTIL|USING|WEND)\b"> + <token type="Keyword"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/qml.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/qml.xml new file mode 100644 index 0000000..43eb3eb --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/qml.xml @@ -0,0 +1,113 @@ +<lexer> + <config> + <name>QML</name> + <alias>qml</alias> + <alias>qbs</alias> + <filename>*.qml</filename> + <filename>*.qbs</filename> + <mime_type>application/x-qml</mime_type> + <mime_type>application/x-qt.qbs+qml</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="root"> + <rule pattern="^(?=\s|/|<!--)"> + <token type="Text"/> + <push state="slashstartsregex"/> + </rule> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?"> + <token type="Operator"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[{(\[;,]"> + <token type="Punctuation"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[})\].]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\bid\s*:\s*[A-Za-z][\w.]*"> + <token type="KeywordDeclaration"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="\b[A-Za-z][\w.]*\s*:"> + <token type="Keyword"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(for|in|while|do|break|return|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|void|this)\b"> + <token type="Keyword"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(var|let|with|function)\b"> + <token type="KeywordDeclaration"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(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"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(true|false|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|Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\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=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + </state> + <state name="commentsandwhitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="<!--"> + <token type="Comment"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="CommentMultiline"/> + </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> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/r.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/r.xml new file mode 100644 index 0000000..6dbfcba --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/r.xml @@ -0,0 +1,127 @@ +<lexer> + <config> + <name>R</name> + <alias>splus</alias> + <alias>s</alias> + <alias>r</alias> + <filename>*.S</filename> + <filename>*.R</filename> + <filename>*.r</filename> + <filename>.Rhistory</filename> + <filename>.Rprofile</filename> + <filename>.Renviron</filename> + <mime_type>text/S-plus</mime_type> + <mime_type>text/S</mime_type> + <mime_type>text/x-r-source</mime_type> + <mime_type>text/x-r</mime_type> + <mime_type>text/x-R</mime_type> + <mime_type>text/x-r-history</mime_type> + <mime_type>text/x-r-profile</mime_type> + </config> + <rules> + <state name="numbers"> + <rule pattern="0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[+-]?([0-9]+(\.[0-9]+)?|\.[0-9]+|\.)([eE][+-]?[0-9]+)?[Li]?"> + <token type="LiteralNumber"/> + </rule> + </state> + <state name="operators"> + <rule pattern="<<?-|->>?|-|==|<=|>=|<|>|&&?|!=|\|\|?|\?"> + <token type="Operator"/> + </rule> + <rule pattern="\*|\+|\^|/|!|%[^%]*%|=|~|\$|@|:{1,3}"> + <token type="Operator"/> + </rule> + </state> + <state name="root"> + <rule pattern="((?:`[^`\\]*(?:\\.[^`\\]*)*`)|(?:(?:[a-zA-z]|[_.][^0-9])[\w_.]*))\s*(?=\()"> + <token type="NameFunction"/> + </rule> + <rule> + <include state="statements"/> + </rule> + <rule pattern="\{|\}"> + <token type="Punctuation"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="valid_name"> + <rule pattern="(?:`[^`\\]*(?:\\.[^`\\]*)*`)|(?:(?:[a-zA-z]|[_.][^0-9])[\w_.]*)"> + <token type="Name"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(if|else|for|while|repeat|in|next|break|return|switch|function)(?![\w.])"> + <token type="KeywordReserved"/> + </rule> + </state> + <state name="builtin_symbols"> + <rule pattern="(NULL|NA(_(integer|real|complex|character)_)?|letters|LETTERS|Inf|TRUE|FALSE|NaN|pi|\.\.(\.|[0-9]+))(?![\w.])"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(T|F)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + </state> + <state name="string_squote"> + <rule pattern="([^\'\\]|\\.)*\'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="comments"> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </rule> + </state> + <state name="punctuation"> + <rule pattern="\[{1,2}|\]{1,2}|\(|\)|;|,"> + <token type="Punctuation"/> + </rule> + </state> + <state name="statements"> + <rule> + <include state="comments"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\'"> + <token type="LiteralString"/> + <push state="string_squote"/> + </rule> + <rule pattern="\""> + <token type="LiteralString"/> + <push state="string_dquote"/> + </rule> + <rule> + <include state="builtin_symbols"/> + </rule> + <rule> + <include state="valid_name"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule> + <include state="operators"/> + </rule> + </state> + <state name="string_dquote"> + <rule pattern="([^"\\]|\\.)*""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/racket.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/racket.xml new file mode 100644 index 0000000..6cdd303 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/racket.xml @@ -0,0 +1,260 @@ +<lexer> + <config> + <name>Racket</name> + <alias>racket</alias> + <alias>rkt</alias> + <filename>*.rkt</filename> + <filename>*.rktd</filename> + <filename>*.rktl</filename> + <mime_type>text/x-racket</mime_type> + <mime_type>application/x-racket</mime_type> + </config> + <rules> + <state name="datum*"> + <rule pattern="`|,@?"> + <token type="Operator"/> + </rule> + <rule pattern="(?:\|[^|]*\||\\[\w\W]|[^|\\()[\]{}",\'`;\s]+)+"> + <token type="LiteralStringSymbol"/> + <pop depth="1"/> + </rule> + <rule pattern="[|\\]"> + <token type="Error"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="quoted-list"> + <rule> + <include state="list"/> + </rule> + <rule pattern="(?!\Z)"> + <token type="Text"/> + <push state="quoted-datum"/> + </rule> + </state> + <state name="quasiquoted-list"> + <rule> + <include state="list"/> + </rule> + <rule pattern="(?!\Z)"> + <token type="Text"/> + <push state="quasiquoted-datum"/> + </rule> + </state> + <state name="quoted-datum"> + <rule> + <include state="datum"/> + </rule> + <rule pattern="[([{]"> + <token type="Punctuation"/> + <push state="#pop" state="quoted-list"/> + </rule> + <rule> + <include state="datum*"/> + </rule> + </state> + <state name="block-comment"> + <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="datum"> + <rule pattern="(?s)#;|#*"> + <token type="Comment"/> + </rule> + <rule pattern=";[^\n\r
]*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="#\|"> + <token type="CommentMultiline"/> + <push state="block-comment"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(?i)(?:#e)?(?:#d)?(?:#e)?[-+]?\d+(?=[()[\]{}",\'`;\s])"> + <token type="LiteralNumberInteger"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(?:#e)?(?:#d)?(?:#e)?[-+]?(\d+(\.\d*)?|\.\d+)([deflst][-+]?\d+)?(?=[()[\]{}",\'`;\s])"> + <token type="LiteralNumberFloat"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(?:#e)?(?:#d)?(?:#e)?[-+]?((?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)(?:[defls][-+]?\d+)?)([-+](?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)(?:[defls][-+]?\d+)?)?i)?|[-+](?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)(?:[defls][-+]?\d+)?)?i)(?=[()[\]{}",\'`;\s])"> + <token type="LiteralNumber"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(#d)?((?:[-+]?(?:(?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|\d+(?:\.\d*#+|/\d+#+)))(?:[defls][-+]?\d+)?)|[-+](?:(?:inf|nan)\.[0f]))([-+](?:(?:(?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|\d+(?:\.\d*#+|/\d+#+)))(?:[defls][-+]?\d+)?)|(?:(?:inf|nan)\.[0f]))?i)?|[-+](?:(?:(?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|\d+(?:\.\d*#+|/\d+#+)))(?:[defls][-+]?\d+)?)|(?:(?:inf|nan)\.[0f]))?i|(?:[-+]?(?:(?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|\d+(?:\.\d*#+|/\d+#+)))(?:[defls][-+]?\d+)?)|[-+](?:(?:inf|nan)\.[0f]))@(?:[-+]?(?:(?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|\d+(?:\.\d*#+|/\d+#+)))(?:[defls][-+]?\d+)?)|[-+](?:(?:inf|nan)\.[0f])))(?=[()[\]{}",\'`;\s])"> + <token type="LiteralNumberFloat"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(([-+]?(?:(?:\d+(?:/\d+|\.\d*)?|\.\d+)|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|\d+(?:\.\d*#+|/\d+#+)))t[-+]?\d+)|[-+](inf|nan)\.t)(?=[()[\]{}",\'`;\s])"> + <token type="LiteralNumberFloat"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(#[ei])?#b(?:\|[^|]*\||\\[\w\W]|[^|\\()[\]{}",\'`;\s]+)+"> + <token type="LiteralNumberBin"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(#[ei])?#o(?:\|[^|]*\||\\[\w\W]|[^|\\()[\]{}",\'`;\s]+)+"> + <token type="LiteralNumberOct"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(#[ei])?#x(?:\|[^|]*\||\\[\w\W]|[^|\\()[\]{}",\'`;\s]+)+"> + <token type="LiteralNumberHex"/> + <pop depth="1"/> + </rule> + <rule pattern="(?i)(#d)?#i(?:\|[^|]*\||\\[\w\W]|[^|\\()[\]{}",\'`;\s]+)+"> + <token type="LiteralNumberFloat"/> + <pop depth="1"/> + </rule> + <rule pattern="#?""> + <token type="LiteralStringDouble"/> + <push state="#pop" state="string"/> + </rule> + <rule pattern="#<<(.+)\n(^(?!\1$).*$\n)*^\1$"> + <token type="LiteralStringHeredoc"/> + <pop depth="1"/> + </rule> + <rule pattern="#\\(u[\da-fA-F]{1,4}|U[\da-fA-F]{1,8})"> + <token type="LiteralStringChar"/> + <pop depth="1"/> + </rule> + <rule pattern="(?is)#\\([0-7]{3}|[a-z]+|.)"> + <token type="LiteralStringChar"/> + <pop depth="1"/> + </rule> + <rule pattern="(?s)#[pr]x#?"(\\?.)*?""> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </rule> + <rule pattern="#(true|false|[tTfF])"> + <token type="NameConstant"/> + <pop depth="1"/> + </rule> + <rule pattern="#:(?:\|[^|]*\||\\[\w\W]|[^|\\()[\]{}",\'`;\s]+)+"> + <token type="KeywordDeclaration"/> + <pop depth="1"/> + </rule> + <rule pattern="(#lang |#!)(\S+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="#reader"> + <token type="KeywordNamespace"/> + <push state="quoted-datum"/> + </rule> + <rule pattern="(?i)\.(?=[()[\]{}",\'`;\s])|#c[is]|#['`]|#,@?"> + <token type="Operator"/> + </rule> + <rule pattern="'|#[s&]|#hash(eqv?)?|#\d*(?=[([{])"> + <token type="Operator"/> + <push state="#pop" state="quoted-datum"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="(?s)\\([0-7]{1,3}|x[\da-fA-F]{1,2}|u[\da-fA-F]{1,4}|U[\da-fA-F]{1,8}|.)"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="root"> + <rule pattern="[)\]}]"> + <token type="Error"/> + </rule> + <rule pattern="(?!\Z)"> + <token type="Text"/> + <push state="unquoted-datum"/> + </rule> + </state> + <state name="list"> + <rule pattern="[)\]}]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="unquoted-datum"> + <rule> + <include state="datum"/> + </rule> + <rule pattern="quote(?=[()[\]{}",\'`;\s])"> + <token type="Keyword"/> + <push state="#pop" state="quoted-datum"/> + </rule> + <rule pattern="`"> + <token type="Operator"/> + <push state="#pop" state="quasiquoted-datum"/> + </rule> + <rule pattern="quasiquote(?=[()[\]{}",\'`;\s])"> + <token type="Keyword"/> + <push state="#pop" state="quasiquoted-datum"/> + </rule> + <rule pattern="[([{]"> + <token type="Punctuation"/> + <push state="#pop" state="unquoted-list"/> + </rule> + <rule pattern="(define/subexpression-pos-prop/name|define-module-boundary-contract|define-values/invoke-unit/infer|with-contract-continuation-mark|define/subexpression-pos-prop|include-at/relative-to/reader|define-unit/new-import-export|define-compound-unit/infer|define-serializable-class\*|provide-signature-elements|define-serializable-class|define-values/invoke-unit|define-values-for-export|define-custom-hash-types|define-local-member-name|define-unit-from-context|define-values-for-syntax|define-custom-set-types|define-namespace-anchor|#%printing-module-begin|letrec-syntaxes\+values|include-at/relative-to|define-contract-struct|define-struct/contract|unconstrained-domain->|with-continuation-mark|unit/new-import-export|define-sequence-syntax|define-match-expander|define-signature-form|define/override-final|define-struct/derived|define/augment-final|define-compound-unit|#%plain-module-begin|class-field-accessor|#%variable-reference|define-unit/contract|class-field-mutator|match-letrec-values|define/public-final|for\*/mutable-seteqv|define-unit-binding|invariant-assertion|flat-murec-contract|match-define-values|compound-unit/infer|for/mutable-seteqv|parameterize-break|send/keyword-apply|struct-field-index|quote-syntax/prune|recursive-contract|define-syntax-rule|for\*/mutable-seteq|define-member-name|match-let\*-values|#%top-interaction|for/mutable-seteq|define/final-prop|unit-from-context|unsyntax-splicing|#%stratified-body|super-instantiate|invoke-unit/infer|flat-rec-contract|for\*/fold/derived|super-make-object|define-for-syntax|define-signature|for/fold/derived|for\*/weak-seteqv|gen:custom-write|unquote-splicing|begin-for-syntax|provide/contract|for\*/mutable-set|match-let-values|for\*/weak-seteq|object-contract|define/override|all-defined-out|define/overment|member-name-key|quasisyntax/loc|define/contract|contract-struct|define-syntaxes|override-final\*|for/mutable-set|for/weak-seteqv|syntax-id-rules|letrec-syntaxes|define/private|gen:equal\+hash|for/weak-seteq|match\*/derived|recontract-out|#%module-begin|define/augment|augment-final\*|define/augride|with-handlers\*|match-lambda\*\*|include/reader|define/pubment|override-final|#%plain-lambda|parametric->/c|define-struct|match/derived|compound-unit|class/derived|define-unit/s|inherit/super|define-logger|augment-final|for\*/weak-set|with-handlers|define/public|match-lambda\*|define-syntax|parameterize\*|place/context|local-require|letrec-values|define-values|public-final\*|letrec-syntax|inherit-field|with-contract|inherit/inner|define/match|failure-cont|send-generic|#%expression|parameterize|syntax-case\*|for/weak-set|match-define|syntax-rules|public-final|delay/thread|delay/strict|match-lambda|quote-syntax|only-meta-in|let-syntaxes|all-from-out|match/values|for\*/hasheqv|command-line|for\*/product|match-letrec|rename-inner|rename-super|for-template|contract-out|define-opt/c|field-bound\?|prompt-tag/c|for\*/vector|invoke-unit|values/drop|instantiate|for\*/stream|for\*/seteqv|init-depend|relative-in|let\*-values|with-method|case-lambda|protect-out|for\*/hasheq|with-syntax|set!-values|syntax-case|stream-cons|#%plain-app|quasisyntax|struct-copy|log-warning|combine-out|define-unit|for/hasheqv|for/product|interface\*|for/vector|for/stream|for/seteqv|syntax/loc|prefix-out|contracted|set-field!|for\*/async|gen:stream|for\*/first|init-field|let-values|send/apply|for\*/lists|let-syntax|match-let\*|delay/name|struct/ctc|for/hasheq|rename-out|delay/idle|combine-in|quasiquote|delay/sync|struct-out|except-out|for-syntax|for\*/seteq|overment\*|init-rest|interface|match-let|for/async|for-label|for/first|override\*|for\*/fold|rename-in|struct/dc|except-in|for/lists|#%require|#%provide|for\*/list|for\*/hash|get-field|#%declare|prefix-in|log-debug|for\*/last|for/seteq|log-fatal|super-new|log-error|override|augment\*|overment|log-info|abstract|for\*/sum|pubment\*|for-meta|struct/c|for\*/and|for/fold|for/hash|for/last|for/list|unsyntax|private\*|gen:dict|contract|augride\*|object/c|for\*/set|class/c|pubment|case->m|module\*|module\+|cons/dc|public\*|augride|struct\*|extends|augment|only-in|false/c|provide|for\*/or|inspect|for/and|for/sum|require|inherit|include|implies|hash/dc|generic|#%datum|gen:set|private|for/set|unquote|stream\*|import|planet|place\*|:do-in|unless|unit/s|unit/c|absent|thunk\*|begin0|public|prefix|case->|module|syntax|match\*|define|submod|except|export|let/ec|letrec|struct|let/cc|stream|rename|shared|for/or|lambda|class\*|place|thunk|send\*|send\+|inner|#%top|this%|opt/c|begin|mixin|class|match|super|field|false|local|quote|#%app|delay|time|else|link|when|file|let\*|cond|->dm|->\*m|nand|case|only|for\*|set!|open|this|lazy|send|unit|init|->m|nor|tag|any|->\*|for|->d|let|new|lib|\.\.\.|and|->i|do|==|λ|or|->|if|=>|_)(?=[()[\]{}",\'`;\s])"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule pattern="(variable-reference->module-declaration-inspector|wrapped-extra-arg-arrow-extra-neg-party-argument|contract-random-generate-get-current-environment|internal-definition-context-binding-identifiers|call-with-default-reading-parameterization|struct:exn:fail:contract:non-fixnum-result|syntax-local-transforming-module-provides\?|identifier-remove-from-definition-context|impersonator-property-accessor-procedure\?|struct:exn:fail:filesystem:missing-module|regexp-match-peek-positions-immediate/end|syntax-local-lift-module-end-declaration|syntax-local-module-required-identifiers|variable-reference->resolved-module-path|make-exn:fail:contract:non-fixnum-result|struct-type-property-accessor-procedure\?|syntax-local-module-defined-identifiers|make-tentative-pretty-print-output-port|module-compiled-cross-phase-persistent\?|struct:exn:fail:contract:divide-by-zero|make-exn:fail:filesystem:missing-module|arrow-contract-info-chaperone-procedure|exn:fail:filesystem:missing-module-path|syntax-transforming-module-expression\?|local-transformer-expand/capture-lifts|custodian-memory-accounting-available\?|call-with-immediate-continuation-mark|variable-reference->module-path-index|struct:exn:fail:contract:continuation|internal-definition-context-introduce|struct:exn:fail:syntax:missing-module|regexp-match-peek-positions-immediate|variable-reference->module-base-phase|arrow-contract-info-check-first-order|make-exn:fail:contract:divide-by-zero|exn:fail:contract:non-fixnum-result\?|tentative-pretty-print-port-transfer|prop:opt-chaperone-contract-get-test|syntax-local-make-definition-context|compile-context-preservation-enabled|current-preserved-thread-cell-values|exn:fail:filesystem:missing-module\?|contract-struct-late-neg-projection|make-exn:fail:contract:continuation|syntax-local-lift-values-expression|pretty-print-abbreviate-read-macros|current-evt-pseudo-random-generator|checked-procedure-check-and-extract|contract-custom-write-property-proc|exn:fail:syntax:missing-module-path|exn:fail:contract:non-fixnum-result|namespace-attach-module-declaration|variable-reference->empty-namespace|make-exn:fail:syntax:missing-module|arrow-contract-info-accepts-arglist|syntax-local-make-delta-introducer|struct:exn:fail:filesystem:version|impersonator-prop:application-mark|pretty-print-\.-symbol-without-bars|prop:orc-contract-get-subcontracts|syntax-local-identifier-as-binding|exn:fail:filesystem:missing-module|current-get-interaction-input-port|tentative-pretty-print-port-cancel|current-subprocess-custodian-mode|build-chaperone-contract-property|impersonate-continuation-mark-key|identifier-prune-to-source-module|variable-reference->module-source|namespace-anchor->empty-namespace|struct:exn:fail:contract:variable|exn:fail:contract:divide-by-zero\?|wrapped-extra-arg-arrow-real-func|make-handle-get-preference-locked|string-environment-variable-name\?|current-thread-initial-stack-size|struct:exn:fail:filesystem:exists|call-with-composable-continuation|exn:fail:contract:divide-by-zero|namespace-require/expansion-time|call-with-semaphore/enable-break|pretty-print-current-style-table|compile-enforce-module-constants|identifier-prune-lexical-context|vector->pseudo-random-generator!|make-exn:fail:filesystem:version|current-library-collection-paths|struct:exn:fail:filesystem:errno|current-write-relative-directory|current-library-collection-links|current-force-delete-permissions|internal-definition-context-seal|bytes-environment-variable-name\?|call-with-break-parameterization|file-or-directory-modify-seconds|exn:fail:filesystem:errno-errno|current-load-relative-directory|syntax-transforming-with-lifts\?|chaperone-continuation-mark-key|default-continuation-prompt-tag|pseudo-random-generator-vector\?|make-exn:fail:filesystem:exists|pseudo-random-generator->vector|pretty-print-extend-style-table|exn:fail:contract:continuation\?|current-pseudo-random-generator|exn:fail:syntax:missing-module\?|vector->pseudo-random-generator|contract-random-generate/choose|regexp-match-peek-positions/end|make-exn:fail:contract:variable|call-with-current-continuation|custom-print-quotable-accessor|identifier-transformer-binding|current-break-parameterization|make-exn:fail:filesystem:errno|struct:exn:fail:contract:arity|exn:fail:contract:blame-object|exn:fail:contract:continuation|contract-random-generate-fail\?|write-bytes-avail/enable-break|syntax-local-expand-expression|continuation-prompt-available\?|struct:exn:fail:contract:blame|procedure-reduce-keyword-arity|struct:wrapped-extra-arg-arrow|continuation-mark-set->context|struct:exn:fail:syntax:unbound|use-user-specific-search-paths|contract-continuation-mark-key|get/build-val-first-projection|call-with-continuation-barrier|contract-random-generate-stash|read-bytes-avail!/enable-break|contract-struct-list-contract\?|exn:fail:syntax:missing-module|procedure-closure-contents-eq\?|peek-bytes-avail!/enable-break|current-command-line-arguments|prop:recursive-contract-unroll|file-or-directory-permissions|compiled-expression-recompile|call-with-continuation-prompt|vector-set-performance-stats!|get/build-late-neg-projection|object-method-arity-includes\?|find-library-collection-links|current-module-declare-source|exn:fail:contract:variable-id|pretty-print-exact-as-decimal|find-library-collection-paths|struct:exn:fail:network:errno|current-environment-variables|namespace-set-variable-value!|struct:exn:fail:read:non-char|module-compiled-language-info|contract-val-first-projection|pretty-print-show-inexactness|struct-constructor-procedure\?|struct:exn:fail:out-of-memory|contract-random-generate-fail|call-with-escape-continuation|free-transformer-identifier=\?|variable-reference->namespace|current-module-name-resolver|filesystem-change-evt-cancel|current-module-path-for-load|call-with-atomic-output-file|udp-multicast-set-interface!|struct-type-make-constructor|pretty-print-post-print-hook|make-exn:fail:syntax:unbound|current-process-milliseconds|port-provides-progress-evts\?|make-continuation-prompt-tag|compile-allow-set!-undefined|exn:fail:network:errno-errno|make-exn:fail:contract:blame|exn:fail:filesystem:version\?|make-exn:fail:contract:arity|read-square-bracket-as-paren|read-square-bracket-with-tag|make-pseudo-random-generator|continuation-mark-set->list\*|make-syntax-delta-introducer|current-inexact-milliseconds|prop:arrow-contract-get-info|namespace-undefine-variable!|namespace-symbol->identifier|contract-first-order-passes\?|contract-late-neg-projection|syntax-local-lift-expression|syntax-local-value/immediate|impersonator-prop:contracted|variable-reference-constant\?|build-flat-contract-property|chaperone-contract-property\?|regexp-match-peek-positions\*|internal-definition-context\?|prop:opt-chaperone-contract\?|make-input-port/read-to-peek|plumber-flush-handle-remove!|current-compiled-file-roots|prop:opt-chaperone-contract|prop:liberal-define-context|syntax-local-module-exports|compiled-module-expression\?|exn:fail:filesystem:version|exn:fail:filesystem:exists\?|continuation-mark-set->list|make-file-or-directory-link|continuation-mark-set-first|error-print-source-location|semaphore-wait/enable-break|exn:fail:contract:variable\?|exn:missing-module-accessor|namespace-module-identifier|environment-variables-names|current-module-declare-name|identifier-template-binding|system-path-convention-type|make-exn:fail:read:non-char|regexp-match-peek-positions|struct:exn:fail:unsupported|pretty-print-remap-stylable|pretty-print-pre-print-hook|make-exn:fail:network:errno|namespace-anchor->namespace|call-with-exception-handler|make-exn:fail:out-of-memory|error-value->string-handler|path-list-string->path-list|struct-predicate-procedure\?|udp-multicast-set-loopback!|regexp-match-peek-immediate|syntax-property-symbol-keys|call-with-file-lock/timeout|module-path-index-submodule|udp-multicast-leave-group!|struct:exn:fail:filesystem|current-directory-for-user|floating-point-bytes->real|namespace-unprotect-module|free-template-identifier=\?|struct-accessor-procedure\?|namespace-syntax-introduce|namespace-require/constant|syntax-property-preserved\?|exact-nonnegative-integer\?|call-with-parameterization|real->floating-point-bytes|error-print-context-length|raise-not-cons-blame-error|current-continuation-marks|preferences-lock-file-mode|check-duplicate-identifier|make-environment-variables|environment-variables-set!|make-continuation-mark-key|file-or-directory-identity|struct-type-make-predicate|build-path/convention-type|print-reader-abbreviations|make-immutable-custom-hash|module-compiled-submodules|procedure-arity-includes/c|struct:exn:break:terminate|regexp-match-positions/end|coerce-chaperone-contracts|environment-variables-copy|exn:fail:contract:variable|make-struct-field-accessor|local-expand/capture-lifts|dynamic-require-for-syntax|syntax-local-bind-syntaxes|set!-transformer-procedure|exn:fail:filesystem:errno\?|exn:fail:filesystem:exists|prop:custom-print-quotable|make-known-char-range-list|abort-current-continuation|uncaught-exception-handler|custom-write-property-proc|make-impersonator-property|struct:arrow-contract-info|variable-reference->phase|set-some-basic-contracts!|current-load/use-compiled|use-collection-link-paths|make-resolved-module-path|string->unreadable-symbol|syntax-local-lift-require|set-symmetric-difference!|syntax-local-lift-provide|udp-multicast-join-group!|read-curly-brace-as-paren|read-curly-brace-with-tag|exn:fail:filesystem:errno|global-port-print-handler|rename-transformer-target|blame-add-nth-arg-context|make-exn:fail:unsupported|identifier-binding-symbol|equal-secondary-hash-code|make-struct-field-mutator|blame-add-unknown-context|pretty-print-style-table\?|make-struct-type-property|member-name-key-hash-code|coerce-chaperone-contract|resolved-module-path-name|syntax-local-lift-context|environment-variables-ref|expand-syntax-to-top-form|module-path-index-resolve|make-base-empty-namespace|namespace-module-registry|string->uninterned-symbol|udp-receive!/enable-break|special-filter-input-port|syntax-local-get-shadower|struct-mutator-procedure\?|module-provide-protected\?|procedure-arity-includes\?|sync/timeout/enable-break|subprocess-group-enabled|custodian-require-memory|contract-struct-generate|pseudo-random-generator\?|syntax-shift-phase-level|vector->immutable-vector|contract-struct-exercise|exn:fail:contract:arity\?|procedure-extract-target|exn:fail:contract:blame\?|build-compound-type-name|make-exn:fail:filesystem|contract-random-generate|namespace-mapped-symbols|local-transformer-expand|in-immutable-hash-values|some-system-path->string|struct:exn:break:hang-up|skip-projection-wrapper\?|identifier-label-binding|print-mpair-curly-braces|executable-yield-handler|current-read-interaction|struct:exn:fail:contract|continuation-prompt-tag\?|exn:fail:syntax:unbound\?|make-hasheqv-placeholder|syntax-local-lift-module|current-parameterization|tcp-connect/enable-break|struct:exn:fail:read:eof|namespace-variable-value|string->immutable-string|wrapped-extra-arg-arrow\?|string->some-system-path|dict-can-functional-set\?|prop:recursive-contract\?|syntax-local-phase-level|rename-file-or-directory|set-symmetric-difference|udp-send-to/enable-break|port-count-lines-enabled|make-exn:break:terminate|exn:fail:syntax:unbound|struct:exn:fail:network|prefab-key->struct-type|namespace-attach-module|read-decimal-as-inexact|udp-multicast-loopback\?|pretty-print-print-hook|current-gc-milliseconds|blame-add-missing-party|pretty-print-print-line|exact-positive-integer\?|blame-add-range-context|free-label-identifier=\?|set-port-next-location!|print-boolean-long-form|string-normalize-spaces|flat-contract-property\?|print-pair-curly-braces|current-contract-region|flat-contract-predicate|make-chaperone-contract|tcp-accept/enable-break|call-with-output-string|module-compiled-imports|file-stream-buffer-mode|impersonator-prop:blame|exn:fail:contract:arity|in-immutable-hash-pairs|load-relative-extension|exn:fail:contract:blame|liberal-define-context\?|interface->method-names|break-parameterization\?|prop:chaperone-contract|build-contract-property|system-language\+country|module-path-index-split|module-compiled-exports|regexp-match-positions\*|prop:rename-transformer|wrapped-extra-arg-arrow|make-rename-transformer|make-pipe-with-specials|continuation-mark-key/c|use-compiled-file-paths|syntax-local-submodules|exn:fail:read:non-char\?|exn:fail:out-of-memory\?|prop:exn:missing-module|exn:fail:network:errno\?|prop:expansion-contexts|make-mutable-custom-set|make-limited-input-port|make-hasheq-placeholder|udp-multicast-interface|prop:recursive-contract|make-sibling-inspector|current-code-inspector|impersonator-ephemeron|blame-replace-negative|exn-continuation-marks|delete-directory/files|call-with-input-string|make-parent-directory\*|integer-sqrt/remainder|impersonate-prompt-tag|impersonator-property\?|open-input-output-file|string-locale-downcase|module-path-index-join|impersonate-procedure\*|syntax-local-introduce|load-on-demand-enabled|make-immutable-hasheqv|integer-bytes->integer|integer->integer-bytes|make-exn:fail:read:eof|locale-string-encoding|make-keyword-procedure|filter-read-input-port|bytes->immutable-bytes|udp-multicast-set-ttl!|custom-print-quotable\?|thread/suspend-to-kill|namespace-require/copy|custodian-shutdown-all|filesystem-change-evt\?|syntax-local-certifier|current-load-extension|custodian-managed-list|prop:checked-procedure|in-immutable-hash-keys|struct:exn:fail:object|regexp-match-positions|continuation-mark-set\?|continuation-mark-key\?|system-library-subpath|custodian-limit-memory|impersonator-contract\?|transplant-output-port|exn:fail:network:errno|make-custom-hash-types|struct-type-property/c|exn:fail:out-of-memory|with-input-from-string|exn:fail:read:non-char|matches-arity-exactly\?|procedure-struct-type\?|place-message-allowed\?|struct:exn:fail:syntax|procedure-result-arity|make-derived-parameter|call-with-output-bytes|arity-checking-wrapper|procedure-reduce-arity|pretty-print-size-hook|make-exn:break:hang-up|make-exn:fail:contract|environment-variables\?|current-security-guard|in-mutable-hash-values|read-accept-quasiquote|primitive-result-arity|make-syntax-introducer|hash-iterate-key\+value|call-with-output-file\*|exn:break-continuation|bytes-close-converter|raise-arguments-error|make-set!-transformer|make-weak-custom-hash|in-mutable-hash-pairs|call-with-output-file|read-bytes-avail!-evt|path-for-some-system\?|special-comment-value|exn:fail:unsupported\?|coerce-flat-contracts|with-input-from-bytes|struct:arity-at-least|peek-bytes-avail!-evt|exn:fail:syntax-exprs|place-channel-put/get|read-accept-infix-dot|struct-type-property\?|resolved-module-path\?|make-custom-set-types|exn:fail:read-srclocs|string->bytes/latin-1|display-lines-to-file|plumber-flush-handle\?|call-with-input-file\*|prop:set!-transformer|read-accept-bar-quote|chaperone-struct-type|error-display-handler|transplant-input-port|bad-number-of-results|regexp-max-lookbehind|call-with-input-bytes|bytes->string/latin-1|parameter-procedure=\?|filesystem-change-evt|call-in-nested-thread|with-output-to-string|module->language-info|make-exn:fail:network|char-general-category|thread-rewind-receive|write-bytes-avail-evt|udp-receive-ready-evt|impersonate-procedure|string-normalize-nfkd|custom-write-accessor|make-hash-placeholder|dict-can-remove-keys\?|udp-send/enable-break|read-on-demand-source|date-time-zone-offset|read-syntax/recursive|blame-add-car-context|blame-add-cdr-context|string-normalize-nfkc|make-immutable-hasheq|vector-split-at-right|path-element->string|string-normalize-nfc|exn:break:terminate\?|current-blame-format|string-normalize-nfd|datum-intern-literal|fsemaphore-try-wait\?|reencode-output-port|copy-directory/files|port-writes-special\?|impersonate-hash-set|make-exn:fail:syntax|namespace-base-phase|chaperone-procedure\*|port-display-handler|contract-first-order|list->mutable-seteqv|make-exn:fail:object|bytes-open-converter|raise-mismatch-error|real->decimal-string|interface-extension\?|date\*-time-zone-name|current-milliseconds|syntax-source-module|chaperone-prompt-tag|write-special-avail\*|string-locale-upcase|syntax-transforming\?|call-with-input-file|prop:impersonator-of|compiled-expression\?|exn:fail:filesystem\?|struct:exn:fail:read|module-compiled-name|find-executable-path|relocate-output-port|error-escape-handler|read-eval-print-loop|read-char-or-special|pretty-print-columns|read-accept-compiled|arrow-contract-info\?|syntax-local-context|string->bytes/locale|method-in-interface\?|make-primitive-class|prop:arrow-contract\?|sequence-add-between|pretty-print-handler|pretty-print-newline|collection-file-path|current-reader-guard|arity-at-least-value|coerce-flat-contract|bytes->string/locale|generate-temporaries|exn:fail:unsupported|struct:exn:fail:user|current-thread-group|path->directory-path|path-convention-type|make-special-comment|read-byte-or-special|with-output-to-bytes|exn:srclocs-accessor|peek-char-or-special|string->path-element|with-input-from-file|raise-argument-error|in-mutable-hash-keys|procedure-specialize|blame-missing-party\?|peek-byte-or-special|make-weak-custom-set|make-empty-namespace|regexp-replace-quote|raise-contract-error|filesystem-root-list|match-equality-test|path-replace-suffix|print-vector-length|path-element->bytes|make-temporary-file|custodian-box-value|exn:missing-module\?|print-as-expression|split-common-prefix|prop:arrow-contract|path->complete-path|file-name-from-path|read-bytes-line-evt|read-case-sensitive|dict-value-contract|bytes->string/utf-8|pipe-content-length|make-security-guard|with-output-to-file|arrow-contract-info|in-input-port-chars|string->bytes/utf-8|in-values\*-sequence|bytes->path-element|current-prompt-read|make-base-namespace|in-weak-hash-values|make-arity-at-least|relocate-input-port|semaphore-peek-evt\?|current-output-port|semaphore-try-wait\?|chaperone-procedure|open-output-nowhere|thread-cell-values\?|listen-port-number\?|syntax-track-origin|make-mixin-contract|string-utf-8-length|chaperone-contract\?|generate-member-key|exn:fail:filesystem|variable-reference\?|make-lock-file-name|flat-named-contract|real->double-flonum|impersonate-channel|contract-projection|real->single-flonum|reencode-input-port|port-writes-atomic\?|call-with-semaphore|list->mutable-seteq|rename-transformer\?|prop:place-location|make-immutable-hash|port-try-file-lock\?|exn:break:terminate|regexp-match-exact\?|in-input-port-bytes|bytes-utf-8-length|blame-fmt->-string|prop:orc-contract\?|thread-receive-evt|sequence-generate\*|make-phantom-bytes|set-phantom-bytes!|syntax-local-value|prop:flat-contract|bound-identifier=\?|write-bytes-avail\*|dict-iter-contract|plumber-add-flush!|module-predefined\?|thread-suspend-evt|thread-try-receive|module-path-index\?|dict-iterate-first|find-relative-path|semaphore-peek-evt|open-output-string|string-locale-ci>\?|order-of-magnitude|string-locale-ci=\?|dict-iterate-value|in-weak-hash-pairs|prop:dict/contract|string-locale-ci<\?|in-values-sequence|filename-extension|make-custodian-box|take-common-prefix|symbol-unreadable\?|drop-common-prefix|raise-result-error|parse-command-line|procedure-keywords|quotient/remainder|print-syntax-width|make-will-executor|dynamic-set-field!|expand-to-top-form|expand-syntax-once|primitive-closure\?|equal-contract-val|hash-iterate-first|pretty-print-depth|vector-immutableof|current-memory-use|vector-immutable/c|hash-iterate-value|the-unsupplied-arg|make-exn:fail:read|current-input-port|raise-syntax-error|peek-bytes-avail!\*|peeking-input-port|make-exn:fail:user|udp-send-ready-evt|read-accept-reader|make-flat-contract|stream-add-between|exn:fail:read:eof\?|current-error-port|port-write-handler|chaperone-hash-set|make-proj-contract|exn:break:hang-up\?|make-prefab-struct|impersonate-vector|identifier-binding|impersonate-struct|system-big-endian\?|read-bytes-avail!\*|port-print-handler|port-next-location|port-commit-peeked|contract-stronger\?|contract-property\?|exn:fail:contract\?|continuation-marks|port-counts-lines\?|port-file-identity|exn:fail:contract|contract-exercise|bytes-utf-8-index|make-log-receiver|port-count-lines!|system\*/exit-code|remove-duplicates|port->bytes-lines|exn:fail:network\?|plumber-flush-all|port-progress-evt|thread-resume-evt|exn:break:hang-up|port-read-handler|current-custodian|read-accept-graph|current-directory|exn:fail:read:eof|tcp-accept-ready\?|make-reader-graph|implementation\?/c|place-channel-put|place-channel-get|make-shared-bytes|coerce-contract/f|bytes-convert-end|hash-placeholder\?|set!-transformer\?|close-output-port|raise-range-error|current-inspector|udp-multicast-ttl|vector-filter-not|prefab-struct-key|in-immutable-hash|hash-iterate-pair|error-print-width|hash-iterate-next|current-namespace|peek-bytes-avail!|read-bytes-avail!|char-iso-control\?|current-readtable|make-thread-group|raise-blame-error|raise-arity-error|make-weak-hasheqv|vector-take-right|vector-drop-right|externalizable<%>|procedure->method|chaperone-channel|cartesian-product|dynamic-get-field|file->bytes-lines|parameterization\?|subprocess-status|member-name-key=\?|tail-marks-match\?|sync/enable-break|file-stream-port\?|prop:arity-string|directory-exists\?|syntax-debug-info|bitwise-bit-field|prop:custom-write|other-execute-bit|in-weak-hash-keys|module->namespace|dict-key-contract|group-execute-bit|char-utf-8-length|dict-iterate-next|write-bytes-avail|get-output-string|input-port-append|open-output-bytes|open-input-string|load/use-compiled|object-or-false=\?|readtable-mapping|dict-implements/c|namespace-anchor\?|non-empty-string\?|sequence-for-each|syntax-local-name|regexp-match-peek|namespace-require|write-special-evt|list->weak-seteqv|sequence-generate|char-punctuation\?|prop:orc-contract|free-identifier=\?|blame-add-context|list->mutable-set|dump-memory-stats|normalized-arity\?|make-output-port|set-implements/c|open-output-file|find-system-path|placeholder-set!|prop:output-port|degrees->radians|delete-directory|exn:fail:object\?|date\*-nanosecond|prop:object-name|open-input-bytes|make-weak-hasheq|make-thread-cell|prop:exn:srclocs|bitwise-bit-set\?|struct-type-info|dict-implements\?|dict-iterate-key|exn:fail:network|syntax-original\?|hash-iterate-key|member-name-key\?|list->weak-seteq|regexp-match/end|make-struct-type|tcp-abandon-port|object-interface|system/exit-code|raise-user-error|read-string!-evt|raise-type-error|regexp-try-match|string-contains\?|sequence->stream|char-title-case\?|char-whitespace\?|port-file-unlock|promise-running\?|thread-cell-set!|bytes-converter\?|make-rectangular|string-titlecase|check-duplicates|channel-put-evt\?|syntax-recertify|coerce-contracts|normal-case-path|class->interface|symbol-interned\?|make-placeholder|non-empty-listof|user-execute-bit|dynamic-object/c|procedure-rename|read-accept-lang|char-alphabetic\?|module-declared\?|failure-result/c|exn:fail:syntax\?|char-upper-case\?|will-try-execute|impersonate-hash|chaperone-vector|procedure-arity\?|regexp-match-evt|vector-immutable|simple-form-path|make-custom-hash|chaperone-struct|in-immutable-set|natural-number/c|pathlist-closure|get-output-bytes|radians->degrees|char-lower-case\?|eval-jit-enabled|make-do-sequence|expand-user-path|struct:exn:break|fsemaphore-count|print-unreadable|peek-string!-evt|special-comment\?|impersonator-of\?|arithmetic-shift|udp-receive!-evt|call-with-values|futures-enabled\?|print-hash-table|close-input-port|make-custom-set|peek-bytes!-evt|string-no-nuls\?|string-locale>\?|splitf-at-right|in-mutable-hash|subprocess-kill|srcloc-position|udp-open-socket|vector-split-at|string-locale=\?|struct:exn:fail|syntax-position|syntax-property|fsemaphore-wait|fsemaphore-post|pretty-printing|dynamic-require|string-locale<\?|in-combinations|read-bytes!-evt|make-fsemaphore|current-seconds|arity-at-least\?|implementation\?|ephemeron-value|udp-send-to-evt|box-immutable/c|arity-includes\?|unspecified-dom|bytes-utf-8-ref|eq-contract-val|in-permutations|equal-contract\?|impersonate-box|make-input-port|current-plumber|coerce-contract|blame-original\?|unsupplied-arg\?|peek-string-evt|exn:misc:match\?|make-directory\*|put-preferences|rename-contract|procedure-arity|set-implements\?|shrink-path-wrt|dup-output-port|port-closed-evt|thread-dead-evt|security-guard\?|system-idle-evt|subprocess-wait|path-add-suffix|channel-try-get|normalize-arity|collect-garbage|stream-for-each|current-compile|exn:fail:syntax|display-to-file|group-write-bit|module->imports|processor-count|thread-running\?|promise-forced\?|string->keyword|module->exports|equal-hash-code|string-foldcase|syntax-tainted\?|read-string-evt|sequence-andmap|sequence-append|thread-cell-ref|sequence-filter|channel-put-evt|prop:contracted|other-write-bit|would-be-future|prop:equal\+hash|place-location\?|sequence-length|read-accept-box|regexp-replaces|string-downcase|collection-path|exn:fail:object|read-accept-dot|prop:input-port|placeholder-get|keyword->string|open-input-file|hash-copy-clear|regexp-replace\*|read-bytes-line|regexp-replace|string-append\*|make-weak-hash|terminal-port\?|compile-syntax|poll-guard-evt|complete-path\?|string->symbol|exn:fail:read\?|place-enabled\?|string->number|place-dead-evt|place-channel\?|mixin-contract|make-semaphore|make-readtable|convert-stream|group-read-bit|user-write-bit|value-contract|syntax-protect|relative-path\?|current-future|list-contract\?|make-parameter|get-preference|exact->inexact|exn:fail:user\?|phantom-bytes\?|current-locale|bytes-no-nuls\?|current-logger|pretty-display|make-inspector|chaperone-hash|in-bytes-lines|peek-bytes-evt|mutable-seteqv|arity-at-least|nack-guard-evt|current-thread|in-dict-values|empty-sequence|in-hash-values|blame-swapped\?|custodian-box\?|vector->values|weak-box-value|srcloc->string|in-mutable-set|blame-positive|split-at-right|make-exn:break|blame-negative|make-ephemeron|udp-connected\?|blame-contract|dynamic-place\*|make-directory|load-extension|read-bytes-evt|single-flonum\?|make-custodian|will-executor\?|subprocess-pid|dup-input-port|string-replace|inexact->exact|semaphore-post|symbol->string|string-suffix\?|log-all-levels|semaphore-wait|double-flonum\?|normalize-path|thread-suspend|process\*/ports|flat-contract\?|char-symbolic\?|read/recursive|number->string|sequence->list|integer-length|sequence-count|object->vector|proper-subset\?|directory-list|file-position\*|absolute-path\?|list->weak-set|other-read-bit|thread-receive|set-intersect!|tcp-accept-evt|sequence-ormap|set-copy-clear|struct->vector|char-titlecase|prop:procedure|keywords-match|exact-integer\?|string-prefix\?|exact-truncate|stream-empty\?|read-line-evt|string-upcase|vector-argmin|flat-contract|date-year-day|vector-argmax|file-truncate|keyword-apply|vector-append|file-position|thread-resume|write-to-file|tcp-addresses|sequence-tail|date-week-day|write-special|custom-write\?|dict-for-each|dict-has-key\?|set-intersect|path-element\?|thread-group\?|dict-mutable\?|regexp-match\*|datum->syntax|prop:contract|read-language|prop:sequence|char-numeric\?|blame-context|syntax-column|expand-syntax|tcp-listener\?|syntax->datum|promise/name\?|sequence-fold|base->-rngs/c|base->-doms/c|mutable-seteq|box-immutable|load-relative|break-enabled|integer->char|progress-evt\?|process/ports|display-lines|set-subtract!|log-level-evt|log-max-level|exn:fail:user|log-receiver\?|byte-pregexp\?|place-channel|char-graphic\?|inexact-real\?|char-foldcase|string-length|seconds->date|has-contract\?|will-register|char-downcase|regexp-match\?|exn:fail:read|udp-addresses|make-contract|simplify-path|dynamic-place|chaperone-box|make-exn:fail|string-append|srcloc-column|make-weak-box|hash-for-each|chaperone-evt|hash-has-key\?|bytes-append\*|bytes-convert|stream-filter|in-hash-pairs|in-dict-pairs|udp-receive!\*|srcloc-source|struct:srcloc|syntax-source|continuation\?|contract-name|contract-proc|impersonator\?|chaperone-of\?|user-read-bit|vector-member|shell-execute|vector-filter|stream-length|current-print|current-drive|stream-andmap|vector-length|pretty-format|exact-ceiling|char->integer|stream-append|eqv-hash-code|syntax-disarm|regexp-split|stream-count|bytes-length|current-load|stream-first|pretty-print|equal\?/recur|make-plumber|current-eval|exit-handler|stream-ormap|eq-hash-code|syntax-rearm|eq-contract\?|hash-update!|make-hasheqv|string->list|udp-send-to\*|make-generic|stream->list|udp-send-evt|syntax-taint|vector-set\*!|hash-remove!|pretty-write|in-dict-keys|port-closed\?|string->path|empty-stream|udp-receive!|in-directory|in-hash-keys|dynamic-wind|port->string|dynamic-send|bytes-append|vector-fill!|print-struct|string-ci<=\?|resolve-path|placeholder\?|in-sequences|printable<%>|string-ci>=\?|udp-connect!|thread-cell\?|regexp-quote|will-execute|combinations|string-copy!|string-fill!|make-channel|string-len/c|shared-bytes|in-weak-hash|byte-regexp\?|byte-pregexp|build-vector|build-string|permutations|set-subtract|module-path\?|local-expand|generic-set\?|instanceof/c|break-thread|peek-string!|exn:srclocs\?|vector->list|blame-update|sync/timeout|integer-sqrt|blame-source|dict-update!|cleanse-path|explode-path|list-prefix\?|string-port\?|path-string\?|set-mutable\?|dict-remove!|vector-count|list->vector|list->string|list->seteqv|thread-dead\?|regexp-match|flush-output|struct-type\?|class-unseal|string-split|sequence-map|path->string|sequence-ref|link-exists\?|file->string|write-string|file-exists\?|port-number\?|read-string!|vector-copy!|output-port\?|set-for-each|struct:date\*|syntax->list|make-logger|string-join|dict-update|subprocess\?|prop:stream|dropf-right|write-bytes|in-weak-set|input-port\?|writable<%>|add-between|set-remove!|set-member\?|printable/c|weak-seteqv|print-graph|subclass\?/c|eof-object\?|syntax-line|hash-clear!|vector-take|prefab-key\?|predicate/c|string-copy|eval-syntax|exact-floor|port->lines|vector-set!|random-seed|exact-round|string-ci>\?|rationalize|vector-memv|port->bytes|vector-memq|vector-map!|kill-thread|place-sleep|in-producer|place-break|dict-empty\?|vector-drop|exn-message|peek-string|in-parallel|read-bytes!|string-ci=\?|peek-bytes!|dict-clear!|string-ci<\?|hash-empty\?|bitwise-and|in-naturals|path->bytes|hash-equal\?|denominator|set->stream|delete-file|parameter/c|vector-copy|bitwise-ior|bitwise-not|bitwise-xor|hash-remove|expand-once|blame-value|char-blank\?|object-name|read-string|object-info|string-set!|date-second|read-syntax|date-minute|struct:date|byte-ready\?|list->bytes|byte-regexp|bytes->list|value-blame|bytes->path|field-names|hash-update|bytes-copy!|bytes-fill!|hash-values|list->seteq|srcloc-line|string-trim|list-update|stream-tail|file->bytes|file->lines|udp-send-to|mutable-set|stream-rest|syntax-span|handle-evt\?|merge-input|log-message|logger-name|thread-wait|thread-send|channel-get|channel-put|dict-remove|system-type|srcloc-span|make-vector|make-string|make-srcloc|takef-right|char-upcase|stream-fold|make-object|struct-info|identifier\?|char-ready\?|reroot-path|replace-evt|make-none/c|make-hasheq|stop-before|tcp-connect|file->value|fsemaphore\?|dict-values|immutable\?|stop-after|filter-map|filter-not|char-ci>=\?|make-date\*|file->list|make-polar|tcp-accept|find-files|take-right|make-bytes|char-ci<=\?|chaperone\?|time-apply|stream-map|log-level\?|choice-evt|class-info|semaphore\?|class-seal|udp-bound\?|stream-ref|namespace\?|bytes-set!|first-or/c|hash-weak\?|in-indexed|custodian\?|bytes-join|bytes-copy|readtable\?|build-path|struct:exn|build-list|date-month|sequence/c|hash-set\*!|blame-swap|parameter\?|split-path|exn:break\?|fold-files|string-ref|dict->list|dict-clear|drop-right|set-clear!|peek-bytes|read-bytes|hash-count|set-empty\?|dict-count|set-equal\?|vector-map|place-kill|place-wait|vector-ref|port->list|append-map|primitive\?|ephemeron\?|weak-seteq|hash-clear|always-evt|interface\?|subprocess|integer-in|set-remove|hash->list|tcp-listen|inspector\?|procedure\?|dynamic->\*|syntax-arm|write-byte|has-blame\?|set-union!|write-char|prop:blame|dict-set\*!|handle-evt|displayln|suggest/c|substring|set-weak\?|in-vector|set-union|in-syntax|infinite\?|in-string|in-stream|dict-set\*|set-mcdr!|subclass\?|set-mcar!|dict-set!|dict-ref!|keyword<\?|dict-keys|set-first|set-count|dict-copy|exn:break|set-clear|set->list|last-pair|splitf-at|exn:fail\?|date-year|date-hour|date-dst\?|list->set|copy-port|list-tail|copy-file|contract\?|magnitude|make-date|make-hash|make-list|tcp-close|file-size|char-in/c|imag-part|tcp-port\?|char-ci>\?|char-ci=\?|remainder|make-pipe|char-ci<\?|channel/c|udp-bind!|string>=\?|udp-close|udp-send\*|bytes-ref|string<=\?|negative\?|never-evt|new-∀/c|new-∃/c|real-part|numerator|hash-set\*|hash-set!|boolean=\?|read-line|hash-ref!|read-char|read-cdot|hash-keys|hash-eqv\?|partition|path-only|between/c|peek-byte|peek-char|read-byte|rational\?|hash-copy|positive\?|weak-box\?|print-box|alarm-evt|guard-evt|promise/c|prop:dict|conjugate|sequence\?|in-range|group-by|set-eqv\?|set-box!|generic\?|dict-map|dict-ref|channel\?|hash-eq\?|set-add!|dict-set|one-of/c|box-cas!|for-each|make-exn|set-copy|hash-map|hash-ref|hash-set|syntax-e|integer\?|set-rest|inexact\?|vectorof|truncate|stream/c|string<\?|string=\?|symbol=\?|string>\?|symbol<\?|vector/c|prop:evt|plumber\?|pregexp\?|identity|in-value|list-set|in-bytes|in-cycle|weak-set|in-slice|date-day|subbytes|in-lines|list-ref|boolean\?|udp-send|promise\?|process\*|keyword\?|equal<%>|object=\?|compose1|exn:fail|in-mlist|split-at|syntax/c|quotient|wrap-evt|complex\?|char<=\?|system\*|println|syntax\?|in-port|compose|in-list|conjoin|regexp\?|bytes>\?|process|compile|\*list/c|object%|thread\?|eof-evt|load/cd|logger\?|struct\?|pregexp|bytes=\?|in-hash|in-dict|srcloc\?|list\*of|append\*|shuffle|writeln|call/cc|hasheqv|subset\?|seventh|char>=\?|call/ec|number\?|bytes<\?|string\?|object\?|symbol\?|symbols|version|display|disjoin|stream\?|vector\?|fixnum\?|arity=\?|flatten|flonum\?|set-map|reverse|newline|ceiling|fprintf|is-a\?/c|future\?|real-in|char-in|remove\*|set-eq\?|set-add|base->\?|eprintf|andmap|modulo|blame\?|cdaadr|cdaaar|seteqv|length|eighth|vector|cadddr|caddar|date\*\?|cdaddr|cadadr|empty\?|curryr|cadaar|caaddr|in-set|equal\?|mpair\?|list/c|cddaar|cddadr|member|argmax|cons/c|argmin|listof|caadar|printf|caaadr|caaaar|bytes\?|system|putenv|exact\?|expand|class\?|random|srcloc|cdddar|false\?|filter|char>\?|hasheq|none/c|second|cddddr|hash/c|string|place\?|char=\?|values|char<\?|negate|append|regexp|cdadar|fourth|future|banner|gensym|getenv|remove|thread|format|path<\?|tenth|third|remf\*|path\?|char\?|ninth|remq\*|pair\?|ormap|mcons|assoc|remv\*|round|cdddr|takef|range|cons\?|cddar|const|list\?|apply|port\?|count|curry|touch|cdadr|date\*|list\*|date\?|findf|is-a\?|box/c|set/c|set=\?|dict\?|void\?|null\?|seteq|dropf|not/c|caddr|empty|print|cadar|raise|any/c|byte\?|caadr|sixth|angle|and/c|error|caaar|n->th|sleep|even\?|evt/c|write|bytes|unbox|fifth|unit\?|first|floor|foldl|foldr|force|real\?|zero\?|hash\?|cdaar|sinh|nan\?|udp\?|caar|cadr|null|hash|rest|box\?|<=/c|memv|expt|true|memq|cdar|memf|cddr|odd\?|exn\?|or/c|mcdr|mcar|if/c|eqv\?|exit|remf|remq|atan|assv|assq|remv|assf|asin|pi\.f|tanh|>=/c|take|read|acos|load|cons|sort|add1|cosh|date|list|evt\?|eval|last|sync|void|set\?|drop|sub1|sqrt|sin|sgn|eof|~\.a|eq\?|</c|lcm|set|cos|~\.s|log|abs|tan|~\.v|gcd|map|xor|=/c|max|cdr|exp|sqr|box|min|car|>/c|not|exn|~v|~s|<=|~r|~e|~a|>=|pi|/|\*|>|\+|=|-|<)(?=[()[\]{}",\'`;\s])"> + <token type="NameBuiltin"/> + <pop depth="1"/> + </rule> + <rule pattern="(?:\|[^|]*\||\\[\w\W]|[^|\\()[\]{}",\'`;\s]+)+"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule> + <include state="datum*"/> + </rule> + </state> + <state name="unquoted-list"> + <rule> + <include state="list"/> + </rule> + <rule pattern="(?!\Z)"> + <token type="Text"/> + <push state="unquoted-datum"/> + </rule> + </state> + <state name="quasiquoted-datum"> + <rule> + <include state="datum"/> + </rule> + <rule pattern=",@?"> + <token type="Operator"/> + <push state="#pop" state="unquoted-datum"/> + </rule> + <rule pattern="unquote(-splicing)?(?=[()[\]{}",\'`;\s])"> + <token type="Keyword"/> + <push state="#pop" state="unquoted-datum"/> + </rule> + <rule pattern="[([{]"> + <token type="Punctuation"/> + <push state="#pop" state="quasiquoted-list"/> + </rule> + <rule> + <include state="datum*"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ragel.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ragel.xml new file mode 100644 index 0000000..69638d2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ragel.xml @@ -0,0 +1,149 @@ +<lexer> + <config> + <name>Ragel</name> + <alias>ragel</alias> + </config> + <rules> + <state name="host"> + <rule pattern="([^{}\'"/#]+|[^\\]\\[{}]|"(\\\\|\\"|[^"])*"|'(\\\\|\\'|[^'])*'|//.*$\n?|/\*(.|\n)*?\*/|\#.*$\n?|/(?!\*)(\\\\|\\/|[^/])*/|/)+"> + <token type="Other"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="0x[0-9A-Fa-f]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[+-]?[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="literals"> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralString"/> + </rule> + <rule pattern="\[(\\\\|\\\]|[^\]])*\]"> + <token type="LiteralString"/> + </rule> + <rule pattern="/(?!\*)(\\\\|\\/|[^/])*/"> + <token type="LiteralStringRegex"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(access|action|alphtype)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(getkey|write|machine|include)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(any|ascii|extend|alpha|digit|alnum|lower|upper)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(xdigit|cntrl|graph|print|punct|space|zlen|empty)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="identifiers"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameVariable"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="literals"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule> + <include state="identifiers"/> + </rule> + <rule> + <include state="operators"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="host"/> + </rule> + <rule pattern="="> + <token type="Operator"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + </rule> + </state> + <state name="comments"> + <rule pattern="\#.*$"> + <token type="Comment"/> + </rule> + </state> + <state name="operators"> + <rule pattern=","> + <token type="Operator"/> + </rule> + <rule pattern="\||&|--?"> + <token type="Operator"/> + </rule> + <rule pattern="\.|<:|:>>?"> + <token type="Operator"/> + </rule> + <rule pattern=":"> + <token type="Operator"/> + </rule> + <rule pattern="->"> + <token type="Operator"/> + </rule> + <rule pattern="(>|\$|%|<|@|<>)(/|eof\b)"> + <token type="Operator"/> + </rule> + <rule pattern="(>|\$|%|<|@|<>)(!|err\b)"> + <token type="Operator"/> + </rule> + <rule pattern="(>|\$|%|<|@|<>)(\^|lerr\b)"> + <token type="Operator"/> + </rule> + <rule pattern="(>|\$|%|<|@|<>)(~|to\b)"> + <token type="Operator"/> + </rule> + <rule pattern="(>|\$|%|<|@|<>)(\*|from\b)"> + <token type="Operator"/> + </rule> + <rule pattern=">|@|\$|%"> + <token type="Operator"/> + </rule> + <rule pattern="\*|\?|\+|\{[0-9]*,[0-9]*\}"> + <token type="Operator"/> + </rule> + <rule pattern="!|\^"> + <token type="Operator"/> + </rule> + <rule pattern="\(|\)"> + <token type="Operator"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/react.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/react.xml new file mode 100644 index 0000000..a4109b0 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/react.xml @@ -0,0 +1,236 @@ +<lexer> + <config> + <name>react</name> + <alias>jsx</alias> + <alias>react</alias> + <filename>*.jsx</filename> + <filename>*.react</filename> + <mime_type>text/jsx</mime_type> + <mime_type>text/typescript-jsx</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="commentsandwhitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="<!--"> + <token type="Comment"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="slashstartsregex"> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gimuy]+\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="tag"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="([\w]+\s*)(=)(\s*)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + <push state="attr"/> + </rule> + <rule pattern="[{}]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="[\w\.]+"> + <token type="NameAttribute"/> + </rule> + <rule pattern="(/?)(\s*)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + <state name="expression"> + <rule pattern="{"> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="attr"> + <rule pattern="{"> + <token type="Punctuation"/> + <push state="expression"/> + </rule> + <rule pattern="".*?""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="'.*?'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="interp-inside"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="badregex"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="jsx"> + <rule pattern="(<)(/?)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Punctuation"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(<)([\w\.]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameTag"/> + </bygroups> + <push state="tag"/> + </rule> + <rule pattern="(<)(/)([\w\.]+)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Punctuation"/> + <token type="NameTag"/> + <token type="Punctuation"/> + </bygroups> + </rule> + </state> + <state name="root"> + <rule> + <include state="jsx"/> + </rule> + <rule pattern="\A#! ?/.*?\n"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="^(?=\s|/|<!--)"> + <token type="Text"/> + <push state="slashstartsregex"/> + </rule> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="(\.\d+|[0-9]+\.[0-9]*)([eE][-+]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[bB][01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0[oO][0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\.\.\.|=>"> + <token type="Punctuation"/> + </rule> + <rule pattern="\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?"> + <token type="Operator"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[{(\[;,]"> + <token type="Punctuation"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[})\].]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(for|in|while|do|break|return|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|void|yield|this|of)\b"> + <token type="Keyword"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(var|let|with|function)\b"> + <token type="KeywordDeclaration"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(abstract|async|await|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"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(true|false|null|NaN|Infinity|undefined)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|Promise|Proxy|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|Error|eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|document|this|window)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?:[$_\p{L}\p{N}]|\\u[a-fA-F0-9]{4})(?:(?:[$\p{L}\p{N}]|\\u[a-fA-F0-9]{4}))*"> + <token type="NameOther"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <push state="interp"/> + </rule> + </state> + <state name="interp"> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\\`"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="interp-inside"/> + </rule> + <rule pattern="\$"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="[^`\\$]+"> + <token type="LiteralStringBacktick"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/reasonml.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/reasonml.xml new file mode 100644 index 0000000..8b7bcc5 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/reasonml.xml @@ -0,0 +1,147 @@ +<lexer> + <config> + <name>ReasonML</name> + <alias>reason</alias> + <alias>reasonml</alias> + <filename>*.re</filename> + <filename>*.rei</filename> + <mime_type>text/x-reasonml</mime_type> + </config> + <rules> + <state name="escape-sequence"> + <rule pattern="\\[\\"\'ntbr]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\[0-9]{3}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\x[0-9a-fA-F]{2}"> + <token type="LiteralStringEscape"/> + </rule> + </state> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="false|true|\(\)|\[\]"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="\b([A-Z][\w\']*)(?=\s*\.)"> + <token type="NameNamespace"/> + <push state="dotted"/> + </rule> + <rule pattern="\b([A-Z][\w\']*)"> + <token type="NameClass"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\/\*(?![\/])"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\b(as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|false|for|fun|esfun|function|functor|if|in|include|inherit|initializer|lazy|let|switch|module|pub|mutable|new|nonrec|object|of|open|pri|rec|sig|struct|then|to|true|try|type|val|virtual|when|while|with)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(~|\}|\|]|\||\|\||\{<|\{|`|_|]|\[\||\[>|\[<|\[|\?\?|\?|>\}|>]|>|=|<-|<|;;|;|:>|:=|::|:|\.\.\.|\.\.|\.|=>|-\.|-|,|\+|\*|\)|\(|&&|&|#|!=)"> + <token type="OperatorWord"/> + </rule> + <rule pattern="([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]"> + <token type="Operator"/> + </rule> + <rule pattern="\b(and|asr|land|lor|lsl|lsr|lxor|mod|or)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="\b(unit|int|float|bool|string|char|list|array)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[^\W\d][\w']*"> + <token type="Name"/> + </rule> + <rule pattern="-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)"> + <token type="LiteralNumberFloat"/> + </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_]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'.'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'"> + <token type="Keyword"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="[~?][a-z][\w\']*:"> + <token type="NameVariable"/> + </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="string"> + <rule pattern="[^\\"]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule> + <include state="escape-sequence"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <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\']*(?=\s*\.)"> + <token type="NameNamespace"/> + </rule> + <rule pattern="[A-Z][\w\']*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-z_][\w\']*"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/reg.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/reg.xml new file mode 100644 index 0000000..501d380 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/reg.xml @@ -0,0 +1,68 @@ +<lexer> + <config> + <name>reg</name> + <alias>registry</alias> + <filename>*.reg</filename> + <mime_type>text/x-windows-registry</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="Windows Registry Editor.*"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[;#].*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(\[)(-?)(HKEY_[A-Z_]+)(.*?\])$"> + <bygroups> + <token type="Keyword"/> + <token type="Operator"/> + <token type="NameBuiltin"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="("(?:\\"|\\\\|[^"])+")([ \t]*)(=)([ \t]*)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="(.*?)([ \t]*)(=)([ \t]*)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Text"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + <push state="value"/> + </rule> + </state> + <state name="value"> + <rule pattern="-"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule pattern="(dword|hex(?:\([0-9a-fA-F]\))?)(:)([0-9a-fA-F,]+)"> + <bygroups> + <token type="NameVariable"/> + <token type="Punctuation"/> + <token type="LiteralNumber"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern=".+"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/rexx.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/rexx.xml new file mode 100644 index 0000000..e682500 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/rexx.xml @@ -0,0 +1,127 @@ +<lexer> + <config> + <name>Rexx</name> + <alias>rexx</alias> + <alias>arexx</alias> + <filename>*.rexx</filename> + <filename>*.rex</filename> + <filename>*.rx</filename> + <filename>*.arexx</filename> + <mime_type>text/x-rexx</mime_type> + <case_insensitive>true</case_insensitive> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="keyword"> + <rule pattern="(address|arg|by|call|do|drop|else|end|exit|for|forever|if|interpret|iterate|leave|nop|numeric|off|on|options|parse|pull|push|queue|return|say|select|signal|to|then|trace|until|while)\b"> + <token type="KeywordReserved"/> + </rule> + </state> + <state name="operator"> + <rule pattern="(-|//|/|\(|\)|\*\*|\*|\\<<|\\<|\\==|\\=|\\>>|\\>|\\|\|\||\||&&|&|%|\+|<<=|<<|<=|<>|<|==|=|><|>=|>>=|>>|>|¬<<|¬<|¬==|¬=|¬>>|¬>|¬|\.|,)"> + <token type="Operator"/> + </rule> + </state> + <state name="string_double"> + <rule pattern="[^"\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern=""""> + <token type="LiteralString"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="string_single"> + <rule pattern="[^\'\n]"> + <token type="LiteralString"/> + </rule> + <rule pattern="\'\'"> + <token type="LiteralString"/> + </rule> + <rule pattern="\'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="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="root"> + <rule pattern="\s"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string_double"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="string_single"/> + </rule> + <rule pattern="[0-9]+(\.[0-9]+)?(e[+-]?[0-9])?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="([a-z_]\w*)(\s*)(:)(\s*)(procedure)\b"> + <bygroups> + <token type="NameFunction"/> + <token type="TextWhitespace"/> + <token type="Operator"/> + <token type="TextWhitespace"/> + <token type="KeywordDeclaration"/> + </bygroups> + </rule> + <rule pattern="([a-z_]\w*)(\s*)(:)"> + <bygroups> + <token type="NameLabel"/> + <token type="TextWhitespace"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule> + <include state="function"/> + </rule> + <rule> + <include state="keyword"/> + </rule> + <rule> + <include state="operator"/> + </rule> + <rule pattern="[a-z_]\w*"> + <token type="Text"/> + </rule> + </state> + <state name="function"> + <rule pattern="(sourceline|wordlength|errortext|translate|wordindex|condition|datatype|subword|lineout|lastpos|delword|address|charout|wordpos|compare|overlay|reverse|symbol|stream|charin|center|delstr|verify|digits|abbrev|bitxor|format|random|insert|bitand|queued|length|linein|substr|copies|xrange|space|words|lines|bitor|trunc|strip|right|value|chars|trace|sign|form|fuzz|word|left|time|date|c2d|d2c|d2x|c2x|pos|b2x|arg|abs|min|x2b|x2c|x2d|max)(\s*)(\()"> + <bygroups> + <token type="NameBuiltin"/> + <token type="TextWhitespace"/> + <token type="Operator"/> + </bygroups> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ruby.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ruby.xml new file mode 100644 index 0000000..b47b1ab --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/ruby.xml @@ -0,0 +1,723 @@ +<lexer> + <config> + <name>Ruby</name> + <alias>rb</alias> + <alias>ruby</alias> + <alias>duby</alias> + <filename>*.rb</filename> + <filename>*.rbw</filename> + <filename>Rakefile</filename> + <filename>*.rake</filename> + <filename>*.gemspec</filename> + <filename>*.rbx</filename> + <filename>*.duby</filename> + <filename>Gemfile</filename> + <mime_type>text/x-ruby</mime_type> + <mime_type>application/x-ruby</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="simple-sym"> + <rule> + <include state="string-intp-escaped"/> + </rule> + <rule pattern="[^\\"#]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="[\\#]"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="""> + <token type="LiteralStringSymbol"/> + <pop depth="1"/> + </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="strings"> + <rule pattern="\:@{0,2}[a-zA-Z_]\w*[!?]?"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="\:@{0,2}(===|\[\]=|<=>|\*\*|==|>=|\+@|<>|>>|<<|-@|\[\]|~|`|\^|\||&|<|%|/|>|\+|-|\*)"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern=":'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern=":""> + <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="""> + <token type="LiteralStringDouble"/> + <push state="simple-string"/> + </rule> + <rule pattern="(?<!\.)`"> + <token type="LiteralStringBacktick"/> + <push state="simple-backtick"/> + </rule> + <rule pattern="%[QWx]?\{"> + <token type="LiteralStringOther"/> + <push state="cb-intp-string"/> + </rule> + <rule pattern="%[qsw]\{"> + <token type="LiteralStringOther"/> + <push state="cb-string"/> + </rule> + <rule pattern="%r\{"> + <token type="LiteralStringRegex"/> + <push state="cb-regex"/> + </rule> + <rule pattern="%[QWx]?\["> + <token type="LiteralStringOther"/> + <push state="sb-intp-string"/> + </rule> + <rule pattern="%[qsw]\["> + <token type="LiteralStringOther"/> + <push state="sb-string"/> + </rule> + <rule pattern="%r\["> + <token type="LiteralStringRegex"/> + <push state="sb-regex"/> + </rule> + <rule pattern="%[QWx]?\("> + <token type="LiteralStringOther"/> + <push state="pa-intp-string"/> + </rule> + <rule pattern="%[qsw]\("> + <token type="LiteralStringOther"/> + <push state="pa-string"/> + </rule> + <rule pattern="%r\("> + <token type="LiteralStringRegex"/> + <push state="pa-regex"/> + </rule> + <rule pattern="%[QWx]?<"> + <token type="LiteralStringOther"/> + <push state="ab-intp-string"/> + </rule> + <rule pattern="%[qsw]<"> + <token type="LiteralStringOther"/> + <push state="ab-string"/> + </rule> + <rule pattern="%r<"> + <token type="LiteralStringRegex"/> + <push state="ab-regex"/> + </rule> + <rule pattern="(%r([\W_]))((?:\\\2|(?!\2).)*)(\2[mixounse]*)"> + <token type="LiteralString"/> + </rule> + <rule pattern="%[qsw]([\W_])((?:\\\1|(?!\1).)*)\1"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="(%[QWx]([\W_]))((?:\\\2|(?!\2).)*)(\2)"> + <token type="LiteralString"/> + </rule> + <rule pattern="(?<=[-+/*%=<>&!^|~,(])(\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="(%([^a-zA-Z0-9\s]))((?:\\\2|(?!\2).)*)(\2)"> + <token type="LiteralString"/> + </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="ab-regex"> + <rule pattern="\\[\\<>]"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="<"> + <token type="LiteralStringRegex"/> + <push/> + </rule> + <rule pattern=">[mixounse]*"> + <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="cb-regex"> + <rule pattern="\\[\\{}]"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="\{"> + <token type="LiteralStringRegex"/> + <push/> + </rule> + <rule pattern="\}[mixounse]*"> + <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="end-part"> + <rule pattern=".+"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="string-intp"> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="in-intp"/> + </rule> + <rule pattern="#@@?[a-zA-Z_]\w*"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="#\$[a-zA-Z_]\w*"> + <token type="LiteralStringInterpol"/> + </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="classname"> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="defexpr"/> + </rule> + <rule pattern="<<"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule pattern="[A-Z_]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule> + <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="root"> + <rule pattern="\A#!.+?$"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="#.*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="=begin\s.*?\n=end.*?$"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="(defined\?|return|ensure|rescue|unless|undef|until|break|begin|elsif|super|alias|while|retry|BEGIN|raise|yield|redo|next|case|when|then|else|end|for|END|do|if|in)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(module)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(def)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="funcname"/> + </rule> + <rule pattern="def(?=[*%&^`~+-/\[<>=])"> + <token type="Keyword"/> + <push state="funcname"/> + </rule> + <rule pattern="(class)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="classname"/> + </rule> + <rule pattern="(module_function|attr_accessor|attr_reader|attr_writer|initialize|protected|include|private|extend|public|raise|false|catch|throw|attr|loop|true|new|nil)\b"> + <token type="KeywordPseudo"/> + </rule> + <rule pattern="(not|and|or)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="(protected_method_defined|private_method_defined|public_method_defined|method_defined|const_defined|block_given|instance_of|respond_to|iterator|autoload|kind_of|tainted|include|frozen|equal|is_a|nil|eql)\?"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(chomp|chop|exit|gsub|sub)!"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<!\.)(protected_instance_methods|private_instance_methods|public_instance_methods|instance_variable_set|instance_variable_get|private_class_method|public_class_method|instance_variables|protected_methods|singleton_methods|included_modules|instance_methods|global_variables|private_methods|local_variables|instance_method|class_variables|public_methods|const_defined\?|set_trace_func|method_missing|const_missing|instance_eval|module_eval|untrace_var|class_eval|trace_var|const_get|readlines|ancestors|constants|const_set|object_id|readline|autoload|__send__|untaint|methods|display|Integer|sprintf|inspect|require|syscall|at_exit|binding|extend|printf|lambda|__id__|String|callcc|method|select|format|system|freeze|caller|raise|Float|print|throw|taint|clone|srand|Array|abort|split|catch|chomp|sleep|open|puts|putc|fork|fail|trap|exit|scan|getc|self|send|eval|gets|exec|gsub|proc|load|loop|chop|warn|hash|test|name|to_a|rand|to_s|sub|dup|id|p)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="__(FILE|LINE)__\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(?<!\w)(<<-?)(["`\']?)([a-zA-Z_]\w*)(\2)(.*?\n)"> + <token type="LiteralString"/> + </rule> + <rule pattern="(<<-?)("|\')()(\2)(.*?\n)"> + <token type="LiteralString"/> + </rule> + <rule pattern="__END__"> + <token type="CommentPreproc"/> + <push state="end-part"/> + </rule> + <rule pattern="(?:^|(?<=[=<>~!:])|(?<=(?:\s|;)when\s)|(?<=(?:\s|;)or\s)|(?<=(?:\s|;)and\s)|(?<=\.index\s)|(?<=\.scan\s)|(?<=\.sub\s)|(?<=\.sub!\s)|(?<=\.gsub\s)|(?<=\.gsub!\s)|(?<=\.match\s)|(?<=(?:\s|;)if\s)|(?<=(?:\s|;)elsif\s)|(?<=^when\s)|(?<=^index\s)|(?<=^scan\s)|(?<=^sub\s)|(?<=^gsub\s)|(?<=^sub!\s)|(?<=^gsub!\s)|(?<=^match\s)|(?<=^if\s)|(?<=^elsif\s))(\s*)(/)"> + <bygroups> + <token type="Text"/> + <token type="LiteralStringRegex"/> + </bygroups> + <push state="multiline-regex"/> + </rule> + <rule pattern="(?<=\(|,|\[)/"> + <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="(0_?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?"> + <bygroups> + <token type="LiteralNumberOct"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?"> + <bygroups> + <token type="LiteralNumberHex"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="(0b[01]+(?:_[01]+)*)(\s*)([/?])?"> + <bygroups> + <token type="LiteralNumberBin"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="([\d]+(?:[_e]\d+)*)(\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="\$[!@&`\'+~=/\\,;.<>_*$?:"^-]"> + <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]-)*(\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)(?!\w)"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="[A-Z]\w+"> + <token type="NameConstant"/> + </rule> + <rule pattern="(\.|::)(===|\[\]=|<=>|\*\*|==|>=|\+@|<>|>>|<<|-@|\[\]|~|`|\^|\||&|<|%|/|>|\+|-|\*)"> + <bygroups> + <token type="Operator"/> + <token type="NameOperator"/> + </bygroups> + </rule> + <rule pattern="(\.|::)([a-zA-Z_]\w*[!?]?|[*%&^`~+\-/\[<>=])"> + <bygroups> + <token type="Operator"/> + <token type="Name"/> + </bygroups> + </rule> + <rule pattern="[a-zA-Z_]\w*[!?]?"> + <token type="Name"/> + </rule> + <rule pattern="(\[|\]|\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\.{1,3})"> + <token type="Operator"/> + </rule> + <rule pattern="[-+/*%=<>&!^|~]=?"> + <token type="Operator"/> + </rule> + <rule pattern="[(){};,/?:\\]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + </state> + <state name="defexpr"> + <rule pattern="(\))(\.|::)?"> + <bygroups> + <token type="Punctuation"/> + <token type="Operator"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="\("> + <token type="Operator"/> + <push/> + </rule> + <rule> + <include state="root"/> + </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="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="/[mixounse]*"> + <token type="LiteralStringRegex"/> + <pop depth="1"/> + </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="funcname"> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="defexpr"/> + </rule> + <rule pattern="(?:([a-zA-Z_]\w*)(\.))?([a-zA-Z_]\w*[!?]?|\*\*?|[-+]@?|[/%&|^`~]|\[\]=?|<<|>>|<=?>|>=?|===?)"> + <bygroups> + <token type="NameClass"/> + <token type="Operator"/> + <token type="NameFunction"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </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-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="string-intp-escaped"> + <rule> + <include state="string-intp"/> + </rule> + <rule pattern="\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})"> + <token type="LiteralStringEscape"/> + </rule> + </state> + <state name="simple-string"> + <rule> + <include state="string-intp-escaped"/> + </rule> + <rule pattern="[^\\"#]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[\\#]"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + <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-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="sb-regex"> + <rule pattern="\\[\\\[\]]"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="\["> + <token type="LiteralStringRegex"/> + <push/> + </rule> + <rule pattern="\][mixounse]*"> + <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="pa-regex"> + <rule pattern="\\[\\()]"> + <token type="LiteralStringRegex"/> + </rule> + <rule pattern="\("> + <token type="LiteralStringRegex"/> + <push/> + </rule> + <rule pattern="\)[mixounse]*"> + <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="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="ab-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> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/rust.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/rust.xml new file mode 100644 index 0000000..f41049c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/rust.xml @@ -0,0 +1,329 @@ +<lexer> + <config> + <name>Rust</name> + <alias>rust</alias> + <alias>rs</alias> + <filename>*.rs</filename> + <filename>*.rs.in</filename> + <mime_type>text/rust</mime_type> + <mime_type>text/x-rust</mime_type> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <state name="modname"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="lifetime"> + <rule pattern="(static|_)"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[a-zA-Z_]+\w*"> + <token type="NameAttribute"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="number_lit"> + <rule pattern="[ui](8|16|32|64|size)"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule pattern="f(32|64)"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="attribute_common"> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="\["> + <token type="CommentPreproc"/> + <push state="attribute["/> + </rule> + </state> + <state name="bytestring"> + <rule pattern="\\x[89a-fA-F][0-9a-fA-F]"> + <token type="LiteralStringEscape"/> + </rule> + <rule> + <include state="string"/> + </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="doccomment"> + <rule pattern="[^*/]+"> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="/\*"> + <token type="LiteralStringDoc"/> + <push/> + </rule> + <rule pattern="\*/"> + <token type="LiteralStringDoc"/> + <pop depth="1"/> + </rule> + <rule pattern="[*/]"> + <token type="LiteralStringDoc"/> + </rule> + </state> + <state name="funcname"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0|\\u\{[0-9a-fA-F]{1,6}\}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + </state> + <state name="root"> + <rule pattern="#![^[\r\n].*$"> + <token type="CommentPreproc"/> + </rule> + <rule> + <push state="base"/> + </rule> + </state> + <state name="attribute["> + <rule> + <include state="attribute_common"/> + </rule> + <rule pattern="\]"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + <rule pattern="[^"\]\[]+"> + <token type="CommentPreproc"/> + </rule> + </state> + <state name="base"> + <rule pattern="\n"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="//!.*?\n"> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="///(\n|[^/].*?\n)"> + <token type="LiteralStringDoc"/> + </rule> + <rule pattern="//(.*?)\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*\*(\n|[^/*])"> + <token type="LiteralStringDoc"/> + <push state="doccomment"/> + </rule> + <rule pattern="/\*!"> + <token type="LiteralStringDoc"/> + <push state="doccomment"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="r#*"(?:\\.|[^\\;])*"#*"> + <token type="LiteralString"/> + </rule> + <rule pattern=""(?:\\.|[^\\"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="\$([a-zA-Z_]\w*|\(,?|\),?|,?)"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="(unsafe|static|extern|return|const|crate|where|while|await|trait|super|async|match|impl|else|move|loop|pub|ref|mut|for|dyn|use|box|in|if|as)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(abstract|override|unsized|virtual|become|typeof|final|macro|yield|priv|try|do)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="self\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="mod\b"> + <token type="Keyword"/> + <push state="modname"/> + </rule> + <rule pattern="let\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="fn\b"> + <token type="Keyword"/> + <push state="funcname"/> + </rule> + <rule pattern="(struct|enum|type|union)\b"> + <token type="Keyword"/> + <push state="typename"/> + </rule> + <rule pattern="(default)(\s+)(type|fn)\b"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(isize|usize|bool|char|u128|i128|i64|i32|i16|str|u64|u32|f32|f64|u16|i8|u8)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[sS]elf\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="(DoubleEndedIterator|ExactSizeIterator|IntoIterator|PartialOrd|PartialEq|ToString|Iterator|ToOwned|Default|Result|String|FnOnce|Extend|Option|FnMut|Unpin|Sized|AsRef|AsMut|Clone|None|From|Into|Sync|drop|Send|Drop|Copy|Some|Ord|Err|Box|Vec|Eq|Ok|Fn)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(is_powerpc64_feature_detected|is_aarch64_feature_detected|is_powerpc_feature_detected|is_mips64_feature_detected|is_mips_feature_detected|is_x86_feature_detected|is_arm_feature_detected|debug_assert_ne|debug_assert_eq|format_args_nl|concat_idents|unimplemented|include_bytes|compile_error|debug_assert|thread_local|trace_macros|macro_rules|format_args|module_path|unreachable|include_str|option_env|global_asm|log_syntax|stringify|assert_ne|assert_eq|llvm_asm|eprintln|include|matches|println|writeln|format|column|assert|concat|eprint|write|panic|print|file|todo|line|env|dbg|vec|cfg|asm)!"> + <token type="NameFunctionMagic"/> + </rule> + <rule pattern="::\b"> + <token type="Text"/> + </rule> + <rule pattern="(?::|->)"> + <token type="Text"/> + <push state="typename"/> + </rule> + <rule pattern="(break|continue)(\b\s*)(\'[A-Za-z_]\w*)?"> + <bygroups> + <token type="Keyword"/> + <token type="TextWhitespace"/> + <token type="NameLabel"/> + </bygroups> + </rule> + <rule pattern="'(\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0|\\u\{[0-9a-fA-F]{1,6}\}|.)'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="b'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\0|\\u\{[0-9a-fA-F]{1,6}\}|.)'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="0b[01_]+"> + <token type="LiteralNumberBin"/> + <push state="number_lit"/> + </rule> + <rule pattern="0o[0-7_]+"> + <token type="LiteralNumberOct"/> + <push state="number_lit"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F_]+"> + <token type="LiteralNumberHex"/> + <push state="number_lit"/> + </rule> + <rule pattern="[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*(?!\.)|[eE][+\-]?[0-9_]+)"> + <token type="LiteralNumberFloat"/> + <push state="number_lit"/> + </rule> + <rule pattern="[0-9][0-9_]*"> + <token type="LiteralNumberInteger"/> + <push state="number_lit"/> + </rule> + <rule pattern="b""> + <token type="LiteralString"/> + <push state="bytestring"/> + </rule> + <rule pattern="(?s)b?r(#*)".*?"\1"> + <token type="LiteralString"/> + </rule> + <rule pattern="'"> + <token type="Operator"/> + <push state="lifetime"/> + </rule> + <rule pattern="\.\.=?"> + <token type="Operator"/> + </rule> + <rule pattern="[{}()\[\],.;]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[+\-*/%&|<>^!~@=:?]"> + <token type="Operator"/> + </rule> + <rule pattern="(r#)?[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="r#[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="#!?\["> + <token type="CommentPreproc"/> + <push state="attribute["/> + </rule> + <rule pattern="#"> + <token type="Text"/> + </rule> + </state> + <state name="typename"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="&"> + <token type="KeywordPseudo"/> + </rule> + <rule pattern="'"> + <token type="Operator"/> + <push state="lifetime"/> + </rule> + <rule pattern="(DoubleEndedIterator|ExactSizeIterator|IntoIterator|PartialOrd|PartialEq|ToString|Iterator|ToOwned|Default|Result|String|FnOnce|Extend|Option|FnMut|Unpin|Sized|AsRef|AsMut|Clone|None|From|Into|Sync|drop|Send|Drop|Copy|Some|Ord|Err|Box|Vec|Eq|Ok|Fn)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(isize|usize|bool|char|u128|i128|i64|i32|i16|str|u64|u32|f32|f64|u16|i8|u8)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sas.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sas.xml new file mode 100644 index 0000000..af1107b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sas.xml @@ -0,0 +1,191 @@ +<lexer> + <config> + <name>SAS</name> + <alias>sas</alias> + <filename>*.SAS</filename> + <filename>*.sas</filename> + <mime_type>text/x-sas</mime_type> + <mime_type>text/sas</mime_type> + <mime_type>application/x-sas</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="validvar"> + <rule pattern="[a-z_]\w{0,31}\.?"> + <token type="NameVariable"/> + <pop depth="1"/> + </rule> + </state> + <state name="cards-datalines"> + <rule pattern="^\s*(datalines|cards)\s*;\s*$"> + <token type="Keyword"/> + <push state="data"/> + </rule> + </state> + <state name="proc-data"> + <rule pattern="(^|;)\s*(proc \w+|data|run|quit)[\s;]"> + <token type="KeywordReserved"/> + </rule> + </state> + <state name="string_dquote"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\"|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="&"> + <token type="NameVariable"/> + <push state="validvar"/> + </rule> + <rule pattern="[^$&"\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="[$"\\]"> + <token type="LiteralString"/> + </rule> + </state> + <state name="general"> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="vars-strings"/> + </rule> + <rule> + <include state="special"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + </state> + <state name="vars-strings"> + <rule pattern="&[a-z_]\w{0,31}\.?"> + <token type="NameVariable"/> + </rule> + <rule pattern="%[a-z_]\w{0,31}"> + <token type="NameFunction"/> + </rule> + <rule pattern="\'"> + <token type="LiteralString"/> + <push state="string_squote"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string_dquote"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="comments"/> + </rule> + <rule> + <include state="proc-data"/> + </rule> + <rule> + <include state="cards-datalines"/> + </rule> + <rule> + <include state="logs"/> + </rule> + <rule> + <include state="general"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + </state> + <state name="data"> + <rule pattern="(.|\n)*^\s*;\s*$"> + <token type="Other"/> + <pop depth="1"/> + </rule> + </state> + <state name="logs"> + <rule pattern="\n?^\s*%?put "> + <token type="Keyword"/> + <push state="log-messages"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="\b(datalines4|datalines|delimiter|startsas|redirect|lostcard|continue|informat|filename|footnote|catname|options|libname|systask|display|waitsas|missing|replace|delete|window|endsas|update|format|attrib|length|infile|select|return|retain|rename|remove|output|cards4|modify|leave|title|merge|delim|input|cards|abort|where|label|array|error|call|page|stop|keep|file|drop|link|skip|list|goto|put|out|set|by|dm|in|x)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(references|distinct|describe|validate|restrict|cascade|msgtype|message|primary|foreign|delete|update|create|unique|having|modify|insert|select|group|check|table|alter|order|reset|index|where|into|from|view|null|like|drop|add|not|key|and|set|on|in|or|as)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(while|until|then|else|end|if|do)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="%(sysevalf|nrbquote|qsysfunc|qlowcase|compstor|nrquote|display|qupcase|datatyp|qcmpres|unquote|syscall|sysfunc|sysrput|sysprod|syslput|sysexec|lowcase|qsubstr|sysget|length|keydef|global|superq|substr|verify|bquote|cmpres|upcase|window|label|qleft|while|qtrim|quote|nrstr|until|sysrc|input|macro|local|qscan|index|else|scan|mend|eval|trim|then|goto|left|put|let|end|str|do|to|if)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\b(vinformatnx|vinformatwx|vinformatdx|vinformatw|vinformatd|vinformatx|vinformatn|vinformat|translate|vinarrayx|vformatwx|vformatnx|vformatdx|getoption|fileexist|fetchobs|vlengthx|filename|fipstate|kurtosis|vinarray|vformatx|pathname|foptname|compound|compress|vformatw|hosthelp|vformatn|zipnamel|vformatd|probbeta|daccdbsl|zipstate|trigamma|probbnml|probhypr|probnegb|probnorm|datepart|datetime|varlabel|varinfmt|dropnote|skewness|doptname|timepart|fipnamel|dequote|tranwrd|sysprod|digamma|stnamel|soundex|depdbsl|reverse|daccsyd|doptnum|resolve|uniform|datejul|varname|varrayx|probgam|probchi|fappend|dacctab|vformat|poisson|collate|brshift|ordinal|fdelete|blshift|betainv|fileref|lowcase|libname|fipname|vlabelx|vlength|weekday|juldate|jbessel|ibessel|zipfips|foptnum|zipname|getvarn|getvarc|frewind|vartype|depsyd|stderr|stfips|fwrite|gaminv|second|substr|vtypex|symget|hbound|vnamex|fpoint|saving|fnonct|rewind|indexc|indexw|repeat|inputc|inputn|ranuni|stname|rantbl|ranpoi|rannor|sysget|rangam|ranexp|vlabel|lbound|cexist|length|lgamma|rancau|libref|cnonct|ranbin|compbl|logpdf|logpmf|logsdf|sysmsg|curobs|daccdb|verify|daccsl|minute|system|tnonct|dsname|varray|varnum|probit|spedis|normal|varlen|dclose|varfmt|fexist|deptab|upcase|rantri|fclose|nmiss|point|trimn|depsl|trunc|peekc|depdb|probf|exist|fetch|netpv|today|mopen|probt|month|dairy|sysrc|finfo|quote|log10|close|floor|dinfo|range|fnote|attrn|intrr|intnx|intck|attrc|input|dread|dopen|index|right|round|vname|vtype|fread|gamma|arsin|arcos|fopen|frlen|fget|sinh|sqrt|addr|airy|sign|fsep|year|fuzz|dnum|scan|rank|fput|fpos|putn|putc|hour|tanh|atan|dhms|tinv|band|bnot|erfc|fcol|poke|trim|byte|ceil|peek|left|cinv|finv|open|log2|mean|note|date|cosh|mort|time|bxor|bor|mdy|std|max|css|sin|cos|npv|log|var|uss|pdf|pmf|cdf|abs|hms|day|erf|put|lag|irr|int|sum|tan|min|dif|qtr|sdf|dim|yyq|exp|mod|cv|n)\("> + <token type="NameBuiltin"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="\b[+-]?([0-9]+(\.[0-9]+)?|\.[0-9]+|\.)(E[+-]?[0-9]+)?i?\b"> + <token type="LiteralNumber"/> + </rule> + </state> + <state name="special"> + <rule pattern="(null|missing|_all_|_automatic_|_character_|_n_|_infile_|_name_|_null_|_numeric_|_user_|_webout_)"> + <token type="KeywordConstant"/> + </rule> + </state> + <state name="log-messages"> + <rule pattern="NOTE(:|-).*"> + <token type="Generic"/> + <pop depth="1"/> + </rule> + <rule pattern="WARNING(:|-).*"> + <token type="GenericEmph"/> + <pop depth="1"/> + </rule> + <rule pattern="ERROR(:|-).*"> + <token type="GenericError"/> + <pop depth="1"/> + </rule> + <rule> + <include state="general"/> + </rule> + </state> + <state name="comments"> + <rule pattern="^\s*\*.*?;"> + <token type="Comment"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="Comment"/> + </rule> + <rule pattern="^\s*\*(.|\n)*?;"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="/[*](.|\n)*?[*]/"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="string_squote"> + <rule pattern="'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\|\\"|\\\n"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^$\'\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="[$\'\\]"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sass.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sass.xml new file mode 100644 index 0000000..f801594 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sass.xml @@ -0,0 +1,362 @@ +<lexer> + <config> + <name>Sass</name> + <alias>sass</alias> + <filename>*.sass</filename> + <mime_type>text/x-sass</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="import"> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern="\S+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <push state="root"/> + </rule> + </state> + <state name="string-single"> + <rule pattern="(\\.|#(?=[^\n{])|[^\n'#])+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + </state> + <state name="string-double"> + <rule pattern="(\\.|#(?=[^\n{])|[^\n"#])+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + <state name="pseudo-class"> + <rule pattern="[\w-]+"> + <token type="NameDecorator"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="for"> + <rule pattern="(from|to|through)"> + <token type="OperatorWord"/> + </rule> + <rule> + <include state="value"/> + </rule> + </state> + <state name="selector"> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern="\:"> + <token type="NameDecorator"/> + <push state="pseudo-class"/> + </rule> + <rule pattern="\."> + <token type="NameClass"/> + <push state="class"/> + </rule> + <rule pattern="\#"> + <token type="NameNamespace"/> + <push state="id"/> + </rule> + <rule pattern="[\w-]+"> + <token type="NameTag"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="&"> + <token type="Keyword"/> + </rule> + <rule pattern="[~^*!&\[\]()<>|+=@:;,./?-]"> + <token type="Operator"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string-double"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <push state="string-single"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <push state="root"/> + </rule> + </state> + <state name="value"> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern="[!$][\w-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="url\("> + <token type="LiteralStringOther"/> + <push state="string-url"/> + </rule> + <rule pattern="[a-z_-][\w-]*(?=\()"> + <token type="NameFunction"/> + </rule> + <rule pattern="(color-interpolation-filters|glyph-orientation-vertical|transition-timing-function|border-bottom-right-radius|border-bottom-left-radius|animation-iteration-count|animation-timing-function|font-variant-alternates|font-variant-east-asian|text-underline-position|border-top-right-radius|scroll-snap-destination|scroll-snap-coordinate|font-language-override|text-emphasis-position|font-variant-ligatures|border-top-left-radius|background-blend-mode|background-attachment|text-decoration-color|text-decoration-style|font-feature-settings|grid-template-columns|shape-image-threshold|hyphenate-limit-lines|hyphenate-limit-chars|font-variant-position|hyphenate-limit-last|scroll-snap-points-x|initial-letter-align|decimal-leading-zero|box-decoration-break|hyphenate-limit-zone|text-combine-upright|text-decoration-skip|font-variant-numeric|scroll-snap-points-y|animation-play-state|text-decoration-line|hyphenate-character|transition-duration|text-emphasis-style|border-bottom-width|border-image-repeat|grid-template-areas|border-image-source|animation-direction|initial-letter-wrap|list-style-position|transition-property|text-space-collapse|border-bottom-style|hanging-punctuation|text-emphasis-color|border-image-outset|background-position|animation-fill-mode|backface-visibility|border-bottom-color|border-right-width|alignment-baseline|mask-border-outset|border-right-style|border-right-color|mask-border-repeat|table-header-group|grid-template-rows|animation-duration|perspective-origin|presentation-level|table-footer-group|mask-border-source|border-image-width|border-image-slice|table-column-group|counter-increment|dominant-baseline|column-rule-width|speak-punctuation|page-break-before|image-orientation|font-variant-caps|grid-auto-columns|page-break-inside|border-left-width|marquee-direction|border-left-style|border-left-color|grid-column-start|mask-border-width|column-rule-color|column-rule-style|background-repeat|background-origin|mask-border-slice|scroll-snap-type|border-top-style|border-top-width|background-image|page-break-after|transform-origin|border-top-color|text-orientation|background-color|transition-delay|footnote-display|list-style-image|mask-border-mode|font-size-adjust|image-resolution|footnote-policy|object-position|ultra-condensed|motion-rotation|cjk-ideographic|justify-content|animation-delay|region-fragment|table-row-group|caret-animation|text-align-last|float-reference|extra-condensed|transform-style|text-decoration|grid-column-gap|border-collapse|background-clip|border-boundary|text-space-trim|grid-column-end|list-style-type|background-size|font-synthesis|padding-bottom|outline-offset|initial-letter|animation-name|hiragana-iroha|katakana-iroha|no-close-quote|border-spacing|rotation-point|flex-direction|voice-duration|grid-row-start|vertical-align|extra-expanded|polar-distance|baseline-shift|letter-spacing|grid-auto-flow|grid-auto-rows|lighting-color|bookmark-label|text-transform|semi-condensed|bookmark-level|mask-composite|bookmark-state|ultra-expanded|mix-blend-mode|overflow-style|grid-template|border-bottom|small-caption|semi-expanded|mask-position|no-open-quote|motion-offset|border-radius|offset-before|outline-color|outline-style|table-caption|outline-width|overflow-wrap|padding-right|flood-opacity|voice-balance|ruby-position|justify-items|bidi-override|marquee-style|shape-outside|speak-numeral|marquee-speed|counter-reset|margin-bottom|text-overflow|text-emphasis|align-content|break-before|border-width|border-image|shape-margin|speak-header|margin-right|inline-table|table-layout|center-right|marquee-loop|border-color|line-through|box-suppress|shape-inside|justify-self|float-offset|pause-before|table-column|grid-row-gap|grid-row-end|padding-left|text-justify|column-count|wrap-through|font-kerning|font-stretch|border-right|border-style|word-spacing|offset-start|caption-side|voice-volume|voice-stress|font-variant|text-spacing|offset-after|voice-family|unicode-bidi|break-inside|writing-mode|column-width|break-after|user-select|align-items|motion-path|font-weight|grid-column|voice-range|white-space|will-change|wrap-before|transparent|caret-color|text-bottom|caret-shape|mask-repeat|wrap-inside|upper-latin|text-shadow|mask-origin|font-family|flex-shrink|column-fill|message-box|text-indent|lower-roman|column-rule|padding-top|column-span|play-during|upper-roman|flood-color|page-policy|border-left|pause-after|lower-greek|perspective|lower-alpha|counter-set|mask-border|center-left|polar-angle|float-defer|marker-side|speech-rate|upper-alpha|line-height|pitch-range|empty-cells|close-quote|rest-before|margin-left|voice-pitch|overflow-y|small-caps|ruby-align|ruby-merge|wrap-after|box-shadow|word-break|flex-basis|max-height|rest-after|mask-image|list-style|min-height|voice-rate|visibility|sans-serif|object-fit|continuous|status-bar|offset-end|align-self|box-sizing|right-side|string-set|transition|margin-top|text-align|cue-before|border-top|font-style|line-break|background|capitalize|table-cell|open-quote|appearance|overflow-x|column-gap|rightwards|table-row|animation|flow-into|landscape|left-side|clip-rule|font-size|clip-path|flow-from|text-wrap|nw-resize|transform|no-repeat|line-grid|condensed|sw-resize|leftwards|line-snap|direction|crosshair|nav-right|list-item|se-resize|isolation|underline|grid-area|uppercase|min-width|flex-wrap|spell-out|max-width|ne-resize|max-lines|mask-clip|elevation|far-right|flex-flow|mask-type|word-wrap|flex-grow|mask-size|wrap-flow|monospace|mask-mode|cue-after|lowercase|relative|absolute|grid-row|armenian|e-resize|narrower|expanded|baseline|nav-down|nav-left|w-resize|xx-large|text-top|overline|overflow|katakana|n-resize|repeat-x|repeat-y|rotation|position|box-snap|xx-small|collapse|tab-size|speak-as|hiragana|s-resize|portrait|georgian|richness|separate|grid-gap|far-left|inherit|columns|content|oblique|default|outside|display|x-small|decimal|fantasy|z-index|running|azimuth|x-large|lighter|cursive|padding|outline|orphans|opacity|pointer|move-to|visible|hyphens|justify|smaller|nav-up|circle|inline|motion|inside|invert|italic|height|center|higher|x-fast|larger|hidden|digits|hebrew|groove|x-high|faster|quotes|static|behind|square|resize|border|slower|silent|dashed|medium|always|middle|filter|x-loud|bottom|widows|volume|scroll|chains|x-soft|stress|normal|nowrap|repeat|double|dotted|margin|outset|cursor|bolder|avoid|embed|x-low|above|fixed|wider|cross|inset|ridge|large|clear|speak|order|caret|width|thick|block|level|serif|blink|lower|pause|pitch|right|aural|super|below|solid|color|float|hide|soft|rest|grid|auto|slow|flow|show|page|disc|left|clip|text|flex|bold|loud|thin|size|none|help|both|once|icon|crop|fast|crop|high|mask|wait|font|all|url|top|rgb|mix|yes|low|ltr|cue|px)\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="(lightgoldenrodyellow|mediumspringgreen|mediumaquamarine|mediumslateblue|mediumturquoise|mediumvioletred|lightsteelblue|cornflowerblue|lightslategray|blanchedalmond|mediumseagreen|lightslategrey|darkolivegreen|darkgoldenrod|darkslateblue|lightseagreen|rebeccapurple|darkslategrey|darkslategray|palegoldenrod|paleturquoise|palevioletred|darkturquoise|lavenderblush|antiquewhite|mediumorchid|lightskyblue|mediumpurple|midnightblue|darkseagreen|lemonchiffon|springgreen|yellowgreen|greenyellow|navajowhite|darkmagenta|lightyellow|transparent|lightsalmon|forestgreen|saddlebrown|deepskyblue|floralwhite|dodgerblue|ghostwhite|lightcoral|sandybrown|darkviolet|papayawhip|mediumblue|chartreuse|lightgreen|whitesmoke|aquamarine|darkorange|darksalmon|powderblue|darkorchid|blueviolet|indianred|mintcream|mistyrose|olivedrab|goldenrod|orangered|lawngreen|gainsboro|lightblue|firebrick|lightcyan|peachpuff|lightgray|darkkhaki|lightgrey|darkgreen|rosybrown|royalblue|slateblue|chocolate|cadetblue|burlywood|slategray|slategrey|limegreen|steelblue|turquoise|palegreen|lightpink|aliceblue|moccasin|darkgrey|darkblue|seagreen|lavender|cornsilk|deeppink|seashell|darkgray|honeydew|darkcyan|dimgrey|magenta|crimson|darkred|hotpink|skyblue|oldlace|dimgray|fuchsia|thistle|orchid|indigo|orange|tomato|violet|salmon|yellow|silver|purple|bisque|sienna|maroon|black|linen|azure|white|wheat|khaki|green|olive|ivory|coral|brown|beige|snow|blue|navy|aqua|teal|gray|gold|grey|lime|peru|cyan|pink|plum|tan|red)\b"> + <token type="NameEntity"/> + </rule> + <rule pattern="(fuchsia|purple|yellow|maroon|silver|white|olive|green|black|lime|gray|navy|blue|teal|aqua|red)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\!(important|default)"> + <token type="NameException"/> + </rule> + <rule pattern="(true|false)"> + <token type="NamePseudo"/> + </rule> + <rule pattern="(and|or|not)"> + <token type="OperatorWord"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="inline-comment"/> + </rule> + <rule pattern="//[^\n]*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\#[a-z0-9]{1,6}"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(-?\d+)(\%|[a-z]+)?"> + <bygroups> + <token type="LiteralNumberInteger"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="(-?\d*\.\d+)(\%|[a-z]+)?"> + <bygroups> + <token type="LiteralNumberFloat"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="[~^*!&%<>|+=@:,./?-]+"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\]()]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string-double"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <push state="string-single"/> + </rule> + <rule pattern="[a-z_-][\w-]*"> + <token type="Name"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <push state="root"/> + </rule> + </state> + <state name="id"> + <rule pattern="[\w-]+"> + <token type="NameNamespace"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="multi-comment"> + <rule pattern=".+"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <push state="root"/> + </rule> + </state> + <state name="interpolation"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="value"/> + </rule> + </state> + <state name="string-url"> + <rule pattern="(\\#|#(?=[^\n{])|[^\n#)])+"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="\)"> + <token type="LiteralStringOther"/> + <pop depth="1"/> + </rule> + </state> + <state name="inline-comment"> + <rule pattern="(\\#|#(?=[^\n{])|\*(?=[^\n/])|[^\n#*])+"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="\*/"> + <token type="Comment"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="[ \t]*\n"> + <token type="Text"/> + </rule> + <rule pattern="@import"> + <token type="Keyword"/> + <push state="import"/> + </rule> + <rule pattern="@for"> + <token type="Keyword"/> + <push state="for"/> + </rule> + <rule pattern="@(debug|warn|if|while)"> + <token type="Keyword"/> + <push state="value"/> + </rule> + <rule pattern="(@mixin)( [\w-]+)"> + <bygroups> + <token type="Keyword"/> + <token type="NameFunction"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="(@include)( [\w-]+)"> + <bygroups> + <token type="Keyword"/> + <token type="NameDecorator"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="@extend"> + <token type="Keyword"/> + <push state="selector"/> + </rule> + <rule pattern="@[\w-]+"> + <token type="Keyword"/> + <push state="selector"/> + </rule> + <rule pattern="=[\w-]+"> + <token type="NameFunction"/> + <push state="value"/> + </rule> + <rule pattern="\+[\w-]+"> + <token type="NameDecorator"/> + <push state="value"/> + </rule> + <rule pattern="([!$][\w-]\w*)([ \t]*(?:(?:\|\|)?=|:))"> + <bygroups> + <token type="NameVariable"/> + <token type="Operator"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern=":"> + <token type="NameAttribute"/> + <push state="old-style-attr"/> + </rule> + <rule pattern="(?=.+?[=:]([^a-z]|$))"> + <token type="NameAttribute"/> + <push state="new-style-attr"/> + </rule> + <rule> + <push state="selector"/> + </rule> + </state> + <state name="single-comment"> + <rule pattern=".+"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <push state="root"/> + </rule> + </state> + <state name="new-style-attr"> + <rule pattern="[^\s:="\[]+"> + <token type="NameAttribute"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="[ \t]*[=:]"> + <token type="Operator"/> + <push state="value"/> + </rule> + </state> + <state name="class"> + <rule pattern="[\w-]+"> + <token type="NameClass"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="old-style-attr"> + <rule pattern="[^\s:="\[]+"> + <token type="NameAttribute"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="[ \t]*="> + <token type="Operator"/> + <push state="value"/> + </rule> + <rule> + <push state="value"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scala.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scala.xml new file mode 100644 index 0000000..2f8ddd4 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scala.xml @@ -0,0 +1,274 @@ +<lexer> + <config> + <name>Scala</name> + <alias>scala</alias> + <filename>*.scala</filename> + <mime_type>text/x-scala</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="import"> + <rule pattern="([\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|\.)+"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + </state> + <state name="interpstringcommon"> + <rule pattern="[^"$\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\$\$"> + <token type="LiteralString"/> + </rule> + <rule pattern="\$[\\$_\p{L}](?:[\\$_\p{L}]|\d)*"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="interpbrace"/> + </rule> + <rule pattern="\\."> + <token type="LiteralString"/> + </rule> + </state> + <state name="interptriplestring"> + <rule pattern=""""(?!")"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + </rule> + <rule> + <include state="interpstringcommon"/> + </rule> + </state> + <state name="root"> + <rule pattern="(class|trait|object)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="class"/> + </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="@[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?"> + <token type="NameDecorator"/> + </rule> + <rule pattern="(abstract|ca(?:se|tch)|d(?:ef|o)|e(?:lse|xtends)|f(?:inal(?:ly)?|or(?:Some)?)|i(?:f|mplicit)|lazy|match|new|override|pr(?:ivate|otected)|re(?:quires|turn)|s(?:ealed|uper)|t(?:h(?:is|row)|ry)|va[lr]|w(?:hile|ith)|yield)\b|(<[%:-]|=>|>:|[#=@_⇒←])(\b|(?=\s)|$)"> + <token type="Keyword"/> + </rule> + <rule pattern=":(?![-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+%s)"> + <token type="Keyword"/> + <push state="type"/> + </rule> + <rule pattern="[\\$_\p{Lu}][\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?\b"> + <token type="NameClass"/> + </rule> + <rule pattern="(true|false|null)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(import|package)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="import"/> + </rule> + <rule pattern="(type)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="type"/> + </rule> + <rule pattern="""".*?"""(?!")"> + <token type="LiteralString"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="'[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?"> + <token type="TextSymbol"/> + </rule> + <rule pattern="[fs]""""> + <token type="LiteralString"/> + <push state="interptriplestring"/> + </rule> + <rule pattern="[fs]""> + <token type="LiteralString"/> + <push state="interpstring"/> + </rule> + <rule pattern="raw"(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?"> + <token type="Name"/> + </rule> + <rule pattern="`[^`]+`"> + <token type="Name"/> + </rule> + <rule pattern="\["> + <token type="Operator"/> + <push state="typeparam"/> + </rule> + <rule pattern="[(){};,.#]"> + <token type="Operator"/> + </rule> + <rule pattern="[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+"> + <token type="Operator"/> + </rule> + <rule pattern="([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0x[0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9]+L?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + </state> + <state name="type"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="<[%:]|>:|[#_]|forSome|type"> + <token type="Keyword"/> + </rule> + <rule pattern="([,);}]|=>|=|⇒)(\s*)"> + <bygroups> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="[({]"> + <token type="Operator"/> + <push/> + </rule> + <rule pattern="((?:[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`)(?:\.(?:[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`))*)(\s*)(\[)"> + <bygroups> + <token type="KeywordType"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + <push state="#pop" state="typeparam"/> + </rule> + <rule pattern="((?:[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`)(?:\.(?:[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`))*)(\s*)$"> + <bygroups> + <token type="KeywordType"/> + <token type="Text"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\.|[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`"> + <token type="KeywordType"/> + </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="interpstring"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <include state="interpstringcommon"/> + </rule> + </state> + <state name="interpbrace"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule pattern="\{"> + <token type="LiteralStringInterpol"/> + <push/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="class"> + <rule pattern="([\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`)(\s*)(\[)"> + <bygroups> + <token type="NameClass"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + <push state="typeparam"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\{"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule pattern="\("> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="typeparam"> + <rule pattern="[\s,]+"> + <token type="Text"/> + </rule> + <rule pattern="<[%:]|=>|>:|[#_⇒]|forSome|type"> + <token type="Keyword"/> + </rule> + <rule pattern="([\])}])"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule pattern="[(\[{]"> + <token type="Operator"/> + <push/> + </rule> + <rule pattern="\.|[\\$_\p{L}](?:[\\$_\p{L}]|[0-9])*(?:(?<=_)[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+)?|[-~\^\*!%&\\<>\|+=:/?@�-�����-����϶҂؆-؈؎-؏۩۽-۾߶৺୰௳-௸௺౿ೱ-ೲ൹༁-༃༓-༗༚-༟༴༶༸྾-࿅࿇-࿏႞-႟፠᎐-᎙᥀᧠-᧿᭡-᭪᭴-᭼⁄⁒⁺-⁼₊-₌℀-℁℃-℆℈-℉℔№-℘℞-℣℥℧℩℮℺-℻⅀-⅄⅊-⅍⅏←-⌨⌫-⑊⒜-ⓩ─-❧➔-⟄⟇-⟥⟰-⦂⦙-⧗⧜-⧻⧾-⭔⳥-⳪⺀-⿻〄〒-〓〠〶-〷〾-〿㆐-㆑㆖-㆟㇀-㇣㈀-㈞㈪-㉐㉠-㉿㊊-㊰㋀-㏿䷀-䷿꒐-꓆꠨-꠫﬩﷽﹢﹤-﹦＋＜-＞｜～￢￤￨-￮-�]+|`[^`]+`"> + <token type="KeywordType"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scheme.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scheme.xml new file mode 100644 index 0000000..0198bd7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scheme.xml @@ -0,0 +1,106 @@ +<lexer> + <config> + <name>Scheme</name> + <alias>scheme</alias> + <alias>scm</alias> + <filename>*.scm</filename> + <filename>*.ss</filename> + <mime_type>text/x-scheme</mime_type> + <mime_type>application/x-scheme</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern=";.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="#\|"> + <token type="CommentMultiline"/> + <push state="multiline-comment"/> + </rule> + <rule pattern="#;\s*\("> + <token type="Comment"/> + <push state="commented-form"/> + </rule> + <rule pattern="#!r6rs"> + <token type="Comment"/> + </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=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'[\w!$%&*+,/:<=>?@^~|-]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="#\\(alarm|backspace|delete|esc|linefeed|newline|page|return|space|tab|vtab|x[0-9a-zA-Z]{1,5}|.)"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="(#t|#f)"> + <token type="NameConstant"/> + </rule> + <rule pattern="('|#|`|,@|,|\.)"> + <token type="Operator"/> + </rule> + <rule pattern="(lambda |define |if |else |cond |and |or |case |let |let\* |letrec |begin |do |delay |set\! |\=\> |quote |quasiquote |unquote |unquote\-splicing |define\-syntax |let\-syntax |letrec\-syntax |syntax\-rules )"> + <token type="Keyword"/> + </rule> + <rule pattern="(?<='\()[\w!$%&*+,/:<=>?@^~|-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(?<=#\()[\w!$%&*+,/:<=>?@^~|-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(?<=\()(\* |\+ |\- |\/ |\< |\<\= |\= |\> |\>\= |abs |acos |angle |append |apply |asin |assoc |assq |assv |atan |boolean\? |caaaar |caaadr |caaar |caadar |caaddr |caadr |caar |cadaar |cadadr |cadar |caddar |cadddr |caddr |cadr |call\-with\-current\-continuation |call\-with\-input\-file |call\-with\-output\-file |call\-with\-values |call\/cc |car |cdaaar |cdaadr |cdaar |cdadar |cdaddr |cdadr |cdar |cddaar |cddadr |cddar |cdddar |cddddr |cdddr |cddr |cdr |ceiling |char\-\>integer |char\-alphabetic\? |char\-ci\<\=\? |char\-ci\<\? |char\-ci\=\? |char\-ci\>\=\? |char\-ci\>\? |char\-downcase |char\-lower\-case\? |char\-numeric\? |char\-ready\? |char\-upcase |char\-upper\-case\? |char\-whitespace\? |char\<\=\? |char\<\? |char\=\? |char\>\=\? |char\>\? |char\? |close\-input\-port |close\-output\-port |complex\? |cons |cos |current\-input\-port |current\-output\-port |denominator |display |dynamic\-wind |eof\-object\? |eq\? |equal\? |eqv\? |eval |even\? |exact\-\>inexact |exact\? |exp |expt |floor |for\-each |force |gcd |imag\-part |inexact\-\>exact |inexact\? |input\-port\? |integer\-\>char |integer\? |interaction\-environment |lcm |length |list |list\-\>string |list\-\>vector |list\-ref |list\-tail |list\? |load |log |magnitude |make\-polar |make\-rectangular |make\-string |make\-vector |map |max |member |memq |memv |min |modulo |negative\? |newline |not |null\-environment |null\? |number\-\>string |number\? |numerator |odd\? |open\-input\-file |open\-output\-file |output\-port\? |pair\? |peek\-char |port\? |positive\? |procedure\? |quotient |rational\? |rationalize |read |read\-char |real\-part |real\? |remainder |reverse |round |scheme\-report\-environment |set\-car\! |set\-cdr\! |sin |sqrt |string |string\-\>list |string\-\>number |string\-\>symbol |string\-append |string\-ci\<\=\? |string\-ci\<\? |string\-ci\=\? |string\-ci\>\=\? |string\-ci\>\? |string\-copy |string\-fill\! |string\-length |string\-ref |string\-set\! |string\<\=\? |string\<\? |string\=\? |string\>\=\? |string\>\? |string\? |substring |symbol\-\>string |symbol\? |tan |transcript\-off |transcript\-on |truncate |values |vector |vector\-\>list |vector\-fill\! |vector\-length |vector\-ref |vector\-set\! |vector\? |with\-input\-from\-file |with\-output\-to\-file |write |write\-char |zero\? )"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?<=\()[\w!$%&*+,/:<=>?@^~|-]+"> + <token type="NameFunction"/> + </rule> + <rule pattern="[\w!$%&*+,/:<=>?@^~|-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(\(|\))"> + <token type="Punctuation"/> + </rule> + <rule pattern="(\[|\])"> + <token type="Punctuation"/> + </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="Comment"/> + <push/> + </rule> + <rule pattern="\)"> + <token type="Comment"/> + <pop depth="1"/> + </rule> + <rule pattern="[^()]+"> + <token type="Comment"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scilab.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scilab.xml new file mode 100644 index 0000000..9e10949 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scilab.xml @@ -0,0 +1,98 @@ +<lexer> + <config> + <name>Scilab</name> + <alias>scilab</alias> + <filename>*.sci</filename> + <filename>*.sce</filename> + <filename>*.tst</filename> + <mime_type>text/scilab</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="//.*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="^\s*function"> + <token type="Keyword"/> + <push state="deffunc"/> + </rule> + <rule pattern="(unwind_protect_cleanup|end_unwind_protect|unwind_protect|end_try_catch|endproperties|endclassdef|endfunction|persistent|properties|endmethods|otherwise|endevents|endswitch|__FILE__|continue|classdef|__LINE__|endwhile|function|methods|elseif|return|static|events|global|endfor|switch|until|endif|while|catch|break|case|else|set|end|try|for|get|do|if)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(gencompilationflags_unix|neldermead_defaultoutput|optimbase_isinnonlincons|tbx_builder_gateway_lang|optimbase_hasconstraints|getinstalledlookandfeels|tbx_build_gateway_loader|xcosValidateCompareBlock|assert_checkalmostequal|optimsimplex_deltafvmax|optimsimplex_gradientfv|tbx_build_gateway_clean|add_module_help_chapter|optimsimplex_fvvariance|optimsimplex_compsomefv|del_module_help_chapter|saveconsecutivecommands|removeModulePreferences|xcosPalGenerateAllIcons|get_absolute_file_path|%Block_xcosUpdateBlock|optimbase_checkcostfun|nyquistfrequencybounds|with_modelica_compiler|optimsimplex_computefv|assert_checkfilesequal|tbx_build_localization|formatSgridDampingTip|block_parameter_error|xcosConfigureModelica|formatNicholsPhaseTip|addlocalizationdomain|optimbase_checkbounds|scicos_workspace_init|formatZgridDampingTip|neldermead_updatesimp|optimbase_logshutdown|optimsimplex_setallfv|xcosSimulationStarted|datatipSetOrientation|extract_help_examples|tbx_builder_help_lang|arobasestring2strings|initial_scicos_tables|optimsimplex_getallfv|fire_closing_finished|atomsGetInstalledPath|tbx_build_help_loader|assert_cond2reqdigits|nmplot_simplexhistory|assert_comparecomplex|optimsimplex_setnbve|assert_computedigits|optimsimplex_getallx|optimsimplex_fvstdev|optimsimplex_deltafv|optimsimplex_setallx|xcosConfigureXmlFile|optimbase_isfeasible|parallel_concurrency|output_nsga2_default|addModulePreferences|xcosValidateBlockSet|compute_initial_temp|crossover_ga_default|optimsimplex_destroy|optimsimplex_reflect|devtools_run_builder|selection_ga_elitist|xcosShowBlockWarning|optimbase_isinbounds|formatNicholsGainTip|jallowClassReloading|detectmsifort64tools|demo_function_choice|optimbase_logstartup|optimsimplex_getnbve|%H5Object_fieldnames|tbx_builder_src_lang|neldermead_configure|createXConfiguration|tbx_build_pal_loader|optimsimplex_dirmat|optimsimplex_fvmean|output_nsga_default|crossover_ga_binary|getPreferencesValue|formatHallModuleTip|getrelativefilename|output_moga_default|optimbase_configure|atomsRepositoryList|xcosPalGenerateIcon|accept_func_default|xcosDiagramToScilab|optimbase_hasbounds|find_scicos_version|fftwlibraryisloaded|optimsimplex_setall|optimbase_hasnlcons|optimbase_outstruct|mutation_ga_default|optimsimplex_shrink|neldermead_function|tbx_generate_pofile|setPreferencesValue|selection_ga_random|matfile_varreadnext|importScicosDiagram|tbx_builder_gateway|optimsimplex_center|optimsimplex_getall|optimbase_terminate|optimbase_proj2bnds|optimbase_outputcmd|findmsifortcompiler|generateBlockImages|getvariablesonstack|getdefaultlanguage|formatBodePhaseTip|nmplot_historyplot|formatHallPhaseTip|formatPhaseplotTip|coding_ga_identity|xcosCodeGeneration|formatSgridFreqTip|xcosBlockInterface|formatZgridFreqTip|generateBlockImage|saveafterncommands|optimsimplex_setve|scicos_debug_count|setdefaultlanguage|neldermead_restart|get_scicos_version|atomsGetLoadedPath|with_macros_source|atomsRestoreConfig|optimbase_function|assert_cond2reltol|datatipManagerMode|optimsimplex_setfv|optimsimplex_getfv|atomsRepositoryDel|xcosPalCategoryAdd|system_getproperty|system_setproperty|mutation_ga_binary|atomsRepositoryAdd|optimsimplex_check|ilib_gen_Make_unix|optimbase_incriter|%XMLList_i_XMLList|%XMLList_i_XMLElem|neldermead_destroy|%XMLElem_i_XMLList|%XMLElem_i_XMLElem|demo_folder_choice|tbx_builder_macros|optimplotfunccount|disposefftwlibrary|neigh_func_default|optimsimplex_getve|%XMLAttr_i_XMLElem|%hmS_k_hmS_generic|fftw_forget_wisdom|assert_checkequal|optimsimplex_getx|optimbase_stoplog|atomsGetInstalled|detectmsvc64tools|importXcosDiagram|%XMLDoc_i_XMLList|%XMLElem_i_XMLDoc|optimsimplex_setn|atomsAutoloadList|atomsSystemUpdate|optimsimplex_getn|number_properties|neldermead_search|ilib_include_flag|optimsimplex_setx|firstnonsingleton|getcallbackobject|x_choose_modeless|optimbase_histset|atomsCategoryList|optimbase_histget|recompilefunction|datatipSetDisplay|optimbase_destroy|check_modules_xml|pointer_xproperty|optimbase_checkx0|formatGainplotTip|csvStringToDouble|jconvMatrixMethod|optimsimplex_sort|getscilabkeywords|removelinehistory|optimsimplex_xbar|assert_checkfalse|output_ga_default|configure_msifort|assert_checkerror|get_function_path|iswaitingforinput|getDiagramVersion|tbx_build_gateway|tbx_build_cleaner|optimsimplex_size|tbx_build_blocks|getshortpathname|tbx_build_loader|convert_to_float|xmlSetAttributes|TCL_DeleteInterp|tbx_build_macros|matfile_varwrite|formatNyquistTip|coding_ga_binary|xmlIsValidObject|tbx_builder_help|xmlGetNsByPrefix|nmplot_outputcmd|assert_checktrue|del_help_chapter|atomsIsInstalled|atomsAutoloadAdd|import_from_hdf5|formatBodeMagTip|datatipSetInterp|xcosAddToolsMenu|atomsAutoloadDel|findmsvccompiler|%cblock_c_cblock|temp_law_default|phase_simulation|%XMLNs_i_XMLElem|ilib_gen_cleaner|nmplot_configure|ilib_gen_gateway|add_help_chapter|%cblock_f_cblock|accept_func_vfsa|demo_file_choice|atomsCheckModule|%TSIMPLEX_string|replace_Ix_by_Fx|%xlssheet_string|atomsDepTreeShow|optimsimplex_new|optimsimplex_log|instruction2code|is_absolute_path|remove_profiling|neldermead_costf|javalibrarypath|relocate_handle|tbx_builder_src|set_fftw_wisdom|updatebrowsevar|%XMLAttr_length|init_ga_default|getModelicaPath|atomsSystemInit|%TNMPLOT_string|TCL_CreateSlave|reset_profiling|importScicosPal|%_listvarinfile|graphicfunction|expression2code|scicos_getvalue|scicos_simulate|is_handle_valid|test_on_columns|matfile_listvar|neigh_func_vfsa|neldermead_cget|loadfftwlibrary|listvar_in_hdf5|ilib_gen_loader|%XMLList_length|nonreg_test_run|get_fftw_wisdom|atomsSaveConfig|%fptr_i_XMLList|datatipSetStyle|xcosUpdateBlock|nmplot_function|assert_generror|xcosPalAddBlock|TCL_ExistInterp|getlongpathname|%TNELDER_string|TCL_GetVersion|%_EObj_1__EObj|gethistoryfile|%_EObj_2__EObj|xcosPalDisable|nmplot_restart|TCL_ExistArray|getlookandfeel|%_EObj_3__EObj|jautoTranspose|nmplot_destroy|nmplot_contour|TCL_DoOneEvent|%_EObj_4__EObj|ilib_build_jar|%_EObj_k__EObj|linear_interpn|xmlGetNsByHref|%XMLSet_length|%spb_i_XMLList|neldermead_log|neldermead_get|%ptr_i_XMLList|ilib_mex_build|xcos_debug_gui|isequalbitwise|neigh_func_fsa|neigh_func_csa|xmlGetOpenDocs|atomsSetConfig|configure_msvc|optimbase_cget|%xlssheet_size|check_versions|%_EObj_a__EObj|%_EObj_z__EObj|DominationRank|historymanager|%_EObj_y__EObj|export_to_hdf5|translatepaths|atomsGetConfig|%_EObj_d__EObj|%TOPTIM_string|displayhistory|%_EObj_x__EObj|%_EObj_j__EObj|setlookandfeel|%_EObj_s__EObj|sethistoryfile|%lss_i_XMLList|!_deff_wrapper|test_run_level|%_EObj_r__EObj|warnBlockByUID|%_EObj_g__EObj|tbx_build_help|temp_law_huang|formatBlackTip|%_EObj_q__EObj|%msp_i_XMLList|%_EObj_p__EObj|atomsGetLoaded|returntoscilab|set_blockerror|progressionbar|%_EObj_o__EObj|%_EObj_h__EObj|sci_haltscicos|%_EObj_n__EObj|%_EObj_i__EObj|%_EObj_m__EObj|check_gateways|%_EObj_l__EObj|neldermead_new|%sp_i_XMLList|add_profiling|mtlb_fftshift|res_with_prec|tbx_build_src|mtlb_isletter|mtlb_legendre|mtlb_linspace|printsetupbox|temp_law_vfsa|set_xproperty|fixedpointgcd|enlarge_shape|mtlb_semilogx|mtlb_semilogy|mtlb_sortrows|get_file_path|browsehistory|mtlb_colordef|mtlb_toeplitz|unit_test_run|matfile_close|demo_viewCode|%plist_string|xcosBlockEval|haveacompiler|getblocklabel|demo_compiler|help_from_sci|help_skeleton|librarieslist|jgetclassname|xcosPalEnable|jdisableTrace|atomsAutoload|xcosPalExport|datatipCreate|nmplot_search|xcosPalDelete|datatipRemove|javaclasspath|listvarinfile|listfunctions|%ce_i_XMLList|datatipToggle|%hm_i_XMLList|taucs_chsolve|numderivative|ilib_for_link|ilib_gen_Make|definedfields|%XMLList_size|getscicosvars|%st_i_XMLList|getscilabmode|atomsIsLoaded|uiDisplayTree|optimbase_get|uicontextmenu|xcos_simulate|%ip_i_XMLList|optimbase_log|%XMLAttr_size|optimplotfval|resize_matrix|%grayplot_i_h|%mc_i_XMLList|%diagram_xcos|%champdat_i_h|optimbase_set|optimbase_new|head_comments|pareto_filter|TCL_UnsetVar|convertindex|%h_i_XMLList|jenableTrace|is_hdf5_file|jnewInstance|%c_i_XMLList|%c_i_XMLElem|jwrapinfloat|end_scicosim|remove_param|show_margins|%c_i_XMLAttr|%i_i_XMLList|%hm_iconvert|nicholschart|matfile_open|%b_i_XMLList|eval_cshep2d|ilib_verbose|mtlb_subplot|st_deviation|st_i_generic|xcos_compile|mtlb_strfind|mtlb_strcmpi|taucs_chinfo|ascii2string|mtlb_sprintf|taucs_chfact|mtlb_realmin|closeEditvar|mtlb_realmax|ilib_compile|%l_i_XMLList|%XMLSet_size|parallel_run|temp_law_csa|%p_i_XMLList|temp_law_fsa|%r_i_XMLList|%cblock_size|swap_handles|testexamples|%i_contour2d|loadXcosLibs|mtlb_num2str|mtlb_meshdom|ReadHBSparse|mtlb_logical|h5isCompound|cb_m2sci_gui|mtlb_isspace|mtlb_isfield|raise_window|%s_i_XMLList|realtimeinit|warnobsolete|fseek_origin|resethistory|bytecodewalk|atomsInstall|mtlb_fprintf|mtlb_findstr|generic_i_ce|generic_i_hm|with_javasci|scicos_debug|mtlb_choices|mtlb_cumprod|%spb_cumprod|createstruct|getdebuginfo|mtlb_dec2hex|atomsVersion|getdynlibext|generic_i_st|TCL_EvalFile|TCL_ExistVar|%spb_cumsum|setlanguage|mtlb_double|getlanguage|get_profile|TCL_EvalStr|show_window|%_EObj_disp|mtlb_delete|generic_i_s|mtlb_cumsum|xmlValidate|scicos_time|%mps_string|%msp_length|generic_i_h|%i_msprintf|savehistory|%i_mfprintf|rotate_axes|mtlb_fliplr|mtlb_format|xmlDocument|atomsUpdate|mtlb_fscanf|xmlAsNumber|%xlssheet_e|mtlb_fwrite|mtlb_filter|readgateway|endfunction|%hm_cumprod|%grand_perm|matfile2sci|%xlssheet_p|ui_observer|printfigure|householder|xcosPalMove|xcosPalLoad|preferences|mtlb_loglog|plotbrowser|mtlb_median|stripblanks|loadmatfile|%XMLValid_p|%hm_dsearch|filebrowser|mtlb_pcolor|pathconvert|tbx_builder|clearglobal|closeEditor|taucs_chdel|mtlb_setstr|taucs_chget|mtlb_sscanf|h5writeattr|mtlb_strcmp|helpbrowser|%msp_sparse|mtlb_sparse|csvTextScan|historysize|atomsSearch|%cblock_c_s|mtlb_strrep|htmlReadStr|%msp_spones|classmarkov|%TSIMPLEX_p|plotprofile|mtlb_uint16|mtlb_uint32|example_run|xmltoformat|prettyprint|datatipMove|%b_iconvert|loadhistory|libraryinfo|showprofile|nmplot_cget|demo_choose|atomsRemove|%sp_cumprod|optim_nsga2|with_module|%c_i_XMLDoc|%s_f_cblock|%s_c_cblock|%H5Object_p|sciGUI_init|jgetmethods|savematfile|jautoUnwrap|umf_lusolve|%H5Object_e|eigenmarkov|%ticks_i_h|%i_4__EObj|%c_dsearch|%i_3__EObj|%i_a__EObj|%i_2__EObj|%lss_o_lss|%i_cumprod|%c_z__EObj|%c_y__EObj|%c_x__EObj|%lss_n_lss|%c_s__EObj|%c_r__EObj|%c_q__EObj|%c_p__EObj|%c_o__EObj|jcreatejar|%c_n__EObj|%c_m__EObj|odeoptions|%c_l__EObj|%c_k__EObj|daeoptions|jgetfields|%c_i__EObj|isalphanum|nmplot_new|nmplot_log|jinvoke_db|%i_d__EObj|%lss_m_lss|%i_g__EObj|nmplot_get|junwraprem|optim_moga|optim_nsga|%i_h__EObj|demo_begin|%c_h__EObj|%c_g__EObj|clean_help|%i_i__EObj|%i_j__EObj|%c_d__EObj|%i_k__EObj|%c_a__EObj|%c_4__EObj|%c_3__EObj|%c_2__EObj|%c_1__EObj|%b_z__EObj|%b_y__EObj|%b_x__EObj|%b_s__EObj|loadScicos|%b_r__EObj|%b_q__EObj|%i_l__EObj|%b_p__EObj|%b_o__EObj|%b_n__EObj|%b_m__EObj|%b_l__EObj|%b_k__EObj|%b_j__EObj|%b_i__EObj|%i_1__EObj|%b_h__EObj|%b_g__EObj|%b_d__EObj|%b_a__EObj|derivative|%b_4__EObj|%i_m__EObj|%b_3__EObj|%b_2__EObj|%lss_l_lss|%b_1__EObj|isLeapYear|%lss_r_lss|%lss_s_lss|edit_error|%lss_i_lss|%_EObj_z_s|%lss_f_lss|%_EObj_z_i|messagebox|%_EObj_z_c|%b_cumprod|%_EObj_z_b|%_EObj_y_s|mtlb_zeros|fieldnames|mtlb_upper|mtlb_uint8|%lss_c_lss|%_strsplit|%i_n__EObj|find_links|%_EObj_y_i|%_EObj_y_c|%_EObj_y_b|%_EObj_x_s|%_EObj_x_i|%i_o__EObj|umf_lufact|%_EObj_x_c|%i_p__EObj|%i_q__EObj|%_EObj_x_b|test_clean|%i_r__EObj|havewindow|%TNMPLOT_p|%lss_v_lss|%TNELDER_p|%i_s__EObj|%i_x__EObj|%_EObj_s_s|%_EObj_s_i|%_EObj_s_c|%_EObj_s_b|%i_y__EObj|%_EObj_r_s|%_EObj_r_i|h5readattr|%i_z__EObj|mtlb_rcond|mtlb_randn|%_EObj_r_c|%_EObj_r_b|%l_i__EObj|%_EObj_q_s|%_EObj_q_i|fminsearch|%lss_a_lss|%msp_spget|%_EObj_q_c|%_EObj_q_b|%s_1__EObj|%_EObj_p_s|%_EObj_p_i|%s_2__EObj|%_EObj_p_c|%s_3__EObj|%s_4__EObj|%_EObj_p_b|%sp_length|%_EObj_o_s|mtlb_lower|%ce_matrix|%ce_string|%s_a__EObj|mtlb_logic|%s_d__EObj|%_EObj_o_i|%_EObj_o_c|%_EObj_o_b|%_EObj_n_s|%s_g__EObj|%_EObj_n_i|%_EObj_n_c|%s_h__EObj|%fptr_i_st|%s_i__EObj|%_EObj_n_b|mtlb_int32|mtlb_int16|%_EObj_m_s|mtlb_image|%_EObj_m_i|%_EObj_m_c|%_EObj_m_b|%s_j__EObj|%_EObj_l_s|%_EObj_l_i|%_EObj_l_c|optimplotx|%s_k__EObj|%_EObj_l_b|format_txt|%_EObj_k_s|gstacksize|%_EObj_k_i|%_EObj_k_c|%s_l__EObj|%s_m__EObj|mtlb_fread|%s_n__EObj|%s_o__EObj|mtlb_fopen|%s_p__EObj|%s_q__EObj|%s_r__EObj|fun2string|%_EObj_k_b|%_EObj_j_s|%_EObj_j_i|%_EObj_j_c|%_EObj_j_b|%_EObj_h_s|getversion|mtlb_false|%_EObj_h_i|%_EObj_h_c|%s_s__EObj|%s_x__EObj|%s_y__EObj|%s_z__EObj|%_EObj_h_b|%sp_string|%l_isequal|getmodules|mtlb_exist|%_EObj_g_s|mtlb_error|%_EObj_g_i|%_EObj_g_c|%_EObj_g_b|%mc_string|bode_asymp|TCL_GetVar|%_EObj_d_s|%_EObj_d_i|TCL_SetVar|%_EObj_d_c|%_EObj_d_b|%_EObj_a_s|gethistory|%spb_g_spb|%spb_h_spb|%_EObj_a_i|%ip_string|xcosPalAdd|%st_i_fptr|addhistory|%_EObj_a_c|xmlRelaxNG|%_EObj_a_b|mtlb_close|%i_plot2d2|xmlReadStr|%i_plot2d1|%st_matrix|%_EObj_4_s|%_EObj_4_i|%_EObj_4_c|xmlElement|%st_string|%hm_bool2s|%_EObj_4_b|vectorfind|%_EObj_3_i|%_EObj_3_c|%hm_cumsum|OS_Version|ilib_build|%_EObj_3_b|%_EObj_2_s|fprintfMat|PlotSparse|bsplin3val|xcosPalGet|%_EObj_2_i|%_EObj_2_c|%_EObj_2_b|%_EObj_1_s|%_EObj_1_i|%_EObj_1_c|buildouttb|%i_dsearch|%_EObj_1_b|%msp_n_msp|%_EClass_p|%i_contour|%_EClass_e|list_param|%_EClass_6|%hm_degree|!!_invoke_|fftw_flags|%i_Matplot|completion|contour2di|csvDefault|%msp_o_msp|%hm_string|testmatrix|squarewave|%p_cumprod|%sp_cumsum|launchtest|randpencil|%XMLList_p|%XMLList_e|%XMLList_6|%hm_isreal|%XMLElem_p|%XMLElem_e|%XMLElem_6|deletefile|scisptdemo|uigetcolor|%r_cumprod|%XMLAttr_p|init_param|%XMLAttr_e|%XMLAttr_6|sci_sparse|%hm_median|%hm_matrix|umf_luinfo|%_EObj_3_s|%c_j__EObj|%i_mprintf|lasterror|umf_luget|uiputfile|%XMLDoc_6|inv_coeff|%r_cumsum|intersect|unsetmenu|%p_string|iscellstr|usecanvas|useeditor|integrate|%r_matrix|%r_string|uigetfont|mtlb_more|uigetfile|%s_bezout|%XMLDoc_e|%XMLDoc_p|uicontrol|%p_matrix|%s_matrix|%sp_floor|%sp_grand|%p_cumsum|%sp_gsort|write_csv|%XMLSet_6|karmarkar|%XMLSet_e|x_mdialog|%XMLSet_p|lindquist|%msp_maxi|invsyslin|xchoicesi|%msp_i_st|%msp_find|listfiles|lmisolver|%sp_round|%lss_size|%lss_rand|%lss_ones|%lss_norm|m2sci_gui|%i_cumsum|stringbox|%i_matrix|%lss_i_st|xmltohtml|%lss_i_ce|%msp_full|ifftshift|ClipBoard|%spb_diag|PlaySound|stacksize|TCL_UpVar|xgetmouse|xgraduate|mfile2sci|_code2str|hallchart|_str2code|%spb_i_ce|%spb_i_st|xmlAppend|%spb_prod|xmlAsText|umf_ludel|xmlDelete|%spb_tril|%i_string|%spb_triu|xmlFormat|%st_i_lss|mtlb_axes|mtlb_axis|mtlb_beta|%st_i_msp|%i_plot2d|spcompack|%st_i_spb|mtlb_cond|xmlRemove|xmlSchema|backslash|simp_mode|%i_length|variancef|IsAScalar|mtlb_diag|get_param|mtlb_diff|tree2code|toolboxes|mtlb_echo|mtlb_eval|genmarkov|browsevar|%i_champ1|%i_bezout|sci_tree4|sci_tree3|sci_tree2|add_param|rubberbox|closeXcos|mtlb_find|ana_style|%hm_zeros|createdir|removedir|steadycos|zoom_rect|mtlb_full|%hm_stdev|%hm_round|mtlb_grid|mtlb_hold|curblockc|spaninter|mtlb_ifft|set_param|mtlb_int8|drawlater|duplicate|atomsList|atomsLoad|mtlb_mean|mtlb_mesh|atomsQuit|mtlb_ones|mtlb_plot|%hm_isnan|mtlb_prod|mtlb_rand|phaseplot|mtlb_size|mtlb_sort|%hm_gsort|nearfloat|%hm_grand|mtlb_mode|%TOPTIM_p|%hm_floor|atomsShow|mtlb_tril|%_EVoid_p|mtlb_triu|mtlb_true|fileparts|mtlb_type|%_sodload|model2blk|findfiles|find_freq|fscanfMat|filt_sinc|atomsTest|getdrives|bench_run|getmemory|%b_cumsum|h5dataset|factorial|h5isArray|nancumsum|h5isGroup|nand2mean|h5isSpace|%cblock_p|%cblock_e|htmlWrite|mclearerr|%c_matrix|companion|dispfiles|condestsp|nanmedian|invoke_lu|nanreglin|macr2tree|createfun|%bicgstab|jgetfield|jsetfield|%b_matrix|%b_string|lsqrsolve|lsq_splin|h_inf_st|demo_end|nextpow2|legendre|loadXcos|demo_gui|demo_run|jgetinfo|narsimul|ctr_gram|jcompile|noisegen|nanstdev|isletter|macr2lst|isglobal|convol2d|num2cell|obs_gram|observer|cont_mat|%c_grand|cont_frm|conjgrad|obsv_mat|%b_i_spb|%c_i_lss|diophant|optim_ga|dt_ility|maxfiles|colregul|colinout|colcompr|interp3d|interp2d|optim_sa|iconvert|%b_h_spb|htmlRead|htmlDump|nanmeanf|h5umount|%b_grand|h5isVlen|h5isType|%ce_c_ce|%b_g_spb|%ce_f_ce|%ce_i_ce|cheb2mag|%ce_i_st|h5isList|cheb1mag|%ce_size|%b_f_spb|cepstrum|cell2mat|h5isFile|h5isAttr|mfprintf|cat_code|optimget|h5exists|%st_i_ip|calendar|optimset|%hm_1_hm|grayplot|%hm_2_hm|bytecode|%hm_3_hm|mvcorrel|%hm_4_hm|getfield|bloc2exp|%hm_a_hm|binomial|%b_c_spb|fftshift|funcprot|fullpath|%hm_c_hm|%hm_ceil|%hm_conj|mtlb_var|findABCD|fromjava|%hm_d_hm|%_unwrap|movefile|fileinfo|p_margin|mtlb_sum|exportUI|%hm_f_hm|%hm_find|msprintf|%hm_g_hm|name2rgb|mtlb_std|%hm_h_hm|pertrans|%hm_i_ce|pfactors|%hm_i_hm|phasemag|findx0BD|errclear|errcatch|%hm_i_st|princomp|%hm_imag|projspec|param3d1|emptystr|%hm_j_hm|mtlb_min|%hm_k_hm|mtlb_max|function|qp_solve|rhs2code|ric_desc|mtlb_isa|drawaxis|%hm_mean|rowcompr|rowinout|rowregul|rowshuff|%hm_n_hm|savewave|diffobjs|dgettext|mtlb_imp|dec2base|%hm_o_hm|show_pca|data2sig|soundsec|%hm_ones|read_csv|spanplus|%hm_prod|%hm_q_hm|continue|%hm_rand|%hm_real|mtlb_get|curblock|%hm_s_hm|specfact|st_ility|%hm_sign|csvWrite|%hm_size|%hm_sqrt|realtime|statgain|csvIsnum|%hm_x_hm|fourplan|fsfirlin|fullfile|coserror|asciimat|copyfile|%plist_p|code2str|xstringb|g_margin|mtlb_fft|%i_ascii|test_run|mtlb_eye|%i_champ|scicosim|captions|thrownan|toeplitz|add_demo|tokenpos|buildDoc|scinotes|setfield|mtlb_dir|%i_grand|trianfml|trimmean|sig2data|trisolve|variance|xmlXPath|vec2list|basename|base2dec|wavwrite|%st_size|xmlWrite|%st_o_tl|%st_o_mc|wfir_gui|mtlb_cov|whereami|%st_n_mc|who_user|%st_i_st|mtlb_box|%st_i_sp|getshell|arl2_ius|addinter|gettklib|mtlb_any|addcolor|%i_round|%st_f_st|%st_c_st|mtlb_all|gfrancis|splitURL|%spb_sum|mstr2sci|%ip_i_st|xmlAddNs|%ip_n_ip|%ip_o_ip|%spb_i_h|%ip_part|xls_read|xls_open|%spb_i_b|hankelsv|%spb_h_b|meshgrid|str2code|%spb_g_b|%spb_f_b|markp2ss|Matplot1|hypermat|%spb_c_b|%spb_and|%sp_z_sp|%sp_y_sp|%sp_triu|%sp_tril|Calendar|iirgroup|%lss_a_p|%lss_a_r|%lss_a_s|xcos_run|%lss_c_p|%lss_c_r|%lss_c_s|%sp_sqrt|%lss_eye|xmltochm|%lss_f_p|%lss_f_r|%lss_f_s|mapsound|makecell|%lss_i_p|%lss_i_r|%lss_i_s|strindex|%lss_inv|macrovar|%lss_l_p|%lss_l_r|%lss_l_s|xmltojar|%lss_m_p|%lss_m_r|%lss_m_s|m_circle|%lss_n_p|%lss_n_r|%lss_n_s|lqg2stan|xmltopdf|%lss_o_p|%lss_o_r|%lss_o_s|strsplit|xmltoweb|%lss_r_p|%lss_r_r|%lss_r_s|logspace|%sp_s_sp|yulewalk|%lss_s_p|%lss_s_r|%lss_s_s|loadwave|strsubst|%_EObj_t|%lss_v_p|%lss_v_r|%lss_v_s|%sp_r_sp|%sp_q_sp|%sp_prod|%sp_norm|%_EObj_p|%mc_i_st|%mc_n_st|%mc_o_st|%_EObj_e|%sp_l_sp|%_EObj_6|%msp_a_s|%msp_abs|%sp_k_sp|list2vec|%msp_i_s|linspace|tempname|%msp_m_s|linsolve|%_EObj_0|%msp_nnz|lex_sort|%sp_i_st|x_dialog|x_choose|%sp_i_sp|%p_a_lss|%sp_i_ce|%p_c_lss|isvector|%XMLNs_p|isstruct|issquare|issparse|%sp_diag|%sp_d_sp|clearfun|%p_f_lss|%XMLNs_e|%p_grand|%XMLNs_6|%sp_conj|%sp_ceil|%p_i_lss|%sp_a_sp|%s_v_lss|%s_s_lss|%s_r_lss|%s_o_lss|%s_n_lss|isscalar|%s_m_msp|%s_m_lss|%p_l_lss|%s_l_lss|%s_i_spb|%s_i_lss|%s_grand|%p_m_lss|%s_f_lss|typename|uigetdir|%p_n_lss|%s_c_lss|imrep2ss|%p_o_lss|inistate|%s_a_msp|%s_a_lss|%r_v_lss|ismatrix|%r_s_lss|%r_r_lss|%r_o_lss|%p_r_lss|%r_n_lss|iscolumn|%r_m_lss|%p_s_lss|%r_l_lss|%r_i_lss|interpln|%r_f_lss|%p_v_lss|intsplin|is_param|%r_clean|%r_c_lss|%r_a_lss|%_EObj_5|gainplot|%hm_x_s|readmps|mtlb_is|saveGui|sciargs|semidef|setmenu|zeropen|%r_a_hm|plot3d1|plot2d4|plot2d3|plot2d2|%p_x_hm|plot2d1|splin2d|splin3d|pathsep|param3d|mtlb_qr|mtlb_qz|minreal|sprintf|openged|%r_diag|members|mdelete|manedit|strcspn|macglov|strncpy|%r_i_ce|%r_i_hm|%p_simp|strrchr|newaxes|msscanf|%r_i_st|lqg_ltr|mputstr|mprintf|mgetstr|lmitool|mfscanf|mvvacov|symfcti|nanmean|%r_m_hm|lusolve|leastsq|lcmdiag|lstsize|lsslist|loadGui|kroneck|toolbar|junwrap|%r_norm|justify|jremove|toprint|jinvoke|%r_ones|jimport|jexists|%r_prod|nthroot|isfield|isempty|uipopup|iserror|numdiff|nyquist|%r_rand|xmltops|%r_s_hm|isequal|umfpack|inttrap|obscont|%r_simp|%r_size|%p_prod|isdigit|interp1|%r_tril|%r_triu|%p_part|oct2dec|var2vec|isascii|%r_varn|inttype|vec2var|waitbar|warning|ind2sub|whereis|h5write|write4b|h5mount|%s_1_hm|h5label|%s_2_hm|xarrows|%s_3_hm|xchange|%s_4_hm|h5isSet|%i_diag|h5isRef|%s_a_hm|h5group|%s_a_ip|h5flush|%p_o_sp|h5close|%s_a_sp|gettext|htrianr|hilbert|hex2dec|xfpolys|getdate|harmean|gammaln|%s_c_sp|filesep|fileext|xmlDump|xmlName|%s_d_sp|xmlRead|fadj2sp|geomean|penlaur|permute|%s_f_sp|execstr|xstring|fullrfk|%p_m_hm|playsnd|fstabst|pmodulo|pol2des|%s_i_ce|pol2str|%s_i_hm|polfact|frep2tf|apropos|profile|qpsolve|%s_i_sp|quaskro|%s_i_st|rafiter|%s_k_hm|readxls|regress|%s_k_sp|flipdim|%s_l_hm|editvar|repfreq|%0_i_st|%3d_i_h|%_gsort|%s_l_sp|%_rlist|dsearch|%s_m_hm|findBDK|%s_m_ip|drawnow|factors|%b_diag|riccati|%s_n_hm|routh_t|rowcomp|dlgamma|samplef|%s_n_st|%s_o_hm|entropy|ell1mag|dispbpt|%b_i_ce|%s_o_st|%i_maxi|sci2exp|delmenu|scitest|%s_q_hm|dllinfo|%b_i_hm|dirname|%s_q_sp|%b_i_sp|detrend|%p_i_st|%b_i_st|derivat|setdiff|%s_r_sp|%b_n_hm|%s_s_hm|%b_o_hm|%s_s_ip|%b_prod|%b_tril|%s_s_sp|%s_simp|dec2oct|dec2hex|dec2bin|intppty|datevec|%s_x_hm|datenum|datafit|%b_triu|spantwo|%s_y_sp|spzeros|cumprod|%s_z_sp|squeeze|ssprint|csvRead|%sp_and|%sp_c_s|%p_i_hm|cshep2d|%sp_cos|%p_i_ce|strange|%sp_d_s|%c_diag|%sp_det|strcmpi|%i_mini|%sp_exp|%sp_f_s|contrss|%c_i_ce|%c_i_hm|cond2sp|%sp_i_h|%sp_i_s|sub2ind|complex|%sp_int|%sp_inv|%sp_k_s|%c_i_st|%sp_l_s|%c_n_st|%mc_i_s|%sp_max|%sp_min|%mc_i_h|colcomp|%sp_p_s|sysconv|%sp_q_s|%c_o_st|%sp_r_s|%lt_i_s|%c_ones|%sp_s_s|cmoment|%sp_sin|cmndred|%l_o_st|%sp_sum|cmb_lin|cls2dls|%sp_y_s|sysdiag|%sp_z_s|%c_rand|%c_tril|%l_n_st|chsolve|%c_triu|sysfact|%ce_i_s|syssize|systmat|%l_i_st|convstr|cellstr|%i_mput|%ip_s_s|%i_prod|%ip_m_s|%spb_or|%ip_a_s|ccontrg|%choose|%i_sign|%h_i_st|%hm_1_s|%i_tril|%hm_2_s|%st_i_b|%st_i_c|buttmag|%st_i_h|%st_i_i|%i_triu|%hm_3_s|%hm_4_s|%st_i_p|%st_i_r|%st_i_s|bloc2ss|%sp_a_s|Matplot|callblk|%st_n_c|%st_n_l|%hm_a_r|%st_n_p|%st_n_s|%st_o_c|%st_o_l|bin2dec|%st_o_p|%st_o_s|time_id|xcosPal|%hm_a_s|balreal|with_tk|auwrite|augment|%hm_abs|%hm_and|%i_i_st|%hm_cos|%hm_d_s|%i_i_hm|%hm_exp|%hm_eye|%hm_i_b|%i_i_ce|%hm_i_h|%hm_i_i|%hm_i_p|winlist|%hm_i_r|%hm_i_s|%hm_int|%hm_j_s|%hm_k_s|weekday|%hm_log|wcenter|%hm_m_p|wavread|besselh|besseli|besselj|%hm_m_r|%hm_m_s|%hm_max|%hm_min|%hm_n_b|%hm_n_c|%hm_n_i|%hm_n_p|%hm_n_s|%hm_o_b|analyze|%hm_o_c|%hm_o_i|%hm_o_p|%hm_o_s|arma2ss|blkslvi|blkfc1i|%hm_r_s|%hm_s_r|arsimul|%hm_s_s|%hm_sin|besselk|%hm_sum|bessely|%hm_x_p|trzeros|pencost|bezout|%i_1_s|asinhm|typeof|unique|%i_2_s|%i_3_s|%i_4_s|bfinit|armax1|trfmod|%hm_or|unix_g|unix_s|atanhm|bool2s|arma2p|unix_w|unix_x|unpack|analpf|%i_a_i|aff2ab|adj2sp|%i_a_s|%i_and|%i_b_s|%i_d_i|%i_d_s|unwrap|banner|acoshm|balanc|wiener|wigner|%i_fft|window|%i_g_i|%i_gcd|%i_h_i|NDcost|%i_i_h|G_make|c_link|%i_i_i|%i_i_s|%i_j_i|%xls_p|%xls_e|auread|%i_j_s|%i_l_s|%i_lcm|%i_m_i|tf2des|%i_m_s|%i_n_s|bitand|bitcmp|bitget|%i_o_s|bitset|bitxor|cdfbet|%i_p_i|cdfbin|%i_p_s|%i_q_s|cdfchi|%i_r_i|cdfchn|%i_r_s|bvodeS|%i_s_i|%i_s_s|cdffnc|%i_sum|calerf|calfrq|cdfgam|cdfnbn|cdfnor|%dir_p|%i_x_i|%i_x_s|cdfpoi|champ1|%l_i_h|center|%l_i_s|cfspec|%l_n_c|system|%l_n_l|%spb_e|syslin|%l_n_m|%l_n_p|chepol|chfact|%l_n_s|%l_o_c|%l_o_l|%l_o_m|%l_o_p|%l_o_s|%lss_e|%lss_s|%lss_t|%m_n_l|%m_o_l|svplot|%sp_or|%c_o_l|%mps_p|%c_n_l|%msp_e|%msp_p|%c_i_s|%msp_t|%p_a_r|%c_i_r|%p_c_r|%c_i_h|%p_d_p|%c_i_c|%c_f_s|%p_d_r|struct|%c_eye|%p_d_s|convol|%p_det|copfac|correl|%p_f_r|%p_i_h|stdevf|%p_i_p|stabil|ctree2|ctree3|ctree4|ssrand|resume|%c_b_s|%c_b_c|%c_a_c|ss2des|srfaur|%b_x_s|%i_min|%s_z_r|sqroot|%s_z_p|sprand|cspect|%b_x_b|cumsum|%s_y_r|%s_y_p|sp2adj|%s_x_r|smooth|%s_x_i|%s_x_b|sm2des|%s_v_s|dawson|%s_v_r|%s_v_p|%p_i_r|%s_s_r|%b_sum|%b_s_s|%b_s_b|%b_r_s|%b_r_b|%p_i_s|%b_p_s|%s_s_i|%s_s_b|%b_m_s|%b_m_b|%s_r_s|%s_r_r|%b_l_s|des2ss|des2tf|%b_l_b|%s_r_p|determ|degree|%s_r_i|%s_r_b|dhnorm|delbpt|%b_i_s|delete|%s_q_r|%s_q_p|%s_q_i|%s_pow|dsimul|%b_i_h|%s_p_i|%s_p_b|%s_o_r|editor|%b_i_b|%p_inv|%s_o_l|%b_h_s|%s_o_i|eomday|%s_n_r|sample|%p_j_s|dnaupd|equil1|erfinv|dneupd|double|%s_n_l|%s_n_i|%b_g_s|%b_f_s|%p_k_p|factor|%s_m_r|%p_k_r|faurre|%p_k_s|driver|%b_c_s|%b_a_s|%b_a_b|filter|dsaupd|findAC|%s_m_i|%s_m_b|dseupd|%_save|%s_lcm|repmat|%s_l_s|%s_l_r|%s_l_p|%p_l_p|%s_l_i|ereduc|%s_l_b|remezb|%s_k_r|select|reglin|recons|%s_k_p|%s_j_i|%p_l_r|%s_i_s|elseif|pspect|psmall|projsl|%s_i_r|primes|%s_i_p|prbs_a|zneupd|%p_l_s|freson|%s_i_i|%s_i_h|znaupd|%s_i_c|%s_i_b|fspecg|%s_h_s|%s_h_b|ftuneq|xtitle|fullrf|%s_gcd|%s_g_s|%s_g_b|exists|gamitg|%s_f_r|perctl|%p_m_r|xs2svg|return|xs2ppm|xs2png|xs2pdf|xs2jpg|xs2gif|genlib|xs2eps|%p_n_l|xs2emf|xs2bmp|xrects|pencan|xpolys|pen2ea|xpause|parrot|%s_f_b|%i_max|figure|%s_d_r|%p_y_s|%s_d_p|givens|glever|%s_d_i|%s_d_b|gschur|findBD|format|h2norm|fsolve|fstair|xmlDTD|h_norm|xlfont|funptr|%s_c_r|geom3d|%p_n_r|getURL|%p_o_l|xfrect|%s_c_b|hermit|%p_o_r|getenv|%s_b_s|getmd5|horner|xfpoly|getpid|%s_b_i|xfarcs|%s_and|global|h5attr|%s_a_r|h5dump|%p_p_s|%s_a_i|iirmod|%s_a_b|%s_4_i|xclick|%s_3_i|%s_2_i|%s_1_i|%r_z_s|%r_z_r|h5open|h5read|winsid|im_inv|%r_z_p|%r_y_s|inpnvi|interp|%r_y_r|%r_y_p|%r_x_s|%r_x_r|%r_x_p|%r_v_s|%r_v_r|%r_v_p|intdec|obsvss|%i_abs|unzoom|%r_sum|%r_s_s|unglue|%r_s_r|%r_s_p|%p_q_p|%r_r_s|%r_r_r|%r_r_p|uiwait|%p_q_r|isfile|iscell|uint32|uint16|%r_q_s|%r_q_r|%r_q_p|uimenu|isreal|jarray|%r_p_s|%_load|%r_o_s|tr_zer|%r_o_r|%r_o_p|%p_q_s|%r_n_s|%r_n_r|kernel|length|linmeq|%r_n_p|%p_r_p|%p_r_r|tokens|lstcat|%r_m_s|%r_m_r|%r_m_p|lufact|nehari|ndgrid|nansum|tohome|%p_r_s|matrix|lin2mu|lincos|nanmin|mclose|%r_l_s|nanmax|merror|ta2lpd|syredi|%r_l_r|%r_l_p|%p_s_r|mu2lin|%r_k_s|strtok|strtod|strstr|%r_k_r|%r_k_p|%r_j_s|strspn|mtlb_t|mscanf|strrev|%r_inv|%r_i_s|mucomp|%r_i_r|%r_i_p|%r_f_s|%r_f_r|string|newest|%r_f_p|%p_sum|strcmp|strchr|strcat|%r_eye|newfun|notify|median|%_eigs|mtlb_s|%r_det|opentk|%r_d_s|%r_d_r|ordmmd|%r_d_p|modulo|moment|%p_v_p|%p_v_r|spones|%p_v_s|mtlb_0|mtlb_a|%r_c_s|%r_c_r|plot2d|%r_c_p|%r_a_s|spchol|sparse|sorder|%r_a_r|%r_a_p|plot3d|%p_x_r|pppdiv|predef|sident|sfinit|printf|%p_y_p|setenv|mtlb_e|setbpt|prompt|%p_y_r|sctree|zpbutt|mtlb_l|%p_z_s|%p_z_r|rankqr|read4b|mtlb_i|%p_z_p|regexp|residu|blanks|%b_d_s|xpoly|remez|rlist|zpch2|roots|readb|round|zpch1|zgrid|rdivf|rcond|%s_or|rtitr|%sp_e|%ip_p|%st_6|%st_e|%i_or|schur|about|%st_p|sfact|print|amell|xcorr|%st_t|ascii|abinv|acosd|slash|sleep|acosh|spget|splin|acosm|acotd|bdiag|mrfit|mkdir|minss|acoth|optim|acscd|acsch|aplat|unobs|odedc|arhnk|meanf|armac|armax|gfare|asecd|union|asech|asind|mtell|asinh|mseek|asinm|%hm_s|%hm_p|mputl|atand|atanh|trans|mopen|trace|mlist|atanm|log10|mgetl|bvode|mgeti|%hm_e|bilin|tf2ss|bitor|black|timer|linfn|%hm_5|bstap|tlist|cainv|canon|levin|luget|champ|ndims|chdir|clean|ludel|clear|ltitr|coeff|color|lattp|contr|log1p|conv2|lattn|%ce_t|tanhm|krac2|tabul|lines|light|nfreq|chart|%ce_p|kpure|ldivf|%ce_6|clock|jwrap|coffg|coshm|stdev|cothm|covar|jdeff|jcast|isrow|ss2tf|isnum|ss2ss|isinf|cross|uint8|%bicg|ulink|numer|invrs|sqrtm|isdir|speye|daskr|isdef|dasrt|dassl|input|sound|solve|signm|sm2ss|dbphi|sinhm|int3d|int32|int2d|int16|sincd|where|imult|debug|sgrid|denom|sensi|sdiff|delip|dhinf|diary|writb|write|scanf|samwr|epred|eqfir|xarcs|eqiir|equil|iirlp|h5get|etime|evans|evstr|xfarc|rmdir|gsort|ffilt|grand|findR|%ar_p|glist|findm|while|getos|histc|getio|pause|range|xgrid|quart|xinit|erfcx|gamma|catch|break|h_inf|error|fromc|frexp|abort|frfit|gtild|floor|gspec|polar|group|gmres|frmag|xmlNs|zeros|fspec|ftest|feval|zpell|gcare|perms|xsegs|xs2ps|xname|xrect|isnan|%ce_e|mget|real|pbig|expm|pack|rpem|perl|%pcg|getd|read|exit|pfss|%r_0|xset|%r_e|pinv|%r_p|exec|plzr|orth|fftw|file|find|fort|freq|h_cl|full|erfi|case|proj|halt|hank|%r_s|else|%r_t|%s_5|%s_e|xcov|help|erfc|xget|rank|save|%i_p|hilb|quit|then|flts|rand|%p_e|hrmt|prod|idct|idst|glue|%asn|fft2|grep|%b_e|ifft|h5cp|acos|eval|xend|xdel|xcos|rref|addf|h5ls|xarc|eigs|disp|h5mv|edit|h5rm|diag|sign|simp|dtsi|hess|dscr|hinf|ppol|secd|sech|pdiv|diff|host|detr|deff|ieee|imag|impl|poly|abcd|%i_e|sinc|whos|sind|sinh|int8|sinm|what|intg|smga|date|varn|asin|intc|damp|user|unix|atan|size|intl|csim|csgn|csch|invr|cscd|wfir|spec|srkf|null|mtlb|ricc|sskf|type|acot|triu|coth|cotg|cotd|cosm|tril|jmat|cosh|cosd|%c_e|conv|cond|part|kalm|sylm|sylv|coff|kron|ldiv|asec|nlev|beep|char|link|tand|tanh|list|tanm|acsc|corr|copy|load|mfft|sqrt|conj|comp|mese|ones|arl2|leqe|norm|chol|leqr|%cgs|mean|ceil|cdft|cell|lyap|casc|mulf|beta|cdff|logm|bode|linf|meof|mput|log2|bilt|move|call|mode|subf|h5ln|argn|toc|min|tic|svd|tan|pca|max|lqe|lqg|lin|lqr|gcd|lft|cat|mad|lev|nnz|clc|eye|ode|lcm|lcf|lsq|log|cos|exp|lib|ver|msd|sva|cov|now|iqr|csc|czt|dae|inv|int|rat|dcf|sin|ddp|dct|dir|and|sec|det|who|pcg|iir|abs|dst|set|fec|phc|pwd|fix|qld|fft|try|erf|sum|end|for|%sn|acf|get|qmr|%k|do|qr|if|_d|or|lu|ls|cd|_)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(differential_equationlib|compatibility_functilib|elementary_functionslib|simulated_annealinglib|genetic_algorithmslib|development_toolslib|signal_processinglib|special_functionslib|external_objectslib|modules_managerlib|data_structureslib|linear_algebralib|interpolationlib|output_streamlib|dynamic_linklib|optimizationlib|scicos_utilslib|optimsimplexlib|spreadsheetlib|scicos_autolib|preferenceslib|polynomialslib|overloadinglib|%toolboxes_dir|neldermeadlib|%modalWarning|parameterslib|demo_toolslib|statisticslib|functionslib|helptoolslib|optimbaselib|scinoteslib|%toolboxes|arnoldilib|integerlib|umfpacklib|randliblib|sparselib|assertlib|fileiolib|stringlib|tclscilib|soundlib|m2scilib|cacsdlib|atomslib|matiolib|timelib|SCIHOME|xcoslib|corelib|TMPDIR|jvoid|iolib|evoid|enull|%fftw|jnull|%nan|home|%eps|%gui|%inf|%io|%tk|SCI|PWD|%pi|fd|%z|%i|%s|%f|%t|%e|%T|%F|\$)\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="-|==|~=|<|>|<=|>=|&&|&|~|\|\|?"> + <token type="Operator"/> + </rule> + <rule pattern="\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\](){}@.,=:;]"> + <token type="Punctuation"/> + </rule> + <rule pattern=""[^"]*""> + <token type="LiteralString"/> + </rule> + <rule pattern="(?<=[\w)\].])\'+"> + <token type="Operator"/> + </rule> + <rule pattern="(?<![\w)\].])\'"> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+[eEf][+-]?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^']*'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="."> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="deffunc"> + <rule pattern="(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)"> + <bygroups> + <token type="TextWhitespace"/> + <token type="Text"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + <token type="NameFunction"/> + <token type="Punctuation"/> + <token type="Text"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="(\s*)([a-zA-Z_]\w*)"> + <bygroups> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scss.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scss.xml new file mode 100644 index 0000000..ee060fc --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/scss.xml @@ -0,0 +1,373 @@ +<lexer> + <config> + <name>SCSS</name> + <alias>scss</alias> + <filename>*.scss</filename> + <mime_type>text/x-scss</mime_type> + <case_insensitive>true</case_insensitive> + <dot_all>true</dot_all> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="string-double"> + <rule pattern="(\\.|#(?=[^\n{])|[^\n"#])+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + <state name="id"> + <rule pattern="[\w-]+"> + <token type="NameNamespace"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="value"> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern="!(important|default|global)"> + <token type="Keyword"/> + </rule> + <rule pattern="[!$][\w-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="url\("> + <token type="LiteralStringOther"/> + <push state="string-url"/> + </rule> + <rule pattern="[a-z_-][\w-]*(?=\()"> + <token type="NameFunction"/> + </rule> + <rule pattern="\b(scroll-padding-inline-start|spatial-navigation-function|transition-timing-function|overscroll-behavior-inline|spatial-navigation-contain|border-bottom-right-radius|scroll-padding-block-start|scroll-margin-inline-start|border-bottom-left-radius|border-start-start-radius|border-inline-start-color|animation-iteration-count|border-inline-start-width|animation-timing-function|text-decoration-thickness|border-inline-start-style|scroll-margin-block-start|scroll-padding-inline-end|spatial-navigation-action|overscroll-behavior-block|scroll-margin-inline-end|border-block-start-style|border-block-start-width|scroll-padding-block-end|border-block-start-color|border-inline-end-width|border-top-right-radius|text-underline-position|scroll-margin-block-end|border-start-end-radius|border-end-start-radius|border-inline-end-style|border-inline-end-color|font-variant-east-asian|border-block-end-style|font-language-override|border-block-end-color|border-block-end-width|text-emphasis-position|border-top-left-radius|font-variant-ligatures|background-attachment|overscroll-behavior-x|text-decoration-style|scroll-padding-inline|background-blend-mode|text-decoration-color|text-underline-offset|overscroll-behavior-y|font-variant-position|shape-image-threshold|grid-template-columns|border-end-end-radius|font-feature-settings|scroll-padding-bottom|font-variant-numeric|initial-letter-align|text-combine-upright|box-decoration-break|overflow-clip-margin|scroll-padding-right|padding-inline-start|scroll-margin-bottom|text-decoration-skip|scroll-margin-inline|scroll-padding-block|animation-play-state|text-decoration-line|scroll-margin-block|border-image-outset|font-optical-sizing|animation-fill-mode|margin-inline-start|border-bottom-color|transition-property|border-inline-width|animation-direction|grid-template-areas|forced-color-adjust|border-inline-style|border-inline-start|text-emphasis-style|scroll-padding-left|border-bottom-width|scroll-margin-right|border-inline-color|overscroll-behavior|list-style-position|hanging-punctuation|background-position|border-bottom-style|border-image-source|transition-duration|initial-letter-wrap|padding-block-start|border-image-repeat|backface-visibility|font-variant-emoji|margin-block-start|border-block-start|border-block-style|padding-inline-end|border-right-width|perspective-origin|inset-inline-start|border-right-color|border-block-color|mask-border-repeat|mask-border-source|border-image-width|scroll-padding-top|animation-duration|border-image-slice|grid-template-rows|content-visibility|scroll-margin-left|border-block-width|border-right-style|image-orientation|scroll-snap-align|page-break-inside|column-rule-width|mask-border-width|column-rule-style|mask-border-slice|column-rule-color|grid-auto-columns|page-break-before|background-repeat|counter-increment|font-variant-caps|padding-block-end|border-inline-end|grid-column-start|border-left-width|border-left-style|border-left-color|scroll-margin-top|inset-block-start|margin-inline-end|background-origin|mask-border-mode|scroll-snap-stop|scroll-snap-type|scrollbar-gutter|font-size-adjust|transform-origin|page-orientation|image-resolution|margin-block-end|footnote-display|page-break-after|border-block-end|text-group-align|text-orientation|transition-delay|background-image|text-size-adjust|border-top-width|border-top-style|list-style-image|border-top-color|background-color|inset-inline-end|offset-distance|background-size|background-clip|list-style-type|footnote-policy|text-decoration|scrollbar-color|scrollbar-width|text-align-last|image-rendering|animation-delay|transform-style|object-position|offset-position|text-space-trim|justify-content|overflow-anchor|scroll-behavior|inset-block-end|border-collapse|grid-column-end|overflow-inline|border-spacing|scroll-padding|text-align-all|pointer-events|max-block-size|text-transform|letter-spacing|lighting-color|mask-composite|initial-letter|mix-blend-mode|overflow-block|animation-name|padding-bottom|flex-direction|padding-inline|font-synthesis|grid-auto-flow|vertical-align|outline-offset|text-rendering|grid-auto-rows|grid-row-start|margin-inline|padding-block|offset-rotate|text-overflow|border-inline|margin-bottom|offset-anchor|scroll-margin|outline-style|border-bottom|shape-outside|outline-width|shape-padding|text-emphasis|align-content|grid-template|border-radius|transform-box|overflow-wrap|justify-items|mask-position|place-content|inline-sizing|counter-reset|padding-right|outline-color|table-layout|column-width|writing-mode|font-variant|touch-action|padding-left|color-adjust|word-spacing|text-justify|shape-margin|caption-side|break-inside|shape-inside|margin-right|break-before|font-kerning|font-stretch|border-width|margin-break|text-spacing|border-style|aspect-ratio|margin-block|grid-row-end|border-block|line-padding|border-right|wrap-through|border-color|border-image|justify-self|inset-inline|unicode-bidi|column-count|column-span|border-left|white-space|wrap-inside|grid-column|will-change|text-shadow|offset-path|user-select|inline-size|break-after|place-items|caret-color|text-indent|padding-top|inset-block|wrap-before|font-weight|flex-shrink|line-height|perspective|column-fill|mask-repeat|align-items|margin-left|mask-origin|margin-trim|column-rule|font-family|empty-cells|counter-set|mask-border|overflow-y|string-set|align-self|text-align|place-self|list-style|wrap-after|block-size|word-break|line-clamp|line-break|flex-basis|max-height|min-height|object-fit|appearance|box-sizing|transition|mask-image|background|border-top|visibility|overflow-x|column-gap|font-style|box-shadow|margin-top|mask-size|line-snap|flex-wrap|nav-right|isolation|flex-grow|flex-flow|translate|line-grid|text-wrap|wrap-flow|min-width|max-width|direction|clip-path|transform|mask-clip|max-lines|mask-type|grid-area|animation|mask-mode|word-wrap|font-size|nav-down|position|overflow|grid-row|tab-size|nav-left|z-index|row-gap|content|opacity|padding|display|outline|columns|hyphens|orphans|margin|border|rotate|filter|resize|quotes|bottom|height|offset|nav-up|cursor|widows|width|inset|clear|color|right|float|scale|order|left|font|flex|mask|page|grid|clip|all|gap|src|top)(?=\s*:)"> + <token type="NameAttribute"/> + </rule> + <rule pattern="(?<!:\s*)[^ \t:="\[;(),.]+(?=[ \t]*:(?:#{|[^{])+?[;,])"> + <token type="NameAttribute"/> + </rule> + <rule pattern="\b(no-discretionary-ligatures|no-historical-ligatures|discretionary-ligatures|simp-chinese-informal|trad-chinese-informal|korean-hanja-informal|historical-ligatures|korean-hangul-formal|decimal-leading-zero|korean-hanja-formal|ruby-text-container|ruby-base-container|no-common-ligatures|trad-chinese-formal|simp-chinese-formal|cjk-earthly-branch|geometricPrecision|optimizeLegibility|table-header-group|table-footer-group|diagonal-fractions|table-column-group|proportional-width|disclosure-closed|stacked-fractions|japanese-informal|alternate-reverse|cjk-heavenly-stem|proportional-nums|slider-horizontal|ideograph-numeric|common-ligatures|isolate-override|ethiopic-numeric|ideograph-alpha|table-row-group|all-petite-caps|cjk-ideographic|inter-character|ultra-condensed|scroll-position|extra-condensed|japanese-formal|disclosure-open|menulist-button|upper-armenian|lower-armenian|extra-expanded|semi-condensed|space-adjacent|all-small-caps|discard-before|katakana-iroha|full-size-kana|no-close-quote|ultra-expanded|hiragana-iroha|target-counter|column-reverse|spelling-error|grammar-error|optimizeSpeed|discard-after|no-contextual|trim-adjacent|table-caption|square-button|semi-expanded|border-bottom|ui-sans-serif|double-circle|vertical-text|outside-shape|horizontal-tb|no-open-quote|space-between|small-caption|oldstyle-nums|bidi-override|progress-bar|match-parent|line-through|space-around|inline-table|inline-block|high-quality|space-evenly|table-column|currentColor|arabic-indic|ui-monospace|rotate-right|inline-start|avoid-region|avoid-column|match-source|manipulation|tabular-nums|context-menu|slashed-zero|cubic-bezier|titling-caps|wrap-reverse|color-dodge|sideways-lr|no-compress|space-first|searchfield|lining-nums|fit-content|ease-in-out|punctuation|min-content|petite-caps|crisp-edges|push-button|translate3d|row-reverse|perspective|max-content|nesw-resize|not-allowed|preserve-3d|space-start|drop-shadow|padding-box|text-bottom|rotate-left|block-start|inline-grid|inline-flex|upper-latin|upper-alpha|lower-latin|auto‑flow|lower-alpha|message-box|lower-greek|upper-roman|lower-roman|vertical-rl|traditional|justify-all|close-quote|content-box|vertical-lr|cjk-decimal|transparent|sideways-rl|target-text|balance-all|ideographic|nwse-resize|saturation|flex-start|open-quote|from-image|avoid-flex|avoid-line|stroke-box|ui-rounded|margin-box|self-start|inline-end|devanagari|avoid-page|status-bar|all-scroll|col-resize|row-resize|translateZ|translateY|translateX|hue-rotate|small-caps|brightness|step-start|capitalize|trim-start|trim-inner|sans-serif|scale-down|contextual|break-word|horizontal|inter-word|color-burn|cross-fade|hard-light|soft-light|border-box|table-cell|luminosity|full-width|difference|simplified|alphabetic|mandatory|exclusion|from-font|table-row|flow-root|underline|image-set|proximity|ruby-base|ruby-text|list-item|monospace|intersect|ns-resize|textfield|ew-resize|uppercase|sw-resize|se-resize|nw-resize|lowercase|grayscale|ne-resize|pan-right|translate|backwards|available|luminance|condensed|alternate|mongolian|plaintext|malayalam|cambodian|transform|block-end|force-end|break-all|crosshair|allow-end|no-repeat|pixelated|system-ui|xxx-large|space-end|w-resize|georgian|flex-end|baseline|gujarati|fangsong|ui-serif|fill-box|keep-all|view-box|xx-small|gurmukhi|pre-line|pre-wrap|contents|xx-large|text-top|hiragana|self-end|katakana|collapse|separate|anywhere|saturate|expanded|subtract|progress|repeat-x|rotate3d|repeat-y|contrast|relative|forwards|infinite|absolute|matrix3d|vertical|overline|pan-down|pan-left|step-end|triangle|ease-out|textarea|sideways|checkbox|menulist|ellipsis|trim-end|grabbing|multiply|zoom-out|n-resize|s-resize|armenian|ordinal|zoom-in|visible|overlay|no-drop|listbox|unicode|lighten|ease-in|lighter|element|running|justify|display|fantasy|unicase|subgrid|reverse|upright|stretch|rotateX|current|exclude|rotateY|pointer|contain|opacity|default|no-clip|in-flow|hanging|isolate|discard|tibetan|persian|myanmar|rotateZ|content|inherit|outside|initial|kannada|smaller|decimal|symbols|x-large|balance|x-small|economy|caption|minimum|maximum|polygon|ellipse|cursive|bengali|masonry|static|region|column|run-in|inline|middle|circle|larger|button|square|pretty|always|hidden|rotate|inside|scroll|screen|matrix|create|unsafe|center|paused|nowrap|medium|darken|sesame|strict|outset|pan-up|bolder|telugu|scaleX|linear|scaleY|groove|double|scaleZ|dashed|minmax|legacy|hebrew|bottom|dotted|leader|normal|stable|weight|smooth|filled|italic|revert|manual|repeat|sticky|invert|table|round|space|alias|jis78|dense|sepia|emoji|auto;|clear|skewX|cover|right|skewY|style|light|unset|force|alpha|large|focus|solid|ridge|white|embed|tamil|blink|first|scale|radio|color|jis83|under|block|jis90|inset|start|pan-y|oriya|super|loose|mixed|thick|slice|pan-x|khmer|width|local|fixed|clone|avoid|serif|exact|recto|meter|small|verso|jis04|image|flow|flex|grid|ruby|wrap|ease|safe|grab|move|icon|bold|last|open|over|wavy|show|hide|both|url;|none|blur|text|line|menu|copy|dark|left|math|cell|clip|fill|skew|wait|help|flat|snap|keep|thai|thin|disc|path|page|attr|rect|auto|row|all|rtl|end|ltr|sub|hue|dot|url|top|lao|add|ray|pre|x|y|z)\b"> + <token type="NameEntity"/> + </rule> + <rule pattern="(?i)\b(LightGoldenRodYellow|MediumSpringGreen|MediumAquaMarine|MediumSlateBlue|MediumVioletRed|MediumTurquoise|LightSlateGray|LightSlateGrey|MediumSeaGreen|BlanchedAlmond|LightSteelBlue|CornflowerBlue|DarkOliveGreen|DarkGoldenRod|PaleGoldenRod|PaleTurquoise|LavenderBlush|RebeccaPurple|DarkSlateGray|DarkSlateGrey|LightSeaGreen|PaleVioletRed|DarkTurquoise|DarkSlateBlue|AntiqueWhite|DarkSeaGreen|LightSkyBlue|MediumOrchid|LemonChiffon|MediumPurple|MidnightBlue|GreenYellow|DarkMagenta|LightSalmon|LightYellow|DeepSkyBlue|NavajoWhite|SaddleBrown|SpringGreen|ForestGreen|FloralWhite|YellowGreen|PapayaWhip|Aquamarine|DodgerBlue|Chartreuse|BlueViolet|DarkViolet|DarkOrange|LightGreen|GhostWhite|WhiteSmoke|DarkOrchid|MediumBlue|PowderBlue|LightCoral|DarkSalmon|SandyBrown|IndianRed|RoyalBlue|SteelBlue|AliceBlue|SlateGrey|MistyRose|Turquoise|LawnGreen|MintCream|LightBlue|SlateGray|LightCyan|GoldenRod|LightGray|LightGrey|Gainsboro|OliveDrab|Chocolate|DarkGreen|PeachPuff|RosyBrown|BurlyWood|FireBrick|SlateBlue|LightPink|LimeGreen|OrangeRed|CadetBlue|DarkKhaki|PaleGreen|HoneyDew|SeaShell|SeaGreen|DeepPink|Cornsilk|DarkBlue|DarkCyan|DarkGray|DarkGrey|Moccasin|Lavender|DarkRed|HotPink|SkyBlue|OldLace|Thistle|Fuchsia|Magenta|DimGrey|Crimson|DimGray|Tomato|Bisque|Silver|Orchid|Orange|Yellow|Sienna|Maroon|Salmon|Purple|Indigo|Violet|Green|Beige|Azure|Olive|Ivory|Coral|Wheat|White|Linen|Brown|Khaki|Black|Cyan|Blue|Aqua|Navy|Peru|Teal|Grey|Snow|Gray|Gold|Plum|Pink|Lime|Red|Tan)\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="(true|false)"> + <token type="NamePseudo"/> + </rule> + <rule pattern="(and|or|not)"> + <token type="OperatorWord"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="inline-comment"/> + </rule> + <rule pattern="//[^\n]*"> + <token type="CommentSingle"/> + </rule> + <rule pattern="\#[a-z0-9]{1,6}"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(-)?(\d+)(\%|[a-z]+)?"> + <bygroups> + <token type="Operator"/> + <token type="LiteralNumberInteger"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="(-?)(\d*\.\d+)(\%|[a-z]+)?"> + <bygroups> + <token type="Operator"/> + <token type="LiteralNumberFloat"/> + <token type="KeywordType"/> + </bygroups> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="[~^*!&%<>|+=@:,./?-]+"> + <token type="Operator"/> + </rule> + <rule pattern="[\[\]()]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string-double"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <push state="string-single"/> + </rule> + <rule pattern="[a-z_-][\w-]*"> + <token type="Name"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="[;{}]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="inline-comment"> + <rule pattern="(\\#|#(?=[^{])|\*(?=[^/])|[^#*])+"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="\*/"> + <token type="Comment"/> + <pop depth="1"/> + </rule> + </state> + <state name="string-single"> + <rule pattern="(\\.|#(?=[^\n{])|[^\n'#])+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + </state> + <state name="interpolation"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="value"/> + </rule> + </state> + <state name="each"> + <rule pattern="in"> + <token type="OperatorWord"/> + </rule> + <rule> + <include state="value"/> + </rule> + </state> + <state name="attr"> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="[ \t]*:"> + <token type="Operator"/> + <push state="value"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="[{}()]"> + <token type="Punctuation"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="@import"> + <token type="Keyword"/> + <push state="value"/> + </rule> + <rule pattern="(@(?:use|forward))(\s+)([^\s;]+)(?:(\s+)(as)(\s+)(\w+|\*))?(?:(\s+)(with))?"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <usingself state="selector"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="@for"> + <token type="Keyword"/> + <push state="for"/> + </rule> + <rule pattern="@each"> + <token type="Keyword"/> + <push state="each"/> + </rule> + <rule pattern="@(debug|warn|else if|if|while|return)"> + <token type="Keyword"/> + <push state="value"/> + </rule> + <rule pattern="(@(?:mixin|function))( [\w-]+)"> + <bygroups> + <token type="Keyword"/> + <token type="NameFunction"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="(@include)( [\w-]+)"> + <bygroups> + <token type="Keyword"/> + <token type="NameDecorator"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="@extend"> + <token type="Keyword"/> + <push state="selector"/> + </rule> + <rule pattern="(@media)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="@[\w-]+"> + <token type="Keyword"/> + <push state="selector"/> + </rule> + <rule pattern="(\$[\w-]*\w)([ \t]*:)"> + <bygroups> + <token type="NameVariable"/> + <token type="Operator"/> + </bygroups> + <push state="value"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="\b(scroll-padding-inline-start|spatial-navigation-function|transition-timing-function|overscroll-behavior-inline|spatial-navigation-contain|border-bottom-right-radius|scroll-padding-block-start|scroll-margin-inline-start|border-inline-start-width|border-start-start-radius|border-inline-start-color|animation-iteration-count|spatial-navigation-action|animation-timing-function|text-decoration-thickness|border-inline-start-style|scroll-margin-block-start|scroll-padding-inline-end|border-bottom-left-radius|overscroll-behavior-block|scroll-margin-inline-end|border-block-start-style|border-block-start-width|scroll-padding-block-end|border-block-start-color|scroll-margin-block-end|border-top-right-radius|text-underline-position|border-inline-end-width|border-start-end-radius|border-end-start-radius|border-inline-end-style|border-inline-end-color|font-variant-east-asian|border-block-end-style|font-language-override|border-block-end-color|border-block-end-width|text-emphasis-position|border-top-left-radius|font-variant-ligatures|shape-image-threshold|overscroll-behavior-x|text-decoration-style|scroll-padding-inline|background-blend-mode|text-decoration-color|text-underline-offset|overscroll-behavior-y|border-end-end-radius|scroll-padding-bottom|grid-template-columns|font-variant-position|font-feature-settings|background-attachment|font-variant-numeric|initial-letter-align|text-combine-upright|text-decoration-line|overflow-clip-margin|scroll-padding-right|padding-inline-start|scroll-margin-bottom|text-decoration-skip|scroll-margin-inline|scroll-padding-block|animation-play-state|box-decoration-break|backface-visibility|border-image-outset|font-optical-sizing|animation-fill-mode|margin-inline-start|border-bottom-color|transition-property|border-inline-width|animation-direction|grid-template-areas|forced-color-adjust|border-inline-style|border-inline-start|text-emphasis-style|scroll-padding-left|border-bottom-width|scroll-margin-right|border-inline-color|overscroll-behavior|list-style-position|hanging-punctuation|background-position|border-bottom-style|border-image-source|transition-duration|initial-letter-wrap|padding-block-start|border-image-repeat|scroll-margin-block|font-variant-emoji|margin-block-start|border-block-start|border-block-style|padding-inline-end|border-block-width|perspective-origin|border-right-style|border-right-color|border-block-color|mask-border-repeat|mask-border-source|border-image-width|scroll-padding-top|animation-duration|border-image-slice|grid-template-rows|content-visibility|scroll-margin-left|border-right-width|inset-inline-start|background-origin|scroll-snap-align|page-break-inside|column-rule-width|mask-border-width|column-rule-style|mask-border-slice|column-rule-color|grid-auto-columns|page-break-before|background-repeat|counter-increment|font-variant-caps|padding-block-end|border-inline-end|grid-column-start|border-left-width|border-left-style|border-left-color|scroll-margin-top|inset-block-start|margin-inline-end|image-orientation|mask-border-mode|scroll-snap-stop|scroll-snap-type|scrollbar-gutter|font-size-adjust|transform-origin|page-orientation|image-resolution|margin-block-end|footnote-display|page-break-after|border-block-end|text-group-align|text-orientation|transition-delay|background-image|text-size-adjust|border-top-width|border-top-style|list-style-image|border-top-color|background-color|inset-inline-end|offset-distance|background-size|background-clip|list-style-type|footnote-policy|text-decoration|scrollbar-color|scrollbar-width|text-align-last|image-rendering|animation-delay|transform-style|object-position|offset-position|text-space-trim|justify-content|overflow-anchor|overflow-inline|inset-block-end|border-collapse|grid-column-end|scroll-behavior|border-spacing|scroll-padding|text-align-all|pointer-events|max-block-size|text-transform|letter-spacing|lighting-color|mask-composite|initial-letter|mix-blend-mode|overflow-block|animation-name|grid-row-start|flex-direction|padding-inline|grid-auto-rows|grid-auto-flow|vertical-align|outline-offset|text-rendering|font-synthesis|padding-bottom|margin-inline|padding-block|offset-rotate|text-overflow|border-inline|margin-bottom|offset-anchor|scroll-margin|outline-style|border-bottom|shape-outside|outline-width|shape-padding|text-emphasis|align-content|grid-template|border-radius|transform-box|overflow-wrap|justify-items|mask-position|place-content|inline-sizing|counter-reset|padding-right|outline-color|writing-mode|column-width|column-count|table-layout|touch-action|padding-left|color-adjust|word-spacing|text-justify|shape-margin|caption-side|break-inside|shape-inside|margin-right|break-before|font-kerning|font-stretch|border-width|margin-break|text-spacing|border-style|aspect-ratio|margin-block|grid-row-end|border-block|line-padding|border-right|wrap-through|border-color|border-image|justify-self|inset-inline|unicode-bidi|font-variant|empty-cells|border-left|white-space|wrap-inside|grid-column|will-change|text-shadow|offset-path|user-select|inline-size|break-after|place-items|caret-color|text-indent|padding-top|inset-block|wrap-before|font-weight|flex-shrink|line-height|perspective|column-fill|mask-repeat|align-items|margin-left|mask-origin|margin-trim|column-rule|font-family|column-span|counter-set|mask-border|mask-image|string-set|align-self|margin-top|place-self|list-style|wrap-after|block-size|word-break|line-clamp|line-break|flex-basis|max-height|min-height|object-fit|appearance|box-sizing|transition|box-shadow|background|border-top|visibility|overflow-x|column-gap|font-style|overflow-y|text-align|mask-size|line-snap|flex-wrap|nav-right|isolation|flex-grow|flex-flow|translate|line-grid|text-wrap|wrap-flow|min-width|max-width|direction|clip-path|word-wrap|mask-clip|max-lines|mask-type|grid-area|animation|mask-mode|transform|font-size|nav-down|position|overflow|grid-row|tab-size|nav-left|display|row-gap|content|opacity|padding|orphans|outline|columns|hyphens|z-index|margin|border|rotate|filter|resize|quotes|bottom|height|offset|nav-up|cursor|widows|color|inset|order|scale|right|float|width|clear|font|flex|left|mask|clip|page|grid|gap|src|top|all)(?=\s*:)"> + <token type="NameAttribute"/> + <push state="attr"/> + </rule> + <rule pattern="(?<!:\s*)[^ \t:="\[;(),.]+(?=[ \t]*:(?:#{|[^{])+?[;,])"> + <token type="NameAttribute"/> + <push state="attr"/> + </rule> + <rule> + <push state="selector"/> + </rule> + </state> + <state name="for"> + <rule pattern="(from|to|through)"> + <token type="OperatorWord"/> + </rule> + <rule> + <include state="value"/> + </rule> + </state> + <state name="class"> + <rule pattern="[\w-]+"> + <token type="NameClass"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="selector"> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern="\:"> + <token type="NameDecorator"/> + <push state="pseudo-class"/> + </rule> + <rule pattern="\."> + <token type="NameClass"/> + <push state="class"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="\#"> + <token type="NameNamespace"/> + <push state="id"/> + </rule> + <rule pattern="&"> + <token type="Keyword"/> + </rule> + <rule pattern="[~^*!&\[\]()<>|+=@:,./?-]"> + <token type="Operator"/> + </rule> + <rule pattern="(%)([\w-]+)"> + <bygroups> + <token type="Operator"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string-double"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <push state="string-single"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="[;{}]"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="[\w-]+"> + <token type="NameTag"/> + </rule> + </state> + <state name="string-url"> + <rule pattern="(\\#|#(?=[^\n{])|[^\n#)])+"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule pattern="\)"> + <token type="LiteralStringOther"/> + <pop depth="1"/> + </rule> + </state> + <state name="pseudo-class"> + <rule pattern="[\w-]+"> + <token type="NameDecorator"/> + </rule> + <rule pattern="#\{"> + <token type="LiteralStringInterpol"/> + <push state="interpolation"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sieve.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sieve.xml new file mode 100644 index 0000000..fc60563 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sieve.xml @@ -0,0 +1,61 @@ +<lexer> + <config> + <name>Sieve</name> + <alias>sieve</alias> + <filename>*.siv</filename> + <filename>*.sieve</filename> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[();,{}\[\]]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?i)require"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="(?i)(:)(addresses|all|contains|content|create|copy|comparator|count|days|detail|domain|fcc|flags|from|handle|importance|is|localpart|length|lowerfirst|lower|matches|message|mime|options|over|percent|quotewildcard|raw|regex|specialuse|subject|text|under|upperfirst|upper|value)"> + <bygroups> + <token type="NameTag"/> + <token type="NameTag"/> + </bygroups> + </rule> + <rule pattern="(?i)(address|addflag|allof|anyof|body|discard|elsif|else|envelope|ereject|exists|false|fileinto|if|hasflag|header|keep|notify_method_capability|notify|not|redirect|reject|removeflag|setflag|size|spamtest|stop|string|true|vacation|virustest)"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?i)set"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="([0-9.]+)([kmgKMG])?"> + <bygroups> + <token type="LiteralNumber"/> + <token type="LiteralNumber"/> + </bygroups> + </rule> + <rule pattern="#.*$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*.*\*/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern=""[^"]*?""> + <token type="LiteralString"/> + </rule> + <rule pattern="text:"> + <token type="NameTag"/> + <push state="text"/> + </rule> + </state> + <state name="text"> + <rule pattern="[^.].*?\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="^\."> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/smalltalk.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/smalltalk.xml new file mode 100644 index 0000000..0027111 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/smalltalk.xml @@ -0,0 +1,294 @@ +<lexer> + <config> + <name>Smalltalk</name> + <alias>smalltalk</alias> + <alias>squeak</alias> + <alias>st</alias> + <filename>*.st</filename> + <mime_type>text/x-smalltalk</mime_type> + </config> + <rules> + <state name="inner_parenth"> + <rule pattern="\)"> + <token type="LiteralStringSymbol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="_parenth_helper"/> + </rule> + </state> + <state name="objects"> + <rule pattern="\["> + <token type="Text"/> + <push state="blockvariables"/> + </rule> + <rule pattern="\]"> + <token type="Text"/> + <push state="afterobject"/> + </rule> + <rule pattern="\b(self|super|true|false|nil|thisContext)\b"> + <token type="NameBuiltinPseudo"/> + <push state="afterobject"/> + </rule> + <rule pattern="\b[A-Z]\w*(?!:)\b"> + <token type="NameClass"/> + <push state="afterobject"/> + </rule> + <rule pattern="\b[a-z]\w*(?!:)\b"> + <token type="NameVariable"/> + <push state="afterobject"/> + </rule> + <rule pattern="#("(""|[^"])*"|[-+*/\\~<>=|&!?,@%]+|[\w:]+)"> + <token type="LiteralStringSymbol"/> + <push state="afterobject"/> + </rule> + <rule> + <include state="literals"/> + </rule> + </state> + <state name="afterobject"> + <rule pattern="! !$"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <include state="whitespaces"/> + </rule> + <rule pattern="\b(ifTrue:|ifFalse:|whileTrue:|whileFalse:|timesRepeat:)"> + <token type="NameBuiltin"/> + <pop depth="1"/> + </rule> + <rule pattern="\b(new\b(?!:))"> + <token type="NameBuiltin"/> + </rule> + <rule pattern=":=|_"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule pattern="\b[a-zA-Z]+\w*:"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule pattern="\b[a-zA-Z]+\w*"> + <token type="NameFunction"/> + </rule> + <rule pattern="\w+:?|[-+*/\\~<>=|&!?,@%]+"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule pattern="\."> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + </rule> + <rule pattern="[\])}]"> + <token type="Text"/> + </rule> + <rule pattern="[\[({]"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="literals"> + <rule pattern="'(''|[^'])*'"> + <token type="LiteralString"/> + <push state="afterobject"/> + </rule> + <rule pattern="\$."> + <token type="LiteralStringChar"/> + <push state="afterobject"/> + </rule> + <rule pattern="#\("> + <token type="LiteralStringSymbol"/> + <push state="parenth"/> + </rule> + <rule pattern="\)"> + <token type="Text"/> + <push state="afterobject"/> + </rule> + <rule pattern="(\d+r)?-?\d+(\.\d+)?(e-?\d+)?"> + <token type="LiteralNumber"/> + <push state="afterobject"/> + </rule> + </state> + <state name="root"> + <rule pattern="(<)(\w+:)(.*?)(>)"> + <bygroups> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="Text"/> + </bygroups> + </rule> + <rule> + <include state="squeak fileout"/> + </rule> + <rule> + <include state="whitespaces"/> + </rule> + <rule> + <include state="method definition"/> + </rule> + <rule pattern="(\|)([\w\s]*)(\|)"> + <bygroups> + <token type="Operator"/> + <token type="NameVariable"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule> + <include state="objects"/> + </rule> + <rule pattern="\^|:=|_"> + <token type="Operator"/> + </rule> + <rule pattern="[\]({}.;!]"> + <token type="Text"/> + </rule> + </state> + <state name="_parenth_helper"> + <rule> + <include state="whitespaces"/> + </rule> + <rule pattern="(\d+r)?-?\d+(\.\d+)?(e-?\d+)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[-+*/\\~<>=|&#!?,@%\w:]+"> + <token type="LiteralStringSymbol"/> + </rule> + <rule pattern="'(''|[^'])*'"> + <token type="LiteralString"/> + </rule> + <rule pattern="\$."> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="#*\("> + <token type="LiteralStringSymbol"/> + <push state="inner_parenth"/> + </rule> + </state> + <state name="parenth"> + <rule pattern="\)"> + <token type="LiteralStringSymbol"/> + <push state="root" state="afterobject"/> + </rule> + <rule> + <include state="_parenth_helper"/> + </rule> + </state> + <state name="whitespaces"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern=""(""|[^"])*""> + <token type="Comment"/> + </rule> + </state> + <state name="squeak fileout"> + <rule pattern="^"(""|[^"])*"!"> + <token type="Keyword"/> + </rule> + <rule pattern="^'(''|[^'])*'!"> + <token type="Keyword"/> + </rule> + <rule pattern="^(!)(\w+)( commentStamp: )(.*?)( prior: .*?!\n)(.*?)(!)"> + <bygroups> + <token type="Keyword"/> + <token type="NameClass"/> + <token type="Keyword"/> + <token type="LiteralString"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="^(!)(\w+(?: class)?)( methodsFor: )('(?:''|[^'])*')(.*?!)"> + <bygroups> + <token type="Keyword"/> + <token type="NameClass"/> + <token type="Keyword"/> + <token type="LiteralString"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="^(\w+)( subclass: )(#\w+)(\s+instanceVariableNames: )(.*?)(\s+classVariableNames: )(.*?)(\s+poolDictionaries: )(.*?)(\s+category: )(.*?)(!)"> + <bygroups> + <token type="NameClass"/> + <token type="Keyword"/> + <token type="LiteralStringSymbol"/> + <token type="Keyword"/> + <token type="LiteralString"/> + <token type="Keyword"/> + <token type="LiteralString"/> + <token type="Keyword"/> + <token type="LiteralString"/> + <token type="Keyword"/> + <token type="LiteralString"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="^(\w+(?: class)?)(\s+instanceVariableNames: )(.*?)(!)"> + <bygroups> + <token type="NameClass"/> + <token type="Keyword"/> + <token type="LiteralString"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(!\n)(\].*)(! !)$"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="! !$"> + <token type="Keyword"/> + </rule> + </state> + <state name="method definition"> + <rule pattern="([a-zA-Z]+\w*:)(\s*)(\w+)"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="^(\b[a-zA-Z]+\w*\b)(\s*)$"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="^([-+*/\\~<>=|&!?,@%]+)(\s*)(\w+)(\s*)$"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + <token type="NameVariable"/> + <token type="Text"/> + </bygroups> + </rule> + </state> + <state name="blockvariables"> + <rule> + <include state="whitespaces"/> + </rule> + <rule pattern="(:)(\s*)(\w+)"> + <bygroups> + <token type="Operator"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="\|"> + <token type="Operator"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/snobol.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/snobol.xml new file mode 100644 index 0000000..f53dbcb --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/snobol.xml @@ -0,0 +1,95 @@ +<lexer> + <config> + <name>Snobol</name> + <alias>snobol</alias> + <filename>*.snobol</filename> + <mime_type>text/x-snobol</mime_type> + </config> + <rules> + <state name="heredoc"> + <rule pattern=".*\n"> + <token type="LiteralStringHeredoc"/> + </rule> + </state> + <state name="root"> + <rule pattern="\*.*\n"> + <token type="Comment"/> + </rule> + <rule pattern="[+.] "> + <token type="Punctuation"/> + <push state="statement"/> + </rule> + <rule pattern="-.*\n"> + <token type="Comment"/> + </rule> + <rule pattern="END\s*\n"> + <token type="NameLabel"/> + <push state="heredoc"/> + </rule> + <rule pattern="[A-Za-z$][\w$]*"> + <token type="NameLabel"/> + <push state="statement"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + <push state="statement"/> + </rule> + </state> + <state name="statement"> + <rule pattern="\s*\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(?<=[^\w.])(LT|LE|EQ|NE|GE|GT|INTEGER|IDENT|DIFFER|LGT|SIZE|REPLACE|TRIM|DUPL|REMDR|DATE|TIME|EVAL|APPLY|OPSYN|LOAD|UNLOAD|LEN|SPAN|BREAK|ANY|NOTANY|TAB|RTAB|REM|POS|RPOS|FAIL|FENCE|ABORT|ARB|ARBNO|BAL|SUCCEED|INPUT|OUTPUT|TERMINAL)(?=[^\w.])"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[A-Za-z][\w.]*"> + <token type="Name"/> + </rule> + <rule pattern="\*\*|[?$.!%*/#+\-@|&\\=]"> + <token type="Operator"/> + </rule> + <rule pattern=""[^"]*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'[^']*'"> + <token type="LiteralString"/> + </rule> + <rule pattern="[0-9]+(?=[^.EeDd])"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[0-9]+(\.[0-9]*)?([EDed][-+]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + <push state="goto"/> + </rule> + <rule pattern="[()<>,;]"> + <token type="Punctuation"/> + </rule> + </state> + <state name="goto"> + <rule pattern="\s*\n"> + <token type="Text"/> + <pop depth="2"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="F|S"> + <token type="Keyword"/> + </rule> + <rule pattern="(\()([A-Za-z][\w.]*)(\))"> + <bygroups> + <token type="Punctuation"/> + <token type="NameLabel"/> + <token type="Punctuation"/> + </bygroups> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/solidity.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/solidity.xml new file mode 100644 index 0000000..04403c8 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/solidity.xml @@ -0,0 +1,279 @@ +<lexer> + <config> + <name>Solidity</name> + <alias>sol</alias> + <alias>solidity</alias> + <filename>*.sol</filename> + <dot_all>true</dot_all> + </config> + <rules> + <state name="strings"> + <rule pattern="hex'[0-9a-fA-F]+'"> + <token type="LiteralString"/> + </rule> + <rule pattern="hex"[0-9a-fA-F]+""> + <token type="LiteralString"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <combined state="string-parse-common" state="string-parse-double"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <combined state="string-parse-common" state="string-parse-single"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="0[xX][0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="comments"/> + </rule> + <rule> + <include state="keywords-types"/> + </rule> + <rule> + <include state="keywords-other"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule> + <include state="strings"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\+\+|--|\*\*|\?|:|~|&&|\|\||=>|==?|!=?|(<<|>>>?|[-<>+*%&|^/])=?"> + <token type="Operator"/> + </rule> + <rule pattern="[{(\[;,]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[})\].]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(abi|block|msg|tx)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?!abi\.)(decode|encode|encodePacked|encodeWithSelector|encodeWithSignature|encodeWithSelector)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?!block\.)(chainid|coinbase|difficulty|gaslimit|number|timestamp)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?!msg\.)(data|gas|sender|value)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?!tx\.)(gasprice|origin)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(type)(\()([a-zA-Z_]\w*)(\))"> + <bygroups> + <token type="NameBuiltin"/> + <token type="Punctuation"/> + <token type="NameClass"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(?!type\([a-zA-Z_]\w*\)\.)(creationCode|interfaceId|max|min|name|runtimeCode)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(now|this|super|gasleft)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(selfdestruct|suicide)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?!0x[0-9a-fA-F]+\.)(balance|code|codehash|send|transfer)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(assert|revert|require)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(call|callcode|delegatecall)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="selector\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(addmod|blockhash|ecrecover|keccak256|mulmod|ripemd160|sha256|sha3)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="keywords-types"> + <rule pattern="(address|ufixed|string|bytes|fixed|byte|bool|uint|int)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(int160|int248|int240|int232|int224|int216|int208|int200|int192|int184|int176|int168|int104|int112|int120|int128|int136|int144|int152|int256|int96|int88|int80|int72|int64|int56|int48|int40|int32|int24|int16|int8)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(uint160|uint248|uint240|uint232|uint224|uint216|uint208|uint200|uint192|uint184|uint176|uint168|uint104|uint112|uint120|uint128|uint136|uint144|uint152|uint256|uint96|uint88|uint80|uint72|uint64|uint56|uint48|uint40|uint32|uint24|uint16|uint8)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(bytes23|bytes31|bytes30|bytes29|bytes28|bytes27|bytes26|bytes25|bytes24|bytes10|bytes11|bytes12|bytes13|bytes14|bytes15|bytes16|bytes17|bytes18|bytes19|bytes20|bytes21|bytes22|bytes32|bytes9|bytes8|bytes7|bytes6|bytes5|bytes4|bytes3|bytes2|bytes1)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(fixed104x17|fixed240x16|fixed240x15|fixed240x14|fixed240x13|fixed240x12|fixed240x11|fixed240x10|fixed232x24|fixed232x23|fixed232x22|fixed232x21|fixed232x20|fixed232x19|fixed232x18|fixed232x17|fixed232x16|fixed232x15|fixed232x14|fixed232x13|fixed232x12|fixed232x11|fixed232x10|fixed224x32|fixed224x31|fixed224x30|fixed224x29|fixed224x28|fixed224x27|fixed224x26|fixed224x25|fixed224x24|fixed224x23|fixed224x22|fixed224x21|fixed224x20|fixed224x19|fixed224x18|fixed224x17|fixed224x16|fixed224x15|fixed224x14|fixed224x13|fixed224x12|fixed224x11|fixed224x10|fixed216x40|fixed216x39|fixed216x38|fixed216x37|fixed216x36|fixed216x35|fixed216x34|fixed216x33|fixed216x32|fixed216x31|fixed216x30|fixed216x29|fixed216x28|fixed216x27|fixed216x26|fixed216x25|fixed216x24|fixed216x23|fixed216x22|fixed216x21|fixed216x20|fixed216x19|fixed216x18|fixed216x17|fixed216x16|fixed216x15|fixed216x14|fixed216x13|fixed216x12|fixed216x11|fixed216x10|fixed208x48|fixed208x47|fixed208x46|fixed208x45|fixed208x44|fixed208x43|fixed208x42|fixed208x41|fixed208x40|fixed208x39|fixed208x38|fixed208x37|fixed208x36|fixed208x35|fixed208x34|fixed208x33|fixed208x32|fixed208x31|fixed208x30|fixed208x29|fixed208x28|fixed208x27|fixed208x26|fixed208x25|fixed208x24|fixed208x23|fixed208x22|fixed208x21|fixed208x20|fixed208x19|fixed208x18|fixed208x17|fixed208x16|fixed208x15|fixed208x14|fixed208x13|fixed208x12|fixed208x11|fixed208x10|fixed200x56|fixed200x55|fixed200x54|fixed200x53|fixed200x52|fixed200x51|fixed200x50|fixed200x49|fixed200x48|fixed200x47|fixed200x46|fixed200x45|fixed200x44|fixed200x43|fixed200x42|fixed200x41|fixed200x40|fixed200x39|fixed200x38|fixed200x37|fixed200x36|fixed200x35|fixed200x34|fixed200x33|fixed200x32|fixed200x31|fixed200x30|fixed200x29|fixed200x28|fixed200x27|fixed200x26|fixed200x25|fixed200x24|fixed200x23|fixed200x22|fixed200x21|fixed200x20|fixed200x19|fixed200x18|fixed200x17|fixed200x16|fixed200x15|fixed200x14|fixed200x13|fixed200x12|fixed200x11|fixed200x10|fixed192x64|fixed192x63|fixed192x62|fixed192x61|fixed192x60|fixed192x59|fixed192x58|fixed192x57|fixed192x56|fixed192x55|fixed192x54|fixed192x53|fixed192x52|fixed192x51|fixed192x50|fixed192x49|fixed192x48|fixed192x47|fixed192x46|fixed192x45|fixed192x44|fixed192x43|fixed192x42|fixed192x41|fixed192x40|fixed192x39|fixed192x38|fixed192x37|fixed192x36|fixed192x35|fixed192x34|fixed192x33|fixed192x32|fixed192x31|fixed192x30|fixed192x29|fixed192x28|fixed192x27|fixed192x26|fixed192x25|fixed192x24|fixed192x23|fixed192x22|fixed192x21|fixed192x20|fixed192x19|fixed192x18|fixed192x17|fixed192x16|fixed192x15|fixed192x14|fixed192x13|fixed192x12|fixed192x11|fixed192x10|fixed184x72|fixed184x71|fixed184x70|fixed184x69|fixed184x68|fixed184x67|fixed184x66|fixed184x65|fixed184x64|fixed184x63|fixed184x62|fixed184x61|fixed184x60|fixed184x59|fixed184x58|fixed184x57|fixed184x56|fixed184x55|fixed184x54|fixed184x53|fixed184x52|fixed184x51|fixed184x50|fixed184x49|fixed184x48|fixed184x47|fixed184x46|fixed184x45|fixed184x44|fixed184x43|fixed184x42|fixed184x41|fixed184x40|fixed184x39|fixed184x38|fixed184x37|fixed184x36|fixed184x35|fixed184x34|fixed184x33|fixed184x32|fixed184x31|fixed184x30|fixed184x29|fixed184x28|fixed184x27|fixed184x26|fixed184x25|fixed184x24|fixed184x23|fixed184x22|fixed184x21|fixed184x20|fixed184x19|fixed184x18|fixed184x17|fixed184x16|fixed184x15|fixed184x14|fixed184x13|fixed184x12|fixed184x11|fixed184x10|fixed176x80|fixed176x79|fixed176x78|fixed176x77|fixed176x76|fixed176x75|fixed176x74|fixed176x73|fixed176x72|fixed176x71|fixed176x70|fixed176x69|fixed176x68|fixed176x67|fixed176x66|fixed176x65|fixed176x64|fixed176x63|fixed176x62|fixed176x61|fixed176x60|fixed176x59|fixed176x58|fixed176x57|fixed176x56|fixed176x55|fixed176x54|fixed176x53|fixed176x52|fixed176x51|fixed176x50|fixed176x49|fixed176x48|fixed176x47|fixed176x46|fixed176x45|fixed176x44|fixed176x43|fixed176x42|fixed176x41|fixed176x40|fixed176x39|fixed176x38|fixed176x37|fixed176x36|fixed176x35|fixed176x34|fixed176x33|fixed176x32|fixed176x31|fixed176x30|fixed176x29|fixed176x28|fixed176x27|fixed176x26|fixed176x25|fixed176x24|fixed176x23|fixed176x22|fixed176x21|fixed176x20|fixed176x19|fixed176x18|fixed176x17|fixed176x16|fixed176x15|fixed176x14|fixed176x13|fixed176x12|fixed176x11|fixed176x10|fixed168x80|fixed168x79|fixed168x78|fixed168x77|fixed168x76|fixed168x75|fixed168x74|fixed168x73|fixed168x72|fixed168x71|fixed168x70|fixed168x69|fixed168x68|fixed168x67|fixed168x66|fixed168x65|fixed168x64|fixed168x63|fixed168x62|fixed168x61|fixed168x60|fixed168x59|fixed168x58|fixed168x57|fixed168x56|fixed168x55|fixed168x54|fixed168x53|fixed168x52|fixed168x51|fixed168x50|fixed168x49|fixed168x48|fixed168x47|fixed168x46|fixed168x45|fixed168x44|fixed168x43|fixed168x42|fixed168x41|fixed168x40|fixed168x39|fixed168x38|fixed168x37|fixed168x36|fixed168x35|fixed168x34|fixed168x33|fixed168x32|fixed168x31|fixed168x30|fixed168x29|fixed168x28|fixed168x27|fixed168x26|fixed168x25|fixed168x24|fixed168x23|fixed168x22|fixed168x21|fixed168x20|fixed168x19|fixed168x18|fixed168x17|fixed168x16|fixed168x15|fixed168x14|fixed168x13|fixed168x12|fixed168x11|fixed168x10|fixed160x80|fixed160x79|fixed160x78|fixed160x77|fixed160x76|fixed160x75|fixed160x73|fixed160x72|fixed160x71|fixed160x70|fixed160x69|fixed160x68|fixed160x67|fixed160x66|fixed160x65|fixed160x64|fixed160x63|fixed160x62|fixed160x61|fixed160x60|fixed160x59|fixed160x58|fixed160x57|fixed160x56|fixed160x55|fixed160x54|fixed160x53|fixed160x52|fixed160x51|fixed160x50|fixed160x49|fixed160x48|fixed160x47|fixed160x46|fixed160x45|fixed160x44|fixed160x43|fixed160x42|fixed160x41|fixed160x40|fixed160x39|fixed160x38|fixed160x37|fixed160x36|fixed160x35|fixed160x34|fixed160x33|fixed160x32|fixed160x31|fixed160x30|fixed160x29|fixed160x28|fixed160x27|fixed160x26|fixed160x25|fixed160x24|fixed160x23|fixed160x22|fixed160x21|fixed160x20|fixed160x19|fixed160x18|fixed160x17|fixed160x16|fixed160x15|fixed160x14|fixed160x13|fixed160x12|fixed160x11|fixed160x10|fixed152x80|fixed152x79|fixed152x78|fixed152x77|fixed152x76|fixed152x75|fixed152x74|fixed152x73|fixed152x72|fixed152x71|fixed152x70|fixed152x69|fixed152x68|fixed152x67|fixed152x66|fixed152x65|fixed152x64|fixed152x63|fixed152x62|fixed152x61|fixed152x60|fixed152x59|fixed152x58|fixed152x57|fixed152x56|fixed152x55|fixed152x54|fixed152x53|fixed152x52|fixed152x51|fixed152x50|fixed152x49|fixed152x48|fixed152x47|fixed152x46|fixed152x45|fixed152x44|fixed152x43|fixed152x42|fixed152x41|fixed152x40|fixed152x39|fixed152x38|fixed152x37|fixed152x36|fixed152x35|fixed152x34|fixed152x33|fixed152x32|fixed152x31|fixed152x30|fixed152x29|fixed152x28|fixed152x27|fixed152x26|fixed152x25|fixed152x24|fixed152x23|fixed152x22|fixed152x21|fixed152x20|fixed152x19|fixed152x18|fixed152x17|fixed152x16|fixed152x15|fixed152x14|fixed152x13|fixed152x12|fixed152x11|fixed152x10|fixed144x80|fixed144x79|fixed144x78|fixed144x77|fixed144x76|fixed144x75|fixed144x74|fixed144x73|fixed144x72|fixed144x71|fixed144x70|fixed144x69|fixed144x68|fixed144x67|fixed144x66|fixed144x65|fixed144x64|fixed144x63|fixed144x62|fixed144x61|fixed144x60|fixed144x59|fixed144x58|fixed144x57|fixed144x56|fixed144x55|fixed144x54|fixed144x53|fixed144x52|fixed144x51|fixed144x50|fixed144x49|fixed144x48|fixed144x47|fixed144x46|fixed144x45|fixed144x44|fixed144x43|fixed144x42|fixed144x41|fixed144x40|fixed144x39|fixed144x38|fixed144x37|fixed144x36|fixed144x35|fixed144x34|fixed144x33|fixed144x32|fixed144x31|fixed144x30|fixed144x29|fixed144x28|fixed144x27|fixed144x26|fixed144x25|fixed144x24|fixed144x23|fixed144x22|fixed144x21|fixed144x20|fixed144x19|fixed144x18|fixed144x17|fixed144x16|fixed144x15|fixed144x14|fixed144x13|fixed144x12|fixed144x11|fixed144x10|fixed136x80|fixed136x79|fixed136x78|fixed136x77|fixed136x76|fixed136x75|fixed136x74|fixed136x73|fixed136x72|fixed136x71|fixed136x70|fixed136x69|fixed136x68|fixed136x67|fixed136x66|fixed136x65|fixed136x64|fixed136x63|fixed136x62|fixed136x61|fixed136x60|fixed136x59|fixed136x58|fixed136x57|fixed136x56|fixed136x55|fixed136x54|fixed136x53|fixed136x52|fixed136x51|fixed136x50|fixed136x48|fixed136x47|fixed136x46|fixed136x45|fixed136x44|fixed136x43|fixed136x42|fixed136x41|fixed136x40|fixed136x39|fixed136x38|fixed136x37|fixed136x36|fixed136x35|fixed136x34|fixed136x33|fixed136x32|fixed136x31|fixed136x30|fixed136x29|fixed136x28|fixed136x27|fixed136x26|fixed136x25|fixed136x24|fixed136x23|fixed136x22|fixed136x21|fixed136x20|fixed136x19|fixed136x18|fixed136x17|fixed136x16|fixed136x15|fixed136x14|fixed136x13|fixed136x12|fixed136x11|fixed136x10|fixed128x80|fixed128x79|fixed128x78|fixed128x77|fixed128x76|fixed128x75|fixed128x74|fixed128x73|fixed128x72|fixed128x71|fixed128x70|fixed128x69|fixed128x68|fixed128x67|fixed128x66|fixed128x65|fixed128x64|fixed128x63|fixed128x62|fixed128x61|fixed128x60|fixed128x59|fixed128x58|fixed128x57|fixed128x56|fixed128x55|fixed128x54|fixed128x53|fixed128x52|fixed128x51|fixed128x50|fixed128x49|fixed128x48|fixed128x47|fixed128x46|fixed128x45|fixed128x44|fixed128x43|fixed128x42|fixed128x41|fixed128x40|fixed128x39|fixed128x38|fixed128x37|fixed128x36|fixed128x35|fixed128x34|fixed128x33|fixed128x32|fixed128x31|fixed128x30|fixed128x29|fixed128x28|fixed128x27|fixed128x26|fixed128x25|fixed128x24|fixed128x23|fixed128x22|fixed128x21|fixed128x20|fixed128x19|fixed128x18|fixed128x17|fixed128x16|fixed128x15|fixed128x14|fixed128x13|fixed128x12|fixed128x11|fixed128x10|fixed120x80|fixed120x79|fixed120x78|fixed120x77|fixed120x76|fixed120x75|fixed120x74|fixed120x73|fixed120x72|fixed120x71|fixed120x70|fixed120x69|fixed120x68|fixed120x67|fixed120x66|fixed120x65|fixed120x64|fixed120x63|fixed120x62|fixed120x61|fixed120x60|fixed120x59|fixed120x58|fixed120x57|fixed120x56|fixed120x55|fixed120x54|fixed120x53|fixed120x52|fixed120x51|fixed120x50|fixed112x23|fixed120x49|fixed120x48|fixed120x47|fixed120x46|fixed120x45|fixed120x44|fixed120x43|fixed120x42|fixed120x41|fixed120x40|fixed120x39|fixed120x38|fixed120x37|fixed120x36|fixed120x35|fixed120x34|fixed120x33|fixed120x32|fixed120x31|fixed120x30|fixed120x29|fixed120x28|fixed120x27|fixed120x26|fixed120x25|fixed120x24|fixed120x23|fixed120x22|fixed120x21|fixed120x20|fixed120x19|fixed120x18|fixed120x17|fixed120x16|fixed120x15|fixed120x14|fixed120x13|fixed120x12|fixed120x11|fixed120x10|fixed112x80|fixed112x79|fixed112x78|fixed112x77|fixed112x76|fixed112x75|fixed112x74|fixed112x73|fixed112x72|fixed112x71|fixed112x70|fixed112x69|fixed112x68|fixed112x67|fixed112x66|fixed112x65|fixed112x64|fixed112x63|fixed112x62|fixed112x61|fixed112x60|fixed112x59|fixed112x58|fixed112x57|fixed112x56|fixed112x55|fixed112x54|fixed112x53|fixed112x52|fixed112x51|fixed112x50|fixed112x49|fixed112x48|fixed112x47|fixed112x46|fixed112x45|fixed112x44|fixed112x43|fixed112x42|fixed112x41|fixed112x40|fixed112x39|fixed112x38|fixed112x37|fixed112x36|fixed112x35|fixed112x34|fixed112x33|fixed112x32|fixed112x31|fixed112x30|fixed112x29|fixed112x28|fixed112x27|fixed112x26|fixed112x25|fixed112x24|fixed136x49|fixed112x22|fixed112x21|fixed112x20|fixed112x19|fixed112x18|fixed112x17|fixed112x16|fixed112x15|fixed112x14|fixed112x13|fixed112x12|fixed112x11|fixed112x10|fixed104x80|fixed104x79|fixed104x78|fixed104x77|fixed104x76|fixed104x75|fixed104x74|fixed104x73|fixed104x72|fixed104x71|fixed104x70|fixed104x69|fixed104x68|fixed104x67|fixed104x66|fixed104x65|fixed104x64|fixed104x63|fixed104x62|fixed104x61|fixed104x60|fixed104x59|fixed104x58|fixed104x57|fixed104x56|fixed104x55|fixed104x54|fixed104x53|fixed104x52|fixed104x51|fixed104x50|fixed104x49|fixed104x48|fixed104x47|fixed104x46|fixed104x45|fixed104x44|fixed104x43|fixed104x42|fixed104x41|fixed104x40|fixed104x39|fixed104x38|fixed104x37|fixed104x36|fixed104x35|fixed104x34|fixed104x33|fixed104x32|fixed104x31|fixed104x30|fixed104x29|fixed104x28|fixed104x27|fixed104x26|fixed104x25|fixed104x24|fixed104x23|fixed104x22|fixed104x21|fixed104x20|fixed104x19|fixed104x18|fixed104x10|fixed104x11|fixed104x12|fixed104x13|fixed104x14|fixed104x15|fixed104x16|fixed160x74|fixed104x9|fixed104x8|fixed104x7|fixed104x6|fixed104x5|fixed104x4|fixed104x3|fixed104x2|fixed104x1|fixed104x0|fixed96x80|fixed96x79|fixed96x78|fixed96x77|fixed96x76|fixed96x75|fixed96x74|fixed96x73|fixed96x72|fixed96x71|fixed96x70|fixed96x69|fixed96x68|fixed96x67|fixed96x66|fixed96x65|fixed96x64|fixed96x63|fixed96x62|fixed96x61|fixed96x60|fixed96x59|fixed96x58|fixed96x57|fixed96x56|fixed96x55|fixed96x54|fixed96x53|fixed96x52|fixed96x51|fixed96x50|fixed96x49|fixed96x48|fixed96x47|fixed96x46|fixed96x45|fixed96x44|fixed96x43|fixed96x42|fixed96x41|fixed96x40|fixed96x39|fixed96x38|fixed96x37|fixed96x36|fixed96x35|fixed96x34|fixed96x33|fixed96x32|fixed96x31|fixed96x30|fixed96x29|fixed96x28|fixed112x0|fixed112x1|fixed112x2|fixed112x3|fixed112x4|fixed112x5|fixed112x6|fixed112x7|fixed112x8|fixed112x9|fixed96x27|fixed96x26|fixed96x25|fixed96x24|fixed96x23|fixed96x22|fixed96x21|fixed96x20|fixed96x19|fixed96x18|fixed96x17|fixed96x16|fixed96x15|fixed96x14|fixed96x13|fixed96x12|fixed96x11|fixed96x10|fixed248x8|fixed248x7|fixed248x6|fixed248x5|fixed248x4|fixed248x3|fixed248x2|fixed248x1|fixed248x0|fixed240x9|fixed88x80|fixed88x79|fixed88x78|fixed88x77|fixed88x76|fixed88x75|fixed88x74|fixed88x73|fixed88x72|fixed88x71|fixed88x70|fixed88x69|fixed88x68|fixed88x67|fixed88x66|fixed88x65|fixed88x64|fixed88x63|fixed88x62|fixed88x61|fixed88x60|fixed88x59|fixed88x58|fixed88x57|fixed88x56|fixed88x55|fixed88x54|fixed88x53|fixed88x52|fixed88x51|fixed88x50|fixed88x49|fixed88x48|fixed88x47|fixed88x46|fixed88x45|fixed88x44|fixed88x43|fixed88x42|fixed88x41|fixed88x40|fixed88x39|fixed88x38|fixed120x0|fixed120x1|fixed120x2|fixed120x3|fixed120x4|fixed120x5|fixed120x6|fixed120x7|fixed120x8|fixed120x9|fixed88x37|fixed88x36|fixed88x35|fixed88x34|fixed88x33|fixed88x32|fixed88x31|fixed88x30|fixed88x29|fixed88x28|fixed88x27|fixed88x26|fixed88x25|fixed88x24|fixed88x23|fixed88x22|fixed88x21|fixed88x20|fixed88x19|fixed88x18|fixed88x17|fixed88x16|fixed88x15|fixed88x14|fixed88x13|fixed88x12|fixed88x11|fixed88x10|fixed240x8|fixed240x7|fixed240x6|fixed240x5|fixed240x4|fixed240x3|fixed240x2|fixed240x1|fixed240x0|fixed232x9|fixed80x80|fixed80x79|fixed80x77|fixed80x76|fixed80x75|fixed80x74|fixed80x73|fixed80x72|fixed80x71|fixed80x70|fixed80x69|fixed80x68|fixed80x67|fixed80x66|fixed80x65|fixed80x64|fixed80x63|fixed80x62|fixed80x61|fixed80x60|fixed80x59|fixed80x58|fixed80x57|fixed80x56|fixed80x55|fixed80x54|fixed80x53|fixed80x52|fixed80x51|fixed80x50|fixed80x49|fixed80x48|fixed80x47|fixed128x0|fixed128x1|fixed128x2|fixed128x3|fixed128x4|fixed128x5|fixed128x6|fixed128x7|fixed128x8|fixed128x9|fixed80x46|fixed80x45|fixed80x44|fixed80x43|fixed80x42|fixed80x41|fixed80x40|fixed80x39|fixed80x38|fixed80x37|fixed80x36|fixed80x35|fixed80x34|fixed80x33|fixed80x32|fixed80x31|fixed80x30|fixed80x29|fixed80x28|fixed80x27|fixed80x26|fixed80x25|fixed80x24|fixed80x23|fixed80x22|fixed80x21|fixed80x20|fixed80x19|fixed80x18|fixed80x17|fixed80x16|fixed80x15|fixed80x14|fixed80x13|fixed80x12|fixed80x11|fixed80x10|fixed232x8|fixed232x7|fixed232x6|fixed232x5|fixed232x4|fixed232x3|fixed232x2|fixed232x1|fixed232x0|fixed224x9|fixed72x80|fixed72x79|fixed72x78|fixed72x77|fixed72x76|fixed72x75|fixed72x74|fixed72x73|fixed72x72|fixed72x71|fixed72x70|fixed72x69|fixed72x68|fixed72x67|fixed72x66|fixed72x65|fixed72x64|fixed72x63|fixed72x62|fixed72x61|fixed72x60|fixed72x59|fixed72x58|fixed72x57|fixed136x0|fixed136x1|fixed136x2|fixed136x3|fixed136x4|fixed136x5|fixed136x6|fixed136x7|fixed136x8|fixed136x9|fixed72x56|fixed72x55|fixed72x54|fixed72x53|fixed72x52|fixed72x51|fixed72x50|fixed72x49|fixed72x48|fixed72x47|fixed72x46|fixed72x45|fixed72x44|fixed72x43|fixed72x42|fixed72x41|fixed72x40|fixed72x39|fixed72x38|fixed72x37|fixed72x36|fixed72x35|fixed72x34|fixed72x33|fixed72x32|fixed72x31|fixed72x30|fixed72x29|fixed72x28|fixed72x27|fixed72x26|fixed72x25|fixed72x24|fixed72x23|fixed72x22|fixed72x21|fixed72x20|fixed72x19|fixed72x18|fixed80x78|fixed72x17|fixed72x16|fixed72x15|fixed72x14|fixed72x13|fixed72x12|fixed72x11|fixed72x10|fixed224x8|fixed224x7|fixed224x6|fixed224x5|fixed224x4|fixed224x3|fixed224x2|fixed224x1|fixed224x0|fixed216x9|fixed64x80|fixed64x79|fixed64x78|fixed64x77|fixed64x76|fixed64x75|fixed64x74|fixed64x73|fixed64x72|fixed64x71|fixed64x70|fixed64x69|fixed64x68|fixed144x0|fixed144x1|fixed144x2|fixed144x3|fixed144x4|fixed144x5|fixed144x6|fixed144x7|fixed144x8|fixed144x9|fixed64x67|fixed64x66|fixed64x65|fixed64x64|fixed64x63|fixed64x62|fixed64x61|fixed64x60|fixed64x59|fixed64x58|fixed64x57|fixed64x56|fixed64x55|fixed64x54|fixed64x53|fixed64x52|fixed64x51|fixed64x50|fixed64x49|fixed64x48|fixed64x47|fixed64x46|fixed64x45|fixed64x44|fixed64x43|fixed64x42|fixed64x41|fixed64x40|fixed64x39|fixed64x38|fixed64x37|fixed64x36|fixed64x35|fixed64x34|fixed64x33|fixed64x32|fixed64x31|fixed64x30|fixed64x29|fixed64x28|fixed64x27|fixed64x26|fixed64x25|fixed64x24|fixed64x23|fixed64x22|fixed64x21|fixed64x20|fixed64x19|fixed64x18|fixed64x17|fixed64x16|fixed64x15|fixed64x14|fixed64x13|fixed64x12|fixed64x11|fixed64x10|fixed216x8|fixed216x7|fixed216x6|fixed216x5|fixed216x4|fixed216x3|fixed216x2|fixed216x1|fixed216x0|fixed16x10|fixed56x80|fixed56x79|fixed56x78|fixed152x0|fixed152x1|fixed152x2|fixed152x3|fixed152x4|fixed152x5|fixed152x6|fixed152x7|fixed152x8|fixed152x9|fixed56x77|fixed56x76|fixed56x75|fixed56x74|fixed56x73|fixed56x72|fixed56x71|fixed56x70|fixed56x69|fixed56x68|fixed56x67|fixed56x66|fixed56x65|fixed56x64|fixed56x63|fixed56x62|fixed56x61|fixed56x60|fixed56x59|fixed56x58|fixed56x57|fixed56x56|fixed56x55|fixed56x54|fixed56x53|fixed16x11|fixed56x51|fixed56x50|fixed56x49|fixed56x48|fixed56x47|fixed56x46|fixed56x45|fixed56x44|fixed56x43|fixed56x42|fixed56x41|fixed56x40|fixed56x39|fixed56x38|fixed56x37|fixed56x36|fixed56x35|fixed56x34|fixed56x33|fixed56x32|fixed56x31|fixed56x30|fixed56x29|fixed56x28|fixed56x27|fixed56x26|fixed56x25|fixed56x24|fixed56x23|fixed56x22|fixed56x21|fixed56x20|fixed56x19|fixed56x18|fixed56x17|fixed56x16|fixed56x15|fixed56x14|fixed56x13|fixed56x12|fixed56x11|fixed56x10|fixed16x12|fixed16x13|fixed16x14|fixed160x0|fixed160x1|fixed160x2|fixed160x3|fixed160x4|fixed160x5|fixed160x6|fixed160x7|fixed160x8|fixed160x9|fixed16x15|fixed16x16|fixed16x17|fixed16x18|fixed16x19|fixed16x20|fixed16x21|fixed48x80|fixed48x79|fixed48x78|fixed48x77|fixed48x76|fixed48x75|fixed48x74|fixed48x73|fixed48x72|fixed48x71|fixed48x70|fixed48x69|fixed48x68|fixed48x67|fixed48x66|fixed16x53|fixed48x64|fixed48x63|fixed48x62|fixed48x61|fixed48x60|fixed48x59|fixed48x58|fixed48x57|fixed48x56|fixed48x55|fixed48x54|fixed48x53|fixed48x52|fixed48x51|fixed48x50|fixed48x49|fixed48x48|fixed48x47|fixed48x46|fixed48x45|fixed48x44|fixed48x43|fixed48x42|fixed48x41|fixed48x40|fixed48x39|fixed48x38|fixed48x37|fixed48x36|fixed48x35|fixed48x34|fixed48x33|fixed48x32|fixed48x31|fixed48x30|fixed48x29|fixed48x28|fixed48x27|fixed48x26|fixed48x25|fixed48x24|fixed256x0|fixed48x23|fixed48x22|fixed48x21|fixed48x20|fixed48x19|fixed48x18|fixed168x0|fixed168x1|fixed168x2|fixed168x3|fixed168x4|fixed168x5|fixed168x6|fixed168x7|fixed168x8|fixed168x9|fixed48x17|fixed48x16|fixed48x15|fixed48x14|fixed48x13|fixed48x12|fixed48x11|fixed48x10|fixed16x22|fixed16x23|fixed16x24|fixed16x25|fixed16x26|fixed16x27|fixed16x28|fixed16x29|fixed16x30|fixed16x31|fixed40x80|fixed40x79|fixed40x78|fixed40x77|fixed40x76|fixed40x75|fixed40x74|fixed40x73|fixed40x72|fixed40x71|fixed40x70|fixed40x69|fixed40x68|fixed40x67|fixed40x66|fixed40x65|fixed40x64|fixed40x63|fixed40x62|fixed40x61|fixed40x60|fixed40x59|fixed40x58|fixed40x57|fixed40x56|fixed40x55|fixed40x54|fixed40x53|fixed40x52|fixed40x51|fixed40x50|fixed40x49|fixed40x48|fixed40x47|fixed40x46|fixed40x45|fixed40x44|fixed40x43|fixed40x42|fixed40x41|fixed40x40|fixed40x39|fixed40x38|fixed40x37|fixed40x36|fixed40x35|fixed40x34|fixed40x33|fixed40x32|fixed40x31|fixed40x30|fixed40x29|fixed40x28|fixed176x0|fixed176x1|fixed176x2|fixed176x3|fixed176x4|fixed176x5|fixed176x6|fixed176x7|fixed176x8|fixed176x9|fixed40x27|fixed40x26|fixed40x25|fixed40x24|fixed40x23|fixed40x22|fixed40x21|fixed40x20|fixed40x19|fixed40x18|fixed40x17|fixed40x16|fixed40x15|fixed40x14|fixed40x13|fixed40x12|fixed40x11|fixed40x10|fixed16x32|fixed16x33|fixed16x34|fixed208x9|fixed208x8|fixed208x7|fixed208x6|fixed208x5|fixed208x4|fixed208x3|fixed32x80|fixed32x79|fixed32x78|fixed32x77|fixed32x76|fixed32x75|fixed32x74|fixed32x73|fixed32x72|fixed32x71|fixed32x70|fixed32x69|fixed32x68|fixed32x67|fixed32x66|fixed32x65|fixed32x64|fixed32x63|fixed32x62|fixed32x61|fixed32x60|fixed32x59|fixed32x58|fixed32x57|fixed32x56|fixed32x55|fixed32x54|fixed32x53|fixed32x52|fixed32x51|fixed32x50|fixed32x49|fixed32x48|fixed32x47|fixed32x46|fixed32x45|fixed32x44|fixed32x43|fixed32x42|fixed32x41|fixed32x40|fixed32x39|fixed32x38|fixed184x0|fixed184x1|fixed184x2|fixed184x3|fixed184x4|fixed184x5|fixed184x6|fixed184x7|fixed184x8|fixed184x9|fixed32x37|fixed32x36|fixed32x35|fixed32x34|fixed32x33|fixed32x32|fixed32x31|fixed32x30|fixed32x29|fixed32x28|fixed32x27|fixed32x26|fixed32x25|fixed32x24|fixed32x23|fixed32x22|fixed32x21|fixed32x20|fixed32x19|fixed32x18|fixed32x17|fixed32x16|fixed32x15|fixed32x14|fixed32x13|fixed32x12|fixed32x11|fixed32x10|fixed208x2|fixed208x1|fixed208x0|fixed16x35|fixed16x36|fixed16x37|fixed16x38|fixed16x39|fixed16x40|fixed16x41|fixed24x80|fixed24x79|fixed24x78|fixed24x77|fixed24x76|fixed24x75|fixed24x74|fixed24x73|fixed24x72|fixed24x71|fixed24x70|fixed24x69|fixed24x68|fixed24x67|fixed24x66|fixed24x65|fixed24x64|fixed24x63|fixed24x62|fixed24x61|fixed24x60|fixed24x59|fixed24x58|fixed24x57|fixed24x56|fixed192x0|fixed192x1|fixed192x2|fixed192x3|fixed192x4|fixed192x5|fixed192x6|fixed192x7|fixed192x8|fixed192x9|fixed24x55|fixed24x54|fixed24x53|fixed24x52|fixed24x51|fixed24x50|fixed24x49|fixed24x48|fixed24x47|fixed24x46|fixed24x45|fixed24x44|fixed24x43|fixed24x42|fixed24x41|fixed24x40|fixed24x39|fixed24x38|fixed24x37|fixed24x36|fixed24x35|fixed24x34|fixed24x33|fixed24x32|fixed24x31|fixed24x30|fixed24x29|fixed24x28|fixed24x27|fixed24x26|fixed24x25|fixed24x24|fixed24x23|fixed24x22|fixed24x21|fixed24x20|fixed24x19|fixed24x18|fixed24x17|fixed24x16|fixed24x15|fixed24x14|fixed24x13|fixed24x12|fixed24x11|fixed24x10|fixed16x42|fixed16x43|fixed16x44|fixed16x45|fixed16x46|fixed16x47|fixed16x48|fixed16x49|fixed16x50|fixed200x0|fixed200x1|fixed200x2|fixed200x3|fixed200x4|fixed200x5|fixed200x6|fixed200x7|fixed200x8|fixed200x9|fixed16x51|fixed16x80|fixed16x79|fixed16x78|fixed16x77|fixed16x76|fixed16x75|fixed16x74|fixed16x73|fixed16x72|fixed16x71|fixed16x70|fixed16x69|fixed16x68|fixed16x67|fixed16x66|fixed16x65|fixed16x64|fixed16x63|fixed16x62|fixed16x61|fixed16x60|fixed16x59|fixed16x58|fixed16x57|fixed16x56|fixed16x55|fixed16x54|fixed48x65|fixed16x52|fixed56x52|fixed24x1|fixed24x2|fixed24x3|fixed24x4|fixed24x5|fixed24x6|fixed24x7|fixed24x8|fixed24x9|fixed32x0|fixed32x1|fixed32x2|fixed32x3|fixed32x4|fixed32x5|fixed32x6|fixed32x7|fixed32x8|fixed32x9|fixed40x0|fixed40x1|fixed40x2|fixed40x3|fixed40x4|fixed40x5|fixed40x6|fixed40x7|fixed40x8|fixed40x9|fixed48x0|fixed48x1|fixed48x2|fixed48x3|fixed48x4|fixed48x5|fixed48x6|fixed48x7|fixed48x8|fixed48x9|fixed56x0|fixed56x1|fixed56x2|fixed56x3|fixed56x4|fixed56x5|fixed56x6|fixed56x7|fixed56x8|fixed56x9|fixed96x9|fixed64x0|fixed16x9|fixed16x8|fixed16x7|fixed16x6|fixed16x5|fixed16x4|fixed16x3|fixed16x2|fixed16x1|fixed16x0|fixed8x80|fixed8x79|fixed8x78|fixed8x77|fixed64x1|fixed64x2|fixed64x3|fixed64x4|fixed64x5|fixed64x6|fixed64x7|fixed64x8|fixed64x9|fixed72x0|fixed8x76|fixed8x75|fixed8x74|fixed8x73|fixed8x72|fixed8x71|fixed8x70|fixed8x69|fixed8x68|fixed8x67|fixed8x66|fixed8x65|fixed8x64|fixed8x63|fixed8x62|fixed8x61|fixed8x60|fixed8x59|fixed8x58|fixed8x57|fixed96x2|fixed8x55|fixed8x54|fixed8x53|fixed8x52|fixed8x51|fixed8x50|fixed8x49|fixed8x48|fixed8x47|fixed8x46|fixed72x1|fixed72x2|fixed72x3|fixed72x4|fixed72x5|fixed72x6|fixed72x7|fixed72x8|fixed72x9|fixed80x0|fixed8x45|fixed8x44|fixed8x43|fixed8x42|fixed8x41|fixed8x40|fixed8x39|fixed8x38|fixed8x37|fixed8x36|fixed8x35|fixed8x34|fixed8x33|fixed8x32|fixed8x31|fixed8x30|fixed8x29|fixed8x28|fixed8x27|fixed8x26|fixed8x25|fixed8x24|fixed8x23|fixed80x1|fixed80x2|fixed80x3|fixed80x4|fixed80x5|fixed80x6|fixed80x7|fixed80x8|fixed80x9|fixed88x0|fixed8x22|fixed8x21|fixed8x20|fixed8x19|fixed8x18|fixed8x17|fixed8x16|fixed8x15|fixed8x14|fixed8x13|fixed8x12|fixed8x11|fixed8x10|fixed96x8|fixed96x7|fixed88x1|fixed88x2|fixed88x3|fixed88x4|fixed88x5|fixed88x6|fixed88x7|fixed88x8|fixed88x9|fixed96x0|fixed96x6|fixed96x5|fixed96x4|fixed96x3|fixed8x56|fixed96x1|fixed24x0|fixed8x2|fixed8x3|fixed8x4|fixed8x5|fixed8x6|fixed8x7|fixed8x8|fixed8x9|fixed8x0|fixed8x1)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(ufixed104x17|ufixed240x16|ufixed240x15|ufixed240x14|ufixed240x13|ufixed240x12|ufixed240x11|ufixed240x10|ufixed232x24|ufixed232x23|ufixed232x22|ufixed232x21|ufixed232x20|ufixed232x19|ufixed232x18|ufixed232x17|ufixed232x16|ufixed232x15|ufixed232x14|ufixed232x13|ufixed232x12|ufixed232x11|ufixed232x10|ufixed224x32|ufixed224x31|ufixed224x30|ufixed224x29|ufixed224x28|ufixed224x27|ufixed224x26|ufixed224x25|ufixed224x24|ufixed224x23|ufixed224x22|ufixed224x21|ufixed224x20|ufixed224x19|ufixed224x18|ufixed224x17|ufixed224x16|ufixed224x15|ufixed224x14|ufixed224x13|ufixed224x12|ufixed224x11|ufixed224x10|ufixed216x40|ufixed216x39|ufixed216x38|ufixed216x37|ufixed216x36|ufixed216x35|ufixed216x34|ufixed216x33|ufixed216x32|ufixed216x31|ufixed216x30|ufixed216x29|ufixed216x28|ufixed216x27|ufixed216x26|ufixed216x25|ufixed216x24|ufixed216x23|ufixed216x22|ufixed216x21|ufixed216x20|ufixed216x19|ufixed216x18|ufixed216x17|ufixed216x16|ufixed216x15|ufixed216x14|ufixed216x13|ufixed216x12|ufixed216x11|ufixed216x10|ufixed208x48|ufixed208x47|ufixed208x46|ufixed208x45|ufixed208x44|ufixed208x43|ufixed208x42|ufixed208x41|ufixed208x40|ufixed208x39|ufixed208x38|ufixed208x37|ufixed208x36|ufixed208x35|ufixed208x34|ufixed208x33|ufixed208x32|ufixed208x31|ufixed208x30|ufixed208x29|ufixed208x28|ufixed208x27|ufixed208x26|ufixed208x25|ufixed208x24|ufixed208x23|ufixed208x22|ufixed208x21|ufixed208x20|ufixed208x19|ufixed208x18|ufixed208x17|ufixed208x16|ufixed208x15|ufixed208x14|ufixed208x13|ufixed208x12|ufixed208x11|ufixed208x10|ufixed200x56|ufixed200x55|ufixed200x54|ufixed200x53|ufixed200x52|ufixed200x51|ufixed200x50|ufixed200x49|ufixed200x48|ufixed200x47|ufixed200x46|ufixed200x45|ufixed200x44|ufixed200x43|ufixed200x42|ufixed200x41|ufixed200x40|ufixed200x39|ufixed200x38|ufixed200x37|ufixed200x36|ufixed200x35|ufixed200x34|ufixed200x33|ufixed200x32|ufixed200x31|ufixed200x30|ufixed200x29|ufixed200x28|ufixed200x27|ufixed200x26|ufixed200x25|ufixed200x24|ufixed200x23|ufixed200x22|ufixed200x21|ufixed200x20|ufixed200x19|ufixed200x18|ufixed200x17|ufixed200x16|ufixed200x15|ufixed200x14|ufixed200x13|ufixed200x12|ufixed200x11|ufixed200x10|ufixed192x64|ufixed192x63|ufixed192x62|ufixed192x61|ufixed192x60|ufixed192x59|ufixed192x58|ufixed192x57|ufixed192x56|ufixed192x55|ufixed192x54|ufixed192x53|ufixed192x52|ufixed192x51|ufixed192x50|ufixed192x49|ufixed192x48|ufixed192x47|ufixed192x46|ufixed192x45|ufixed192x44|ufixed192x43|ufixed192x42|ufixed192x41|ufixed192x40|ufixed192x39|ufixed192x38|ufixed192x37|ufixed192x36|ufixed192x35|ufixed192x34|ufixed192x33|ufixed192x32|ufixed192x31|ufixed192x30|ufixed192x29|ufixed192x28|ufixed192x27|ufixed192x26|ufixed192x25|ufixed192x24|ufixed192x23|ufixed192x22|ufixed192x21|ufixed192x20|ufixed192x19|ufixed192x18|ufixed192x17|ufixed192x16|ufixed192x15|ufixed192x14|ufixed192x13|ufixed192x12|ufixed192x11|ufixed192x10|ufixed184x72|ufixed184x71|ufixed184x70|ufixed184x69|ufixed184x68|ufixed184x67|ufixed184x66|ufixed184x65|ufixed184x64|ufixed184x63|ufixed184x62|ufixed184x61|ufixed184x60|ufixed184x59|ufixed184x58|ufixed184x57|ufixed184x56|ufixed184x55|ufixed184x54|ufixed184x53|ufixed184x52|ufixed184x51|ufixed184x50|ufixed184x49|ufixed184x48|ufixed184x47|ufixed184x46|ufixed184x45|ufixed184x44|ufixed184x43|ufixed184x42|ufixed184x41|ufixed184x40|ufixed184x39|ufixed184x38|ufixed184x37|ufixed184x36|ufixed184x35|ufixed184x34|ufixed184x33|ufixed184x32|ufixed184x31|ufixed184x30|ufixed184x29|ufixed184x28|ufixed184x27|ufixed184x26|ufixed184x25|ufixed184x24|ufixed184x23|ufixed184x22|ufixed184x21|ufixed184x20|ufixed184x19|ufixed184x18|ufixed184x17|ufixed184x16|ufixed184x15|ufixed184x14|ufixed184x13|ufixed184x12|ufixed184x11|ufixed184x10|ufixed176x80|ufixed176x79|ufixed176x78|ufixed176x77|ufixed176x76|ufixed176x75|ufixed176x74|ufixed176x73|ufixed176x72|ufixed176x71|ufixed176x70|ufixed176x69|ufixed176x68|ufixed176x67|ufixed176x66|ufixed176x65|ufixed176x64|ufixed176x63|ufixed176x62|ufixed176x61|ufixed176x60|ufixed176x59|ufixed176x58|ufixed176x57|ufixed176x56|ufixed176x55|ufixed176x54|ufixed176x53|ufixed176x52|ufixed176x51|ufixed176x50|ufixed176x49|ufixed176x48|ufixed176x47|ufixed176x46|ufixed176x45|ufixed176x44|ufixed176x43|ufixed176x42|ufixed176x41|ufixed176x40|ufixed176x39|ufixed176x38|ufixed176x37|ufixed176x36|ufixed176x35|ufixed176x34|ufixed176x33|ufixed176x32|ufixed176x31|ufixed176x30|ufixed176x29|ufixed176x28|ufixed176x27|ufixed176x26|ufixed176x25|ufixed176x24|ufixed176x23|ufixed176x22|ufixed176x21|ufixed176x20|ufixed176x19|ufixed176x18|ufixed176x17|ufixed176x16|ufixed176x15|ufixed176x14|ufixed176x13|ufixed176x12|ufixed176x11|ufixed176x10|ufixed168x80|ufixed168x79|ufixed168x78|ufixed168x77|ufixed168x76|ufixed168x75|ufixed168x74|ufixed168x73|ufixed168x72|ufixed168x71|ufixed168x70|ufixed168x69|ufixed168x68|ufixed168x67|ufixed168x66|ufixed168x65|ufixed168x64|ufixed168x63|ufixed168x62|ufixed168x61|ufixed168x60|ufixed168x59|ufixed168x58|ufixed168x57|ufixed168x56|ufixed168x55|ufixed168x54|ufixed168x53|ufixed168x52|ufixed168x51|ufixed168x50|ufixed168x49|ufixed168x48|ufixed168x47|ufixed168x46|ufixed168x45|ufixed168x44|ufixed168x43|ufixed168x42|ufixed168x41|ufixed168x40|ufixed168x39|ufixed168x38|ufixed168x37|ufixed168x36|ufixed168x35|ufixed168x34|ufixed168x33|ufixed168x32|ufixed168x31|ufixed168x30|ufixed168x29|ufixed168x28|ufixed168x27|ufixed168x26|ufixed168x25|ufixed168x24|ufixed168x23|ufixed168x22|ufixed168x21|ufixed168x20|ufixed168x19|ufixed168x18|ufixed168x17|ufixed168x16|ufixed168x15|ufixed168x14|ufixed168x13|ufixed168x12|ufixed168x11|ufixed168x10|ufixed160x80|ufixed160x79|ufixed160x78|ufixed160x77|ufixed160x76|ufixed160x75|ufixed160x73|ufixed160x72|ufixed160x71|ufixed160x70|ufixed160x69|ufixed160x68|ufixed160x67|ufixed160x66|ufixed160x65|ufixed160x64|ufixed160x63|ufixed160x62|ufixed160x61|ufixed160x60|ufixed160x59|ufixed160x58|ufixed160x57|ufixed160x56|ufixed160x55|ufixed160x54|ufixed160x53|ufixed160x52|ufixed160x51|ufixed160x50|ufixed160x49|ufixed160x48|ufixed160x47|ufixed160x46|ufixed160x45|ufixed160x44|ufixed160x43|ufixed160x42|ufixed160x41|ufixed160x40|ufixed160x39|ufixed160x38|ufixed160x37|ufixed160x36|ufixed160x35|ufixed160x34|ufixed160x33|ufixed160x32|ufixed160x31|ufixed160x30|ufixed160x29|ufixed160x28|ufixed160x27|ufixed160x26|ufixed160x25|ufixed160x24|ufixed160x23|ufixed160x22|ufixed160x21|ufixed160x20|ufixed160x19|ufixed160x18|ufixed160x17|ufixed160x16|ufixed160x15|ufixed160x14|ufixed160x13|ufixed160x12|ufixed160x11|ufixed160x10|ufixed152x80|ufixed152x79|ufixed152x78|ufixed152x77|ufixed152x76|ufixed152x75|ufixed152x74|ufixed152x73|ufixed152x72|ufixed152x71|ufixed152x70|ufixed152x69|ufixed152x68|ufixed152x67|ufixed152x66|ufixed152x65|ufixed152x64|ufixed152x63|ufixed152x62|ufixed152x61|ufixed152x60|ufixed152x59|ufixed152x58|ufixed152x57|ufixed152x56|ufixed152x55|ufixed152x54|ufixed152x53|ufixed152x52|ufixed152x51|ufixed152x50|ufixed152x49|ufixed152x48|ufixed152x47|ufixed152x46|ufixed152x45|ufixed152x44|ufixed152x43|ufixed152x42|ufixed152x41|ufixed152x40|ufixed152x39|ufixed152x38|ufixed152x37|ufixed152x36|ufixed152x35|ufixed152x34|ufixed152x33|ufixed152x32|ufixed152x31|ufixed152x30|ufixed152x29|ufixed152x28|ufixed152x27|ufixed152x26|ufixed152x25|ufixed152x24|ufixed152x23|ufixed152x22|ufixed152x21|ufixed152x20|ufixed152x19|ufixed152x18|ufixed152x17|ufixed152x16|ufixed152x15|ufixed152x14|ufixed152x13|ufixed152x12|ufixed152x11|ufixed152x10|ufixed144x80|ufixed144x79|ufixed144x78|ufixed144x77|ufixed144x76|ufixed144x75|ufixed144x74|ufixed144x73|ufixed144x72|ufixed144x71|ufixed144x70|ufixed144x69|ufixed144x68|ufixed144x67|ufixed144x66|ufixed144x65|ufixed144x64|ufixed144x63|ufixed144x62|ufixed144x61|ufixed144x60|ufixed144x59|ufixed144x58|ufixed144x57|ufixed144x56|ufixed144x55|ufixed144x54|ufixed144x53|ufixed144x52|ufixed144x51|ufixed144x50|ufixed144x49|ufixed144x48|ufixed144x47|ufixed144x46|ufixed144x45|ufixed144x44|ufixed144x43|ufixed144x42|ufixed144x41|ufixed144x40|ufixed144x39|ufixed144x38|ufixed144x37|ufixed144x36|ufixed144x35|ufixed144x34|ufixed144x33|ufixed144x32|ufixed144x31|ufixed144x30|ufixed144x29|ufixed144x28|ufixed144x27|ufixed144x26|ufixed144x25|ufixed144x24|ufixed144x23|ufixed144x22|ufixed144x21|ufixed144x20|ufixed144x19|ufixed144x18|ufixed144x17|ufixed144x16|ufixed144x15|ufixed144x14|ufixed144x13|ufixed144x12|ufixed144x11|ufixed144x10|ufixed136x80|ufixed136x79|ufixed136x78|ufixed136x77|ufixed136x76|ufixed136x75|ufixed136x74|ufixed136x73|ufixed136x72|ufixed136x71|ufixed136x70|ufixed136x69|ufixed136x68|ufixed136x67|ufixed136x66|ufixed136x65|ufixed136x64|ufixed136x63|ufixed136x62|ufixed136x61|ufixed136x60|ufixed136x59|ufixed136x58|ufixed136x57|ufixed136x56|ufixed136x55|ufixed136x54|ufixed136x53|ufixed136x52|ufixed136x51|ufixed136x50|ufixed136x48|ufixed136x47|ufixed136x46|ufixed136x45|ufixed136x44|ufixed136x43|ufixed136x42|ufixed136x41|ufixed136x40|ufixed136x39|ufixed136x38|ufixed136x37|ufixed136x36|ufixed136x35|ufixed136x34|ufixed136x33|ufixed136x32|ufixed136x31|ufixed136x30|ufixed136x29|ufixed136x28|ufixed136x27|ufixed136x26|ufixed136x25|ufixed136x24|ufixed136x23|ufixed136x22|ufixed136x21|ufixed136x20|ufixed136x19|ufixed136x18|ufixed136x17|ufixed136x16|ufixed136x15|ufixed136x14|ufixed136x13|ufixed136x12|ufixed136x11|ufixed136x10|ufixed128x80|ufixed128x79|ufixed128x78|ufixed128x77|ufixed128x76|ufixed128x75|ufixed128x74|ufixed128x73|ufixed128x72|ufixed128x71|ufixed128x70|ufixed128x69|ufixed128x68|ufixed128x67|ufixed128x66|ufixed128x65|ufixed128x64|ufixed128x63|ufixed128x62|ufixed128x61|ufixed128x60|ufixed128x59|ufixed128x58|ufixed128x57|ufixed128x56|ufixed128x55|ufixed128x54|ufixed128x53|ufixed128x52|ufixed128x51|ufixed128x50|ufixed128x49|ufixed128x48|ufixed128x47|ufixed128x46|ufixed128x45|ufixed128x44|ufixed128x43|ufixed128x42|ufixed128x41|ufixed128x40|ufixed128x39|ufixed128x38|ufixed128x37|ufixed128x36|ufixed128x35|ufixed128x34|ufixed128x33|ufixed128x32|ufixed128x31|ufixed128x30|ufixed128x29|ufixed128x28|ufixed128x27|ufixed128x26|ufixed128x25|ufixed128x24|ufixed128x23|ufixed128x22|ufixed128x21|ufixed128x20|ufixed128x19|ufixed128x18|ufixed128x17|ufixed128x16|ufixed128x15|ufixed128x14|ufixed128x13|ufixed128x12|ufixed128x11|ufixed128x10|ufixed120x80|ufixed120x79|ufixed120x78|ufixed120x77|ufixed120x76|ufixed120x75|ufixed120x74|ufixed120x73|ufixed120x72|ufixed120x71|ufixed120x70|ufixed120x69|ufixed120x68|ufixed120x67|ufixed120x66|ufixed120x65|ufixed120x64|ufixed120x63|ufixed120x62|ufixed120x61|ufixed120x60|ufixed120x59|ufixed120x58|ufixed120x57|ufixed120x56|ufixed120x55|ufixed120x54|ufixed120x53|ufixed120x52|ufixed120x51|ufixed120x50|ufixed112x23|ufixed120x49|ufixed120x48|ufixed120x47|ufixed120x46|ufixed120x45|ufixed120x44|ufixed120x43|ufixed120x42|ufixed120x41|ufixed120x40|ufixed120x39|ufixed120x38|ufixed120x37|ufixed120x36|ufixed120x35|ufixed120x34|ufixed120x33|ufixed120x32|ufixed120x31|ufixed120x30|ufixed120x29|ufixed120x28|ufixed120x27|ufixed120x26|ufixed120x25|ufixed120x24|ufixed120x23|ufixed120x22|ufixed120x21|ufixed120x20|ufixed120x19|ufixed120x18|ufixed120x17|ufixed120x16|ufixed120x15|ufixed120x14|ufixed120x13|ufixed120x12|ufixed120x11|ufixed120x10|ufixed112x80|ufixed112x79|ufixed112x78|ufixed112x77|ufixed112x76|ufixed112x75|ufixed112x74|ufixed112x73|ufixed112x72|ufixed112x71|ufixed112x70|ufixed112x69|ufixed112x68|ufixed112x67|ufixed112x66|ufixed112x65|ufixed112x64|ufixed112x63|ufixed112x62|ufixed112x61|ufixed112x60|ufixed112x59|ufixed112x58|ufixed112x57|ufixed112x56|ufixed112x55|ufixed112x54|ufixed112x53|ufixed112x52|ufixed112x51|ufixed112x50|ufixed112x49|ufixed112x48|ufixed112x47|ufixed112x46|ufixed112x45|ufixed112x44|ufixed112x43|ufixed112x42|ufixed112x41|ufixed112x40|ufixed112x39|ufixed112x38|ufixed112x37|ufixed112x36|ufixed112x35|ufixed112x34|ufixed112x33|ufixed112x32|ufixed112x31|ufixed112x30|ufixed112x29|ufixed112x28|ufixed112x27|ufixed112x26|ufixed112x25|ufixed112x24|ufixed136x49|ufixed112x22|ufixed112x21|ufixed112x20|ufixed112x19|ufixed112x18|ufixed112x17|ufixed112x16|ufixed112x15|ufixed112x14|ufixed112x13|ufixed112x12|ufixed112x11|ufixed112x10|ufixed104x80|ufixed104x79|ufixed104x78|ufixed104x77|ufixed104x76|ufixed104x75|ufixed104x74|ufixed104x73|ufixed104x72|ufixed104x71|ufixed104x70|ufixed104x69|ufixed104x68|ufixed104x67|ufixed104x66|ufixed104x65|ufixed104x64|ufixed104x63|ufixed104x62|ufixed104x61|ufixed104x60|ufixed104x59|ufixed104x58|ufixed104x57|ufixed104x56|ufixed104x55|ufixed104x54|ufixed104x53|ufixed104x52|ufixed104x51|ufixed104x50|ufixed104x49|ufixed104x48|ufixed104x47|ufixed104x46|ufixed104x45|ufixed104x44|ufixed104x43|ufixed104x42|ufixed104x41|ufixed104x40|ufixed104x39|ufixed104x38|ufixed104x37|ufixed104x36|ufixed104x35|ufixed104x34|ufixed104x33|ufixed104x32|ufixed104x31|ufixed104x30|ufixed104x29|ufixed104x28|ufixed104x27|ufixed104x26|ufixed104x25|ufixed104x24|ufixed104x23|ufixed104x22|ufixed104x21|ufixed104x20|ufixed104x19|ufixed104x18|ufixed104x10|ufixed104x11|ufixed104x12|ufixed104x13|ufixed104x14|ufixed104x15|ufixed104x16|ufixed160x74|ufixed104x9|ufixed104x8|ufixed104x7|ufixed104x6|ufixed104x5|ufixed104x4|ufixed104x3|ufixed104x2|ufixed104x1|ufixed104x0|ufixed96x80|ufixed96x79|ufixed96x78|ufixed96x77|ufixed96x76|ufixed96x75|ufixed96x74|ufixed96x73|ufixed96x72|ufixed96x71|ufixed96x70|ufixed96x69|ufixed96x68|ufixed96x67|ufixed96x66|ufixed96x65|ufixed96x64|ufixed96x63|ufixed96x62|ufixed96x61|ufixed96x60|ufixed96x59|ufixed96x58|ufixed96x57|ufixed96x56|ufixed96x55|ufixed96x54|ufixed96x53|ufixed96x52|ufixed96x51|ufixed96x50|ufixed96x49|ufixed96x48|ufixed96x47|ufixed96x46|ufixed96x45|ufixed96x44|ufixed96x43|ufixed96x42|ufixed96x41|ufixed96x40|ufixed96x39|ufixed96x38|ufixed96x37|ufixed96x36|ufixed96x35|ufixed96x34|ufixed96x33|ufixed96x32|ufixed96x31|ufixed96x30|ufixed96x29|ufixed96x28|ufixed112x0|ufixed112x1|ufixed112x2|ufixed112x3|ufixed112x4|ufixed112x5|ufixed112x6|ufixed112x7|ufixed112x8|ufixed112x9|ufixed96x27|ufixed96x26|ufixed96x25|ufixed96x24|ufixed96x23|ufixed96x22|ufixed96x21|ufixed96x20|ufixed96x19|ufixed96x18|ufixed96x17|ufixed96x16|ufixed96x15|ufixed96x14|ufixed96x13|ufixed96x12|ufixed96x11|ufixed96x10|ufixed248x8|ufixed248x7|ufixed248x6|ufixed248x5|ufixed248x4|ufixed248x3|ufixed248x2|ufixed248x1|ufixed248x0|ufixed240x9|ufixed88x80|ufixed88x79|ufixed88x78|ufixed88x77|ufixed88x76|ufixed88x75|ufixed88x74|ufixed88x73|ufixed88x72|ufixed88x71|ufixed88x70|ufixed88x69|ufixed88x68|ufixed88x67|ufixed88x66|ufixed88x65|ufixed88x64|ufixed88x63|ufixed88x62|ufixed88x61|ufixed88x60|ufixed88x59|ufixed88x58|ufixed88x57|ufixed88x56|ufixed88x55|ufixed88x54|ufixed88x53|ufixed88x52|ufixed88x51|ufixed88x50|ufixed88x49|ufixed88x48|ufixed88x47|ufixed88x46|ufixed88x45|ufixed88x44|ufixed88x43|ufixed88x42|ufixed88x41|ufixed88x40|ufixed88x39|ufixed88x38|ufixed120x0|ufixed120x1|ufixed120x2|ufixed120x3|ufixed120x4|ufixed120x5|ufixed120x6|ufixed120x7|ufixed120x8|ufixed120x9|ufixed88x37|ufixed88x36|ufixed88x35|ufixed88x34|ufixed88x33|ufixed88x32|ufixed88x31|ufixed88x30|ufixed88x29|ufixed88x28|ufixed88x27|ufixed88x26|ufixed88x25|ufixed88x24|ufixed88x23|ufixed88x22|ufixed88x21|ufixed88x20|ufixed88x19|ufixed88x18|ufixed88x17|ufixed88x16|ufixed88x15|ufixed88x14|ufixed88x13|ufixed88x12|ufixed88x11|ufixed88x10|ufixed240x8|ufixed240x7|ufixed240x6|ufixed240x5|ufixed240x4|ufixed240x3|ufixed240x2|ufixed240x1|ufixed240x0|ufixed232x9|ufixed80x80|ufixed80x79|ufixed80x77|ufixed80x76|ufixed80x75|ufixed80x74|ufixed80x73|ufixed80x72|ufixed80x71|ufixed80x70|ufixed80x69|ufixed80x68|ufixed80x67|ufixed80x66|ufixed80x65|ufixed80x64|ufixed80x63|ufixed80x62|ufixed80x61|ufixed80x60|ufixed80x59|ufixed80x58|ufixed80x57|ufixed80x56|ufixed80x55|ufixed80x54|ufixed80x53|ufixed80x52|ufixed80x51|ufixed80x50|ufixed80x49|ufixed80x48|ufixed80x47|ufixed128x0|ufixed128x1|ufixed128x2|ufixed128x3|ufixed128x4|ufixed128x5|ufixed128x6|ufixed128x7|ufixed128x8|ufixed128x9|ufixed80x46|ufixed80x45|ufixed80x44|ufixed80x43|ufixed80x42|ufixed80x41|ufixed80x40|ufixed80x39|ufixed80x38|ufixed80x37|ufixed80x36|ufixed80x35|ufixed80x34|ufixed80x33|ufixed80x32|ufixed80x31|ufixed80x30|ufixed80x29|ufixed80x28|ufixed80x27|ufixed80x26|ufixed80x25|ufixed80x24|ufixed80x23|ufixed80x22|ufixed80x21|ufixed80x20|ufixed80x19|ufixed80x18|ufixed80x17|ufixed80x16|ufixed80x15|ufixed80x14|ufixed80x13|ufixed80x12|ufixed80x11|ufixed80x10|ufixed232x8|ufixed232x7|ufixed232x6|ufixed232x5|ufixed232x4|ufixed232x3|ufixed232x2|ufixed232x1|ufixed232x0|ufixed224x9|ufixed72x80|ufixed72x79|ufixed72x78|ufixed72x77|ufixed72x76|ufixed72x75|ufixed72x74|ufixed72x73|ufixed72x72|ufixed72x71|ufixed72x70|ufixed72x69|ufixed72x68|ufixed72x67|ufixed72x66|ufixed72x65|ufixed72x64|ufixed72x63|ufixed72x62|ufixed72x61|ufixed72x60|ufixed72x59|ufixed72x58|ufixed72x57|ufixed136x0|ufixed136x1|ufixed136x2|ufixed136x3|ufixed136x4|ufixed136x5|ufixed136x6|ufixed136x7|ufixed136x8|ufixed136x9|ufixed72x56|ufixed72x55|ufixed72x54|ufixed72x53|ufixed72x52|ufixed72x51|ufixed72x50|ufixed72x49|ufixed72x48|ufixed72x47|ufixed72x46|ufixed72x45|ufixed72x44|ufixed72x43|ufixed72x42|ufixed72x41|ufixed72x40|ufixed72x39|ufixed72x38|ufixed72x37|ufixed72x36|ufixed72x35|ufixed72x34|ufixed72x33|ufixed72x32|ufixed72x31|ufixed72x30|ufixed72x29|ufixed72x28|ufixed72x27|ufixed72x26|ufixed72x25|ufixed72x24|ufixed72x23|ufixed72x22|ufixed72x21|ufixed72x20|ufixed72x19|ufixed72x18|ufixed80x78|ufixed72x17|ufixed72x16|ufixed72x15|ufixed72x14|ufixed72x13|ufixed72x12|ufixed72x11|ufixed72x10|ufixed224x8|ufixed224x7|ufixed224x6|ufixed224x5|ufixed224x4|ufixed224x3|ufixed224x2|ufixed224x1|ufixed224x0|ufixed216x9|ufixed64x80|ufixed64x79|ufixed64x78|ufixed64x77|ufixed64x76|ufixed64x75|ufixed64x74|ufixed64x73|ufixed64x72|ufixed64x71|ufixed64x70|ufixed64x69|ufixed64x68|ufixed144x0|ufixed144x1|ufixed144x2|ufixed144x3|ufixed144x4|ufixed144x5|ufixed144x6|ufixed144x7|ufixed144x8|ufixed144x9|ufixed64x67|ufixed64x66|ufixed64x65|ufixed64x64|ufixed64x63|ufixed64x62|ufixed64x61|ufixed64x60|ufixed64x59|ufixed64x58|ufixed64x57|ufixed64x56|ufixed64x55|ufixed64x54|ufixed64x53|ufixed64x52|ufixed64x51|ufixed64x50|ufixed64x49|ufixed64x48|ufixed64x47|ufixed64x46|ufixed64x45|ufixed64x44|ufixed64x43|ufixed64x42|ufixed64x41|ufixed64x40|ufixed64x39|ufixed64x38|ufixed64x37|ufixed64x36|ufixed64x35|ufixed64x34|ufixed64x33|ufixed64x32|ufixed64x31|ufixed64x30|ufixed64x29|ufixed64x28|ufixed64x27|ufixed64x26|ufixed64x25|ufixed64x24|ufixed64x23|ufixed64x22|ufixed64x21|ufixed64x20|ufixed64x19|ufixed64x18|ufixed64x17|ufixed64x16|ufixed64x15|ufixed64x14|ufixed64x13|ufixed64x12|ufixed64x11|ufixed64x10|ufixed216x8|ufixed216x7|ufixed216x6|ufixed216x5|ufixed216x4|ufixed216x3|ufixed216x2|ufixed216x1|ufixed216x0|ufixed16x10|ufixed56x80|ufixed56x79|ufixed56x78|ufixed152x0|ufixed152x1|ufixed152x2|ufixed152x3|ufixed152x4|ufixed152x5|ufixed152x6|ufixed152x7|ufixed152x8|ufixed152x9|ufixed56x77|ufixed56x76|ufixed56x75|ufixed56x74|ufixed56x73|ufixed56x72|ufixed56x71|ufixed56x70|ufixed56x69|ufixed56x68|ufixed56x67|ufixed56x66|ufixed56x65|ufixed56x64|ufixed56x63|ufixed56x62|ufixed56x61|ufixed56x60|ufixed56x59|ufixed56x58|ufixed56x57|ufixed56x56|ufixed56x55|ufixed56x54|ufixed56x53|ufixed16x11|ufixed56x51|ufixed56x50|ufixed56x49|ufixed56x48|ufixed56x47|ufixed56x46|ufixed56x45|ufixed56x44|ufixed56x43|ufixed56x42|ufixed56x41|ufixed56x40|ufixed56x39|ufixed56x38|ufixed56x37|ufixed56x36|ufixed56x35|ufixed56x34|ufixed56x33|ufixed56x32|ufixed56x31|ufixed56x30|ufixed56x29|ufixed56x28|ufixed56x27|ufixed56x26|ufixed56x25|ufixed56x24|ufixed56x23|ufixed56x22|ufixed56x21|ufixed56x20|ufixed56x19|ufixed56x18|ufixed56x17|ufixed56x16|ufixed56x15|ufixed56x14|ufixed56x13|ufixed56x12|ufixed56x11|ufixed56x10|ufixed16x12|ufixed16x13|ufixed16x14|ufixed160x0|ufixed160x1|ufixed160x2|ufixed160x3|ufixed160x4|ufixed160x5|ufixed160x6|ufixed160x7|ufixed160x8|ufixed160x9|ufixed16x15|ufixed16x16|ufixed16x17|ufixed16x18|ufixed16x19|ufixed16x20|ufixed16x21|ufixed48x80|ufixed48x79|ufixed48x78|ufixed48x77|ufixed48x76|ufixed48x75|ufixed48x74|ufixed48x73|ufixed48x72|ufixed48x71|ufixed48x70|ufixed48x69|ufixed48x68|ufixed48x67|ufixed48x66|ufixed16x53|ufixed48x64|ufixed48x63|ufixed48x62|ufixed48x61|ufixed48x60|ufixed48x59|ufixed48x58|ufixed48x57|ufixed48x56|ufixed48x55|ufixed48x54|ufixed48x53|ufixed48x52|ufixed48x51|ufixed48x50|ufixed48x49|ufixed48x48|ufixed48x47|ufixed48x46|ufixed48x45|ufixed48x44|ufixed48x43|ufixed48x42|ufixed48x41|ufixed48x40|ufixed48x39|ufixed48x38|ufixed48x37|ufixed48x36|ufixed48x35|ufixed48x34|ufixed48x33|ufixed48x32|ufixed48x31|ufixed48x30|ufixed48x29|ufixed48x28|ufixed48x27|ufixed48x26|ufixed48x25|ufixed48x24|ufixed256x0|ufixed48x23|ufixed48x22|ufixed48x21|ufixed48x20|ufixed48x19|ufixed48x18|ufixed168x0|ufixed168x1|ufixed168x2|ufixed168x3|ufixed168x4|ufixed168x5|ufixed168x6|ufixed168x7|ufixed168x8|ufixed168x9|ufixed48x17|ufixed48x16|ufixed48x15|ufixed48x14|ufixed48x13|ufixed48x12|ufixed48x11|ufixed48x10|ufixed16x22|ufixed16x23|ufixed16x24|ufixed16x25|ufixed16x26|ufixed16x27|ufixed16x28|ufixed16x29|ufixed16x30|ufixed16x31|ufixed40x80|ufixed40x79|ufixed40x78|ufixed40x77|ufixed40x76|ufixed40x75|ufixed40x74|ufixed40x73|ufixed40x72|ufixed40x71|ufixed40x70|ufixed40x69|ufixed40x68|ufixed40x67|ufixed40x66|ufixed40x65|ufixed40x64|ufixed40x63|ufixed40x62|ufixed40x61|ufixed40x60|ufixed40x59|ufixed40x58|ufixed40x57|ufixed40x56|ufixed40x55|ufixed40x54|ufixed40x53|ufixed40x52|ufixed40x51|ufixed40x50|ufixed40x49|ufixed40x48|ufixed40x47|ufixed40x46|ufixed40x45|ufixed40x44|ufixed40x43|ufixed40x42|ufixed40x41|ufixed40x40|ufixed40x39|ufixed40x38|ufixed40x37|ufixed40x36|ufixed40x35|ufixed40x34|ufixed40x33|ufixed40x32|ufixed40x31|ufixed40x30|ufixed40x29|ufixed40x28|ufixed176x0|ufixed176x1|ufixed176x2|ufixed176x3|ufixed176x4|ufixed176x5|ufixed176x6|ufixed176x7|ufixed176x8|ufixed176x9|ufixed40x27|ufixed40x26|ufixed40x25|ufixed40x24|ufixed40x23|ufixed40x22|ufixed40x21|ufixed40x20|ufixed40x19|ufixed40x18|ufixed40x17|ufixed40x16|ufixed40x15|ufixed40x14|ufixed40x13|ufixed40x12|ufixed40x11|ufixed40x10|ufixed16x32|ufixed16x33|ufixed16x34|ufixed208x9|ufixed208x8|ufixed208x7|ufixed208x6|ufixed208x5|ufixed208x4|ufixed208x3|ufixed32x80|ufixed32x79|ufixed32x78|ufixed32x77|ufixed32x76|ufixed32x75|ufixed32x74|ufixed32x73|ufixed32x72|ufixed32x71|ufixed32x70|ufixed32x69|ufixed32x68|ufixed32x67|ufixed32x66|ufixed32x65|ufixed32x64|ufixed32x63|ufixed32x62|ufixed32x61|ufixed32x60|ufixed32x59|ufixed32x58|ufixed32x57|ufixed32x56|ufixed32x55|ufixed32x54|ufixed32x53|ufixed32x52|ufixed32x51|ufixed32x50|ufixed32x49|ufixed32x48|ufixed32x47|ufixed32x46|ufixed32x45|ufixed32x44|ufixed32x43|ufixed32x42|ufixed32x41|ufixed32x40|ufixed32x39|ufixed32x38|ufixed184x0|ufixed184x1|ufixed184x2|ufixed184x3|ufixed184x4|ufixed184x5|ufixed184x6|ufixed184x7|ufixed184x8|ufixed184x9|ufixed32x37|ufixed32x36|ufixed32x35|ufixed32x34|ufixed32x33|ufixed32x32|ufixed32x31|ufixed32x30|ufixed32x29|ufixed32x28|ufixed32x27|ufixed32x26|ufixed32x25|ufixed32x24|ufixed32x23|ufixed32x22|ufixed32x21|ufixed32x20|ufixed32x19|ufixed32x18|ufixed32x17|ufixed32x16|ufixed32x15|ufixed32x14|ufixed32x13|ufixed32x12|ufixed32x11|ufixed32x10|ufixed208x2|ufixed208x1|ufixed208x0|ufixed16x35|ufixed16x36|ufixed16x37|ufixed16x38|ufixed16x39|ufixed16x40|ufixed16x41|ufixed24x80|ufixed24x79|ufixed24x78|ufixed24x77|ufixed24x76|ufixed24x75|ufixed24x74|ufixed24x73|ufixed24x72|ufixed24x71|ufixed24x70|ufixed24x69|ufixed24x68|ufixed24x67|ufixed24x66|ufixed24x65|ufixed24x64|ufixed24x63|ufixed24x62|ufixed24x61|ufixed24x60|ufixed24x59|ufixed24x58|ufixed24x57|ufixed24x56|ufixed192x0|ufixed192x1|ufixed192x2|ufixed192x3|ufixed192x4|ufixed192x5|ufixed192x6|ufixed192x7|ufixed192x8|ufixed192x9|ufixed24x55|ufixed24x54|ufixed24x53|ufixed24x52|ufixed24x51|ufixed24x50|ufixed24x49|ufixed24x48|ufixed24x47|ufixed24x46|ufixed24x45|ufixed24x44|ufixed24x43|ufixed24x42|ufixed24x41|ufixed24x40|ufixed24x39|ufixed24x38|ufixed24x37|ufixed24x36|ufixed24x35|ufixed24x34|ufixed24x33|ufixed24x32|ufixed24x31|ufixed24x30|ufixed24x29|ufixed24x28|ufixed24x27|ufixed24x26|ufixed24x25|ufixed24x24|ufixed24x23|ufixed24x22|ufixed24x21|ufixed24x20|ufixed24x19|ufixed24x18|ufixed24x17|ufixed24x16|ufixed24x15|ufixed24x14|ufixed24x13|ufixed24x12|ufixed24x11|ufixed24x10|ufixed16x42|ufixed16x43|ufixed16x44|ufixed16x45|ufixed16x46|ufixed16x47|ufixed16x48|ufixed16x49|ufixed16x50|ufixed200x0|ufixed200x1|ufixed200x2|ufixed200x3|ufixed200x4|ufixed200x5|ufixed200x6|ufixed200x7|ufixed200x8|ufixed200x9|ufixed16x51|ufixed16x80|ufixed16x79|ufixed16x78|ufixed16x77|ufixed16x76|ufixed16x75|ufixed16x74|ufixed16x73|ufixed16x72|ufixed16x71|ufixed16x70|ufixed16x69|ufixed16x68|ufixed16x67|ufixed16x66|ufixed16x65|ufixed16x64|ufixed16x63|ufixed16x62|ufixed16x61|ufixed16x60|ufixed16x59|ufixed16x58|ufixed16x57|ufixed16x56|ufixed16x55|ufixed16x54|ufixed48x65|ufixed16x52|ufixed56x52|ufixed24x1|ufixed24x2|ufixed24x3|ufixed24x4|ufixed24x5|ufixed24x6|ufixed24x7|ufixed24x8|ufixed24x9|ufixed32x0|ufixed32x1|ufixed32x2|ufixed32x3|ufixed32x4|ufixed32x5|ufixed32x6|ufixed32x7|ufixed32x8|ufixed32x9|ufixed40x0|ufixed40x1|ufixed40x2|ufixed40x3|ufixed40x4|ufixed40x5|ufixed40x6|ufixed40x7|ufixed40x8|ufixed40x9|ufixed48x0|ufixed48x1|ufixed48x2|ufixed48x3|ufixed48x4|ufixed48x5|ufixed48x6|ufixed48x7|ufixed48x8|ufixed48x9|ufixed56x0|ufixed56x1|ufixed56x2|ufixed56x3|ufixed56x4|ufixed56x5|ufixed56x6|ufixed56x7|ufixed56x8|ufixed56x9|ufixed96x9|ufixed64x0|ufixed16x9|ufixed16x8|ufixed16x7|ufixed16x6|ufixed16x5|ufixed16x4|ufixed16x3|ufixed16x2|ufixed16x1|ufixed16x0|ufixed8x80|ufixed8x79|ufixed8x78|ufixed8x77|ufixed64x1|ufixed64x2|ufixed64x3|ufixed64x4|ufixed64x5|ufixed64x6|ufixed64x7|ufixed64x8|ufixed64x9|ufixed72x0|ufixed8x76|ufixed8x75|ufixed8x74|ufixed8x73|ufixed8x72|ufixed8x71|ufixed8x70|ufixed8x69|ufixed8x68|ufixed8x67|ufixed8x66|ufixed8x65|ufixed8x64|ufixed8x63|ufixed8x62|ufixed8x61|ufixed8x60|ufixed8x59|ufixed8x58|ufixed8x57|ufixed96x2|ufixed8x55|ufixed8x54|ufixed8x53|ufixed8x52|ufixed8x51|ufixed8x50|ufixed8x49|ufixed8x48|ufixed8x47|ufixed8x46|ufixed72x1|ufixed72x2|ufixed72x3|ufixed72x4|ufixed72x5|ufixed72x6|ufixed72x7|ufixed72x8|ufixed72x9|ufixed80x0|ufixed8x45|ufixed8x44|ufixed8x43|ufixed8x42|ufixed8x41|ufixed8x40|ufixed8x39|ufixed8x38|ufixed8x37|ufixed8x36|ufixed8x35|ufixed8x34|ufixed8x33|ufixed8x32|ufixed8x31|ufixed8x30|ufixed8x29|ufixed8x28|ufixed8x27|ufixed8x26|ufixed8x25|ufixed8x24|ufixed8x23|ufixed80x1|ufixed80x2|ufixed80x3|ufixed80x4|ufixed80x5|ufixed80x6|ufixed80x7|ufixed80x8|ufixed80x9|ufixed88x0|ufixed8x22|ufixed8x21|ufixed8x20|ufixed8x19|ufixed8x18|ufixed8x17|ufixed8x16|ufixed8x15|ufixed8x14|ufixed8x13|ufixed8x12|ufixed8x11|ufixed8x10|ufixed96x8|ufixed96x7|ufixed88x1|ufixed88x2|ufixed88x3|ufixed88x4|ufixed88x5|ufixed88x6|ufixed88x7|ufixed88x8|ufixed88x9|ufixed96x0|ufixed96x6|ufixed96x5|ufixed96x4|ufixed96x3|ufixed8x56|ufixed96x1|ufixed24x0|ufixed8x2|ufixed8x3|ufixed8x4|ufixed8x5|ufixed8x6|ufixed8x7|ufixed8x8|ufixed8x9|ufixed8x0|ufixed8x1)\b"> + <token type="KeywordType"/> + </rule> + </state> + <state name="string-parse-double"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + </rule> + </state> + <state name="string-parse-single"> + <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="keywords-other"> + <rule pattern="(continue|returns|storage|memory|delete|return|throw|break|catch|while|else|from|new|try|for|if|is|as|do|in|_)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="assembly\b"> + <token type="Keyword"/> + <push state="assembly"/> + </rule> + <rule pattern="(contract|interface|enum|event|struct)(\s+)([a-zA-Z_]\w*)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="(function|modifier)(\s+)([a-zA-Z_]\w*)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="(constructor|interface|contract|modifier|function|library|mapping|struct|event|enum|var)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(abstract|external|internal|private|public)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(anonymous|immutable|constant|override|indexed|payable|virtual|pure|view)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(import|using)\b"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="pragma (solidity|experimental)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(relocatable|implements|unchecked|reference|supports|typedef|promise|default|partial|mutable|switch|typeof|sealed|inline|copyof|define|static|sizeof|alias|final|match|apply|macro|after|auto|null|case|let|of)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(wei|finney|szabo|ether)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(seconds|minutes|hours|days|weeks|years)\b"> + <token type="KeywordConstant"/> + </rule> + </state> + <state name="comments"> + <rule pattern="//([\w\W]*?\n)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/[*][\w\W]*?[*]/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="/[*][\w\W]*"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="assembly"> + <rule> + <include state="comments"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule> + <include state="strings"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="[(),]"> + <token type="Punctuation"/> + </rule> + <rule pattern=":=|=:"> + <token type="Operator"/> + </rule> + <rule pattern="(let)(\s*)(\w*\b)"> + <bygroups> + <token type="OperatorWord"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="(\w*\b)(\:[^=])"> + <bygroups> + <token type="NameLabel"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(stop|add|mul|sub|div|sdiv|mod|smod|addmod|mulmod|exp|signextend|lt|gt|slt|sgt|eq|iszero|and|or|xor|not|byte|keccak256|sha3|address|balance|origin|caller|callvalue|calldataload|calldatasize|calldatacopy|codesize|codecopy|gasprice|extcodesize|extcodecopy|blockhash|coinbase|timestamp|number|difficulty|gaslimit|pop|mload|mstore|mstore8|sload|sstore|for|switch|jump|jumpi|pc|msize|gas|jumpdest|push1|push2|push32|dup1|dup2|dup16|swap1|swap2|swap16|log0|log1|log4|create|call|callcode|return|delegatecall|suicide|returndatasize|returndatacopy|staticcall|revert|invalid)\b"> + <token type="NameFunction"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="string-parse-common"> + <rule pattern="\\(u[0-9a-fA-F]{4}|x..|[^x])"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"\'\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sparql.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sparql.xml new file mode 100644 index 0000000..7dc65af --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sparql.xml @@ -0,0 +1,160 @@ +<lexer> + <config> + <name>SPARQL</name> + <alias>sparql</alias> + <filename>*.rq</filename> + <filename>*.sparql</filename> + <mime_type>application/sparql-query</mime_type> + </config> + <rules> + <state name="string-escape"> + <rule pattern="u[0-9A-Fa-f]{4}"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="U[0-9A-Fa-f]{8}"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern="."> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + </state> + <state name="end-of-string"> + <rule pattern="(@)([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)"> + <bygroups> + <token type="Operator"/> + <token type="NameFunction"/> + </bygroups> + <pop depth="2"/> + </rule> + <rule pattern="\^\^"> + <token type="Operator"/> + <pop depth="2"/> + </rule> + <rule> + <pop depth="2"/> + </rule> + </state> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="((?i)select|construct|describe|ask|where|filter|group\s+by|minus|distinct|reduced|from\s+named|from|order\s+by|desc|asc|limit|offset|bindings|load|clear|drop|create|add|move|copy|insert\s+data|delete\s+data|delete\s+where|delete|insert|using\s+named|using|graph|default|named|all|optional|service|silent|bind|union|not\s+in|in|as|having|to|prefix|base)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(a)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(<(?:[^<>"{}|^`\\\x00-\x20])*>)"> + <token type="NameLabel"/> + </rule> + <rule pattern="(_:[_\p{L}\p{N}](?:[-_.\p{L}\p{N}]*[-_\p{L}\p{N}])?)"> + <token type="NameLabel"/> + </rule> + <rule pattern="[?$][_\p{L}\p{N}]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="([\p{L}][-_.\p{L}\p{N}]*)?(\:)((?:[_:\p{L}\p{N}]|(?:%[0-9A-Fa-f][0-9A-Fa-f])|(?:\\[ _~.\-!$&"()*+,;=/?#@%]))(?:(?:[-_:.\p{L}\p{N}]|(?:%[0-9A-Fa-f][0-9A-Fa-f])|(?:\\[ _~.\-!$&"()*+,;=/?#@%]))*(?:[-_:\p{L}\p{N}]|(?:%[0-9A-Fa-f][0-9A-Fa-f])|(?:\\[ _~.\-!$&"()*+,;=/?#@%])))?)?"> + <bygroups> + <token type="NameNamespace"/> + <token type="Punctuation"/> + <token type="NameTag"/> + </bygroups> + </rule> + <rule pattern="((?i)str|lang|langmatches|datatype|bound|iri|uri|bnode|rand|abs|ceil|floor|round|concat|strlen|ucase|lcase|encode_for_uri|contains|strstarts|strends|strbefore|strafter|year|month|day|hours|minutes|seconds|timezone|tz|now|md5|sha1|sha256|sha384|sha512|coalesce|if|strlang|strdt|sameterm|isiri|isuri|isblank|isliteral|isnumeric|regex|substr|replace|exists|not\s+exists|count|sum|min|max|avg|sample|group_concat|separator)\b"> + <token type="NameFunction"/> + </rule> + <rule pattern="(true|false)"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="[+\-]?(\d+\.\d*[eE][+-]?\d+|\.?\d+[eE][+-]?\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+\-]?(\d+\.\d*|\.\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+\-]?\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(\|\||&&|=|\*|\-|\+|/|!=|<=|>=|!|<|>)"> + <token type="Operator"/> + </rule> + <rule pattern="[(){}.;,:^\[\]]"> + <token type="Punctuation"/> + </rule> + <rule pattern="#[^\n]*"> + <token type="Comment"/> + </rule> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="triple-double-quoted-string"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="single-double-quoted-string"/> + </rule> + <rule pattern="'''"> + <token type="LiteralString"/> + <push state="triple-single-quoted-string"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="single-single-quoted-string"/> + </rule> + </state> + <state name="triple-double-quoted-string"> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + <push state="string-escape"/> + </rule> + </state> + <state name="single-double-quoted-string"> + <rule pattern="""> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^"\\\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + <push state="string-escape"/> + </rule> + </state> + <state name="triple-single-quoted-string"> + <rule pattern="'''"> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralStringEscape"/> + <push state="string-escape"/> + </rule> + </state> + <state name="single-single-quoted-string"> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^'\\\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + <push state="string-escape"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sql.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sql.xml new file mode 100644 index 0000000..b542b65 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/sql.xml @@ -0,0 +1,90 @@ +<lexer> + <config> + <name>SQL</name> + <alias>sql</alias> + <filename>*.sql</filename> + <mime_type>text/x-sql</mime_type> + <case_insensitive>true</case_insensitive> + <not_multiline>true</not_multiline> + </config> + <rules> + <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="'"> + <token type="LiteralStringSingle"/> + <push state="string"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="double-string"/> + </rule> + <rule pattern="(DATETIME_INTERVAL_PRECISION|PARAMETER_SPECIFIC_CATALOG|PARAMATER_ORDINAL_POSITION|USER_DEFINED_TYPE_CATALOG|PARAMATER_SPECIFIC_SCHEMA|TRANSACTIONS_ROLLED_BACK|USER_DEFINED_TYPE_SCHEMA|PARAMETER_SPECIFIC_NAME|DATETIME_INTERVAL_CODE|TRANSACTIONS_COMMITTED|USER_DEFINED_TYPE_NAME|CHARACTER_SET_CATALOG|DYNAMIC_FUNCTION_CODE|COMMAND_FUNCTION_CODE|RETURNED_OCTET_LENGTH|MESSAGE_OCTET_LENGTH|CHARACTER_SET_SCHEMA|CONSTRAINT_CATALOG|TRANSACTION_ACTIVE|CHARACTER_SET_NAME|CURRENT_TIMESTAMP|CONSTRAINT_SCHEMA|COLLATION_CATALOG|RETURNED_SQLSTATE|DYNAMIC_FUNCTION|CONDITION_NUMBER|CHARACTER_LENGTH|COMMAND_FUNCTION|COLLATION_SCHEMA|CHARACTERISTICS|TRIGGER_CATALOG|CONNECTION_NAME|SUBCLASS_ORIGIN|RETURNED_LENGTH|TIMEZONE_MINUTE|CONSTRAINT_NAME|ROUTINE_CATALOG|TRIGGER_SCHEMA|ROUTINE_SCHEMA|LOCALTIMESTAMP|IMPLEMENTATION|PARAMATER_NAME|MESSAGE_LENGTH|PARAMETER_MODE|COLLATION_NAME|TIMEZONE_HOUR|SPECIFIC_NAME|DETERMINISTIC|CORRESPONTING|AUTHORIZATION|INSTANTIABLE|CURRENT_TIME|CURRENT_USER|ROUTINE_NAME|NOCREATEUSER|MESSAGE_TEXT|SQLEXCEPTION|CATALOG_NAME|SESSION_USER|CLASS_ORIGIN|CURRENT_ROLE|SPECIFICTYPE|SERIALIZABLE|CURRENT_DATE|OCTET_LENGTH|CURRENT_PATH|TRIGGER_NAME|CHAR_LENGTH|SYSTEM_USER|REFERENCING|UNENCRYPTED|COLUMN_NAME|SQLWARNINIG|DIAGNOSTICS|CURSOR_NAME|SERVER_NAME|INSENSITIVE|SCHEMA_NAME|UNCOMMITTED|TRANSACTION|CONSTRUCTOR|LANCOMPILER|CARDINALITY|CONSTRAINTS|TRANSLATION|CHECKPOINT|CONSTRAINT|CONNECTION|PRIVILEGES|COMPLETION|CONVERSION|DELIMITERS|TABLE_NAME|INDITCATOR|INITIALIZE|DESCRIPTOR|REPEATABLE|CREATEUSER|DEFERRABLE|DESTRUCTOR|PROCEDURAL|DICTIONARY|DISCONNECT|TRANSFORMS|KEY_MEMBER|BIT_LENGTH|ASYMMETRIC|ASSIGNMENT|ASENSITIVE|OVERRIDING|PARAMETERS|REFERENCES|ORDINALITY|NOCREATEDB|STATISTICS|DEALLOCATE|SAVE_POINT|RECURSIVE|STRUCTURE|SUBSTRING|IMMEDIATE|GENERATED|SYMMETRIC|STATEMENT|INCREMENT|IMMUTABLE|INCLUDING|COMMITTED|TEMPORARY|INITIALLY|TERMINATE|PRECISION|DELIMITER|TIMESTAMP|INTERSECT|ISOLATION|TRANSFORM|TRANSLATE|ROW_COUNT|ASSERTION|PARAMETER|EXCLUSIVE|LOCALTIME|VALIDATOR|AGGREGATE|EXCLUDING|SENSITIVE|EXCEPTION|ENCRYPTED|OPERATION|HIERARCHY|COLLATION|PROCEDURE|CONTINUE|ENCODING|MINVALUE|SPECIFIC|ABSOLUTE|SECURITY|WHENEVER|EXISTING|VOLATILE|MAXVALUE|EXTERNAL|NULLABLE|VARIABLE|SQLERROR|DISTINCT|DISPATCH|END-EXEC|LOCATION|ALLOCATE|OVERLAPS|UNLISTEN|ROLLBACK|TRUNCATE|DESCRIBE|SQLSTATE|BACKWARD|FUNCTION|LANGUAGE|KEY_TYPE|CASCADED|POSITION|TRAILING|DEFERRED|RELATIVE|DEFAULTS|COALSECE|PREORDER|GROUPING|MODIFIES|INHERITS|PRESERVE|DATABASE|RESTRICT|IDENTITY|TEMPLATE|NATIONAL|CONTAINS|CREATEDB|IMPLICIT|OPERATOR|CONVERT|CURRENT|CONNECT|RECHECK|PRIMARY|STORAGE|DECLARE|DEFAULT|HANDLER|COLLATE|PREPARE|REINDEX|GRANTED|CHECKED|POSTFIX|REPLACE|INSTEAD|CATALOG|RESTART|INVOKER|PLACING|PENDANT|DEFINED|ITERATE|PARTIAL|CASCADE|BREADTH|GENERAL|TRIGGER|SESSION|BETWEEN|DEFINER|LATERAL|LEADING|RETURNS|TRUSTED|UNKNOWN|FORWARD|UNNAMED|OVERLAY|FORTRAN|ANALYZE|OPTIONS|ANALYSE|FOREIGN|ROUTINE|LOCATOR|DESTROY|SUBLIST|VERBOSE|EXTRACT|NOTNULL|EXPLAIN|VERSION|SQLCODE|EXECUTE|NOTHING|DYNAMIC|WITHOUT|SIMILAR|NATURAL|COMMENT|CLUSTER|PASCAL|SOURCE|EQUALS|CALLED|ESCAPE|EXCEPT|SELECT|ISNULL|DOMAIN|SEARCH|SCROLL|SIMPLE|BITVAR|MINUTE|EXISTS|SCHEMA|ATOMIC|METHOD|NOTIFY|ACCESS|UNIQUE|ROLLUP|NULLIF|OBJECT|STABLE|COLUMN|REVOKE|OFFSET|COMMIT|MODIFY|FREEZE|DELETE|RETURN|RESULT|UNNEST|OPTION|GLOBAL|VALUES|RENAME|SYSTEM|STATIC|UPDATE|OUTPUT|LISTEN|STDOUT|STRICT|PUBLIC|IGNORE|PREFIX|SECOND|CREATE|LENGTH|BEFORE|HAVING|INSERT|VACUUM|CURSOR|ELSIF|USING|ALTER|STYPE|CYCLE|LARGE|INPUT|CROSS|INOUT|INNER|INFIX|INDEX|LEVEL|USAGE|ILIKE|VALID|OWNER|GRANT|READS|UPPER|LIMIT|OUTER|STDIN|SYSID|GROUP|ALIAS|ORDER|UNTIL|LOCAL|RESET|START|COUNT|LOWER|TABLE| TEMP|PRIOR|AFTER|STATE|ADMIN|RIGHT|COBOL|FOUND|MATCH|FORCE|ABORT|FIRST|FINAL|CLOSE|DEREF|FETCH|WHERE|FALSE|SCALE|BEGIN|CLASS|TOAST|WRITE|NCLOB|NCHAR|CHECK|CHAIN|SPACE|NAMES|EVERY|MUMPS|CACHE|UNION|UNDER|SETOF|MONTH|SHARE|SCOPE|TREAT|SHOW|SIZE|SOME|SETS|SELF|ELSE|EACH|DROP|TYPE|FROM|RULE|DESC|ROWS|ZONE|ROLE|TRUE|FREE|FULL|GOTO|TRIM|HOLD|HOST|DATA|READ|INTO|USER|JOIN|CUBE|LAST|LEFT|LESS|LIKE|LOAD|LOCK|OPEN|COPY|ONLY|OIDS|VIEW|WHEN|THAN|THEN|NULL|NONE|WITH|WORK|NEXT|YEAR|MODE|CAST|CASE|MOVE|CALL|MORE|BOTH|EXEC|CLOB|OUT|MOD|ARE|SUM|DAY|GET|AVG|NEW|SQL|ABS|MIN|ASC|END|ROW|NOT|FOR|ANY|PLI|MAX|REF|MAP|ADA|KEY|AND|ADD|ALL|OLD|OFF|PAD|SET|OR|ON|TO|IS|OF|IN|IF|GO|AS|DO|AT|NO|BY|C|G)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(CHARACTER|SMALLINT|INTERVAL|DECIMAL|SERIAL8|VARYING|BOOLEAN|VARCHAR|INTEGER|NUMERIC|SERIAL|BINARY|BIGINT|NUMBER|FLOAT|ARRAY|TEXT|REAL|INT8|DATE|CHAR|BLOB|DEC|BIT|INT)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[+*/<>=~!@#%^&|`?-]"> + <token type="Operator"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[a-z_][\w$]*"> + <token type="Name"/> + </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> + <state name="string"> + <rule pattern="[^']+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="''"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + </state> + <state name="double-string"> + <rule pattern="[^"]+"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=""""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/squidconf.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/squidconf.xml new file mode 100644 index 0000000..cbd8dbc --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/squidconf.xml @@ -0,0 +1,63 @@ +<lexer> + <config> + <name>SquidConf</name> + <alias>squidconf</alias> + <alias>squid.conf</alias> + <alias>squid</alias> + <filename>squid.conf</filename> + <mime_type>text/x-squidconf</mime_type> + <case_insensitive>true</case_insensitive> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="#"> + <token type="Comment"/> + <push state="comment"/> + </rule> + <rule pattern="\b(redirect_rewrites_host_header|httpd_accel_uses_host_header|high_response_time_warning|delay_initial_bucket_level|memory_replacement_policy|maximum_single_addr_tries|cahce_replacement_policy|store_objects_per_bucket|mcast_icp_query_timeout|high_page_fault_warning|cache_stoplist_pattern|httpd_accel_with_proxy|request_body_max_size|authenticate_children|minimum_retry_timeout|incoming_http_average|store_avg_object_size|snmp_incoming_address|cache_effective_group|mcast_miss_encode_key|neighbor_type_domain|cache_effective_user|single_parent_bypass|tcp_incoming_address|udp_outgoing_address|tcp_outgoing_address|incoming_icp_average|udp_incoming_address|authenticate_program|minimum_object_size|ident_lookup_access|minimum_direct_hops|maximum_object_size|half_closed_clients|range_offset_limit|forward_snmpd_port|memory_pools_limit|siteselect_timeout|hierarchy_stoplist|netdb_ping_period|strip_query_terms|test_reachability|shutdown_lifetime|redirect_children|min_http_poll_cnt|cache_dns_program|anonymize_headers|dead_peer_timeout|cache_host_domain|emulate_httpd_log|http_reply_access|passthrough_proxy|icp_query_timeout|cache_peer_access|tcp_recv_bufsize|neighbor_timeout|negative_dns_ttl|min_icp_poll_cnt|swap_level1_dirs|visible_hostname|positive_dns_ttl|swap_level2_dirs|auth_param_basic|delay_parameters|proxy_auth_realm|redirect_program|udp_hit_obj_size|cache_access_log|httpd_accel_port|httpd_accel_host|authenticate_ttl|netdb_ping_rate|wais_relay_host|wais_relay_port|dns_nameservers|cache_swap_high|cache_store_log|request_timeout|refresh_pattern|http_anonymizer|announce_period|client_lifetime|as_whois_server|mcast_miss_port|mcast_miss_addr|reload_into_ims|cachemgr_passwd|log_icp_queries|connect_timeout|quick_abort_max|quick_abort_min|quick_abort_pct|unique_hostname|inside_firewall|unlinkd_program|fake_user_agent|ftpget_program|uri_whitespace|cache_announce|ftpget_options|cache_mem_high|cache_swap_low|logfile_rotate|cache_swap_log|fqdncache_size|pinger_program|client_netmask|header_replace|ftp_list_width|cache_host_acl|cache_stoplist|announce_port|prefer_direct|useragent_log|buffered_logs|append_domain|log_mime_hdrs|err_html_text|dns_testnames|forwarded_for|reference_age|announce_host|pconn_timeout|icp_hit_stale|always_direct|cache_mem_low|debug_options|header_access|ident_timeout|ipcache_size|request_size|never_direct|dns_children|negative_ttl|coredump_dir|pid_filename|delay_access|memory_pools|mcast_groups|dns_defnames|ident_lookup|ipcache_high|read_timeout|broken_posts|local_domain|ftp_passive|ipcache_low|quick_abort|delay_pools|announce_to|source_ping|delay_class|firewall_ip|miss_access|http_access|udp_hit_obj|snmp_access|httpd_accel|mime_table|proxy_auth|cache_peer|netdb_high|icp_access|hosts_file|cache_host|cache_swap|wais_relay|query_icmp|access_log|cache_dir|snmp_port|deny_info|client_db|cache_mem|http_port|htcp_port|cache_mgr|cache_log|ssl_proxy|netdb_low|ftp_user|local_ip|log_fqdn|no_cache|icp_port|acl)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(multicast-responder|offline_toggle|credentialsttl|round-robin|proxy-only|no-digest|no-query|children|disable|default|weight|parent|diskd|allow|realm|deny|heap|none|via|all|ttl|off|lru|on|q2|q1)\b"> + <token type="NameConstant"/> + </rule> + <rule pattern="\b(server_list|client_list|squid\.conf|parameter|shutdown|info)\b"> + <token type="LiteralString"/> + </rule> + <rule pattern="stats/(filedescriptors|reply_headers|utilization|redirector|vm_objects|fqdncache|objects|ipcache|netdb|dns|io)\b"> + <token type="LiteralString"/> + </rule> + <rule pattern="log/(disable|status|enable|clear)="> + <token type="LiteralString"/> + </rule> + <rule pattern="\b(snmp_community|rep_mime_type|urlpath_regex|referer_regex|req_mime_type|dstdomain|url_regex|browser|method|proto|ident|time|port|user|src|dst)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(?:(?:(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})(?:\.(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})){3})|(?!.*::.*::)(?:(?!:)|:(?=:))(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)){6}(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)[0-9a-f]{0,4}(?:(?<=::)|(?<!:)|(?<=:)(?<!::):)|(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))(?:/(?:(?:(?:(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})(?:\.(?:[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}|0x0*[0-9a-f]{1,2}|0+[1-3]?[0-7]{0,2})){3})|(?!.*::.*::)(?:(?!:)|:(?=:))(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)){6}(?:[0-9a-f]{0,4}(?:(?<=::)|(?<!::):)[0-9a-f]{0,4}(?:(?<=::)|(?<!:)|(?<=:)(?<!::):)|(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|\b\d+\b))?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(?:\b\d+\b(?:-\b\d+|%)?)"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="\S+"> + <token type="Text"/> + </rule> + </state> + <state name="comment"> + <rule pattern="\s*TAG:.*"> + <token type="LiteralStringEscape"/> + <pop depth="1"/> + </rule> + <rule pattern=".+"> + <token type="Comment"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/standard_ml.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/standard_ml.xml new file mode 100644 index 0000000..39cf4f2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/standard_ml.xml @@ -0,0 +1,548 @@ +<lexer> + <config> + <name>Standard ML</name> + <alias>sml</alias> + <filename>*.sml</filename> + <filename>*.sig</filename> + <filename>*.fun</filename> + <mime_type>text/x-standardml</mime_type> + <mime_type>application/x-standardml</mime_type> + </config> + <rules> + <state name="delimiters"> + <rule pattern="\(|\[|\{"> + <token type="Punctuation"/> + <push state="main"/> + </rule> + <rule pattern="\)|\]|\}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="\b(let|if|local)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="main" state="main"/> + </rule> + <rule pattern="\b(struct|sig|while)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="main"/> + </rule> + <rule pattern="\b(do|else|end|in|then)\b(?!\')"> + <token type="KeywordReserved"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule> + <push state="main"/> + </rule> + </state> + <state name="breakout"> + <rule pattern="(?=\b(where|do|handle|if|sig|op|while|case|as|else|signature|andalso|struct|infixr|functor|in|structure|then|local|rec|end|fun|of|orelse|val|include|fn|with|exception|let|and|infix|sharing|datatype|type|abstype|withtype|eqtype|nonfix|raise|open)\b(?!\'))"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="tyvarseq"> + <rule pattern="\s"> + <token type="Text"/> + </rule> + <rule pattern="\(\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\'[\w\']*"> + <token type="NameDecorator"/> + </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> + <rule pattern="[!%&$#+\-/:<=>?@\\~`^|*]+"> + <token type="Name"/> + </rule> + </state> + <state name="char"> + <rule pattern="[^"\\]"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="\\[\\"abtnvfr]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\\^[\x40-\x5e]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\[0-9]{3}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\u[0-9a-fA-F]{4}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\\s+\\"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="""> + <token type="LiteralStringChar"/> + <pop depth="1"/> + </rule> + </state> + <state name="datbind"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\b(and)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="#pop" state="dname"/> + </rule> + <rule pattern="\b(withtype)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="#pop" state="tname"/> + </rule> + <rule pattern="\b(of)\b(?!\')"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(\|)(\s*)([a-zA-Z][\w']*)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="(\|)(\s+)([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule> + <include state="breakout"/> + </rule> + <rule> + <include state="core"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + </rule> + </state> + <state name="string"> + <rule pattern="[^"\\]"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\\[\\"abtnvfr]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\\^[\x40-\x5e]"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\[0-9]{3}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\u[0-9a-fA-F]{4}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\\\s+\\"> + <token type="LiteralStringInterpol"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + <state name="tname"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="breakout"/> + </rule> + <rule pattern="\'[\w\']*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="tyvarseq"/> + </rule> + <rule pattern="=(?![!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="Punctuation"/> + <push state="#pop" state="typbind"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="KeywordType"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="KeywordType"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + <pop depth="1"/> + </rule> + </state> + <state name="dname"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="breakout"/> + </rule> + <rule pattern="\'[\w\']*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="tyvarseq"/> + </rule> + <rule pattern="(=)(\s*)(datatype)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <token type="KeywordReserved"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="=(?![!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="Punctuation"/> + <push state="#pop" state="datbind" state="datcon"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="KeywordType"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="KeywordType"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + <pop depth="1"/> + </rule> + </state> + <state name="typbind"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\b(and)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="#pop" state="tname"/> + </rule> + <rule> + <include state="breakout"/> + </rule> + <rule> + <include state="core"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + <pop depth="1"/> + </rule> + </state> + <state name="ename"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="(exception|and)\b(\s+)([a-zA-Z][\w']*)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="(exception|and)\b(\s*)([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="\b(of)\b(?!\')"> + <token type="KeywordReserved"/> + </rule> + <rule> + <include state="breakout"/> + </rule> + <rule> + <include state="core"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + </rule> + </state> + <state name="vname"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\'[\w\']*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="tyvarseq"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)(\s*)(=(?![!%&$#+\-/:<=>?@\\~`^|*]+))"> + <bygroups> + <token type="NameVariable"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)(\s*)(=(?![!%&$#+\-/:<=>?@\\~`^|*]+))"> + <bygroups> + <token type="NameVariable"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="NameVariable"/> + <pop depth="1"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="NameVariable"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="sname"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="breakout"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="NameNamespace"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="main-fun"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\s"> + <token type="Text"/> + </rule> + <rule pattern="\(\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\b(fun|and)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="fname"/> + </rule> + <rule pattern="\b(val)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="#pop" state="main" state="vname"/> + </rule> + <rule pattern="\|"> + <token type="Punctuation"/> + <push state="fname"/> + </rule> + <rule pattern="\b(case|handle)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="#pop" state="main"/> + </rule> + <rule> + <include state="delimiters"/> + </rule> + <rule> + <include state="core"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + </rule> + </state> + <state name="datcon"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + <pop depth="1"/> + </rule> + </state> + <state name="dotted"> + <rule pattern="([a-zA-Z][\w']*)(\.)"> + <token type="NameNamespace"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="Name"/> + <pop depth="1"/> + </rule> + <rule pattern="\s+"> + <token type="Error"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + </rule> + </state> + <state name="main"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\b(val|and)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="vname"/> + </rule> + <rule pattern="\b(fun)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="#pop" state="main-fun" state="fname"/> + </rule> + <rule> + <include state="delimiters"/> + </rule> + <rule> + <include state="core"/> + </rule> + <rule pattern="\S+"> + <token type="Error"/> + </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="whitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\(\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + </state> + <state name="core"> + <rule pattern="(_|\}|\{|\)|;|,|\[|\(|\]|\.\.\.)"> + <token type="Punctuation"/> + </rule> + <rule pattern="#""> + <token type="LiteralStringChar"/> + <push state="char"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="~?0x[0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0wx[0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0w\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="~?\d+\.\d+[eE]~?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="~?\d+\.\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="~?\d+[eE]~?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="~?\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="#\s*[1-9][0-9]*"> + <token type="NameLabel"/> + </rule> + <rule pattern="#\s*([a-zA-Z][\w']*)"> + <token type="NameLabel"/> + </rule> + <rule pattern="#\s+([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="NameLabel"/> + </rule> + <rule pattern="\b(datatype|abstype)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="dname"/> + </rule> + <rule pattern="(?=\b(exception)\b(?!\'))"> + <token type="Text"/> + <push state="ename"/> + </rule> + <rule pattern="\b(functor|include|open|signature|structure)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="sname"/> + </rule> + <rule pattern="\b(type|eqtype)\b(?!\')"> + <token type="KeywordReserved"/> + <push state="tname"/> + </rule> + <rule pattern="\'[\w\']*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)(\.)"> + <token type="NameNamespace"/> + <push state="dotted"/> + </rule> + <rule pattern="\b(abstype|and|andalso|as|case|datatype|do|else|end|exception|fn|fun|handle|if|in|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|then|type|val|with|withtype|while|eqtype|functor|include|sharing|sig|signature|struct|structure|where)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="Name"/> + </rule> + <rule pattern="\b(:|\|,=|=>|->|#|:>)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="Name"/> + </rule> + </state> + <state name="fname"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="\'[\w\']*"> + <token type="NameDecorator"/> + </rule> + <rule pattern="\("> + <token type="Punctuation"/> + <push state="tyvarseq"/> + </rule> + <rule pattern="([a-zA-Z][\w']*)"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule pattern="([!%&$#+\-/:<=>?@\\~`^|*]+)"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/stylus.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/stylus.xml new file mode 100644 index 0000000..c2d8807 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/stylus.xml @@ -0,0 +1,132 @@ +<lexer> + <config> + <name>Stylus</name> + <alias>stylus</alias> + <filename>*.styl</filename> + <mime_type>text/x-styl</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="values"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(\#[a-f0-9]{3,6})"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\b(use-glyph-orientation|decimal-leading-zero|ruby-base-container|ruby-text-container|table-column-group|table-header-group|geometricPrecision|table-footer-group|optimizeLegibility|alternate-reverse|repeat no-repeat|table-row-group|all-petite-caps|ultra-condensed|extra-condensed|box-decoration|sideways-right|extra-expanded|no-close-quote|all-small-caps|semi-condensed|ultra-expanded|column-reverse|space-between|semi-expanded|table-caption|no-open-quote|sideways-left|double-circle|vertical-text|optimizeSpeed|weight style|currentColor|titling-caps|match-parent|table-column|line-through|inline-block|inline-table|wrap-reverse|avoid-column|manipulation|space-around|context-menu|lower-alpha|row-reverse|not-allowed|content-box|ease-in-out|close-quote|lower-latin|crisp-edges|lower-roman|lower-greek|upper-alpha|upper-latin|upper-roman|nwse-resize|nesw-resize|preserve-3d|inline-flex|petite-caps|color-dodge|descendants|padding-box|capitalize|small-caps|difference|inter-word|step-start|all-scroll|stroke-box|soft-light|margin-box|open-quote|table-cell|row-resize|border-box|hard-light|break-word|color-burn|luminosity|full-width|col-resize|from-image|avoid-page|scale-down|saturation|sans-serif|flex-start|distribute|horizontal|alternate|ruby-text|force-end|list-item|se-resize|mandatory|exclusion|ns-resize|underline|ruby-base|ew-resize|condensed|container|uppercase|no-repeat|nw-resize|table-row|backwards|crosshair|proximity|sw-resize|lowercase|allow-end|each-line|monospace|pixelated|ne-resize|luminance|pan-right|ellipsis|pan-down|pan-left|overline|multiply|progress|relative|infinite|repeat-x|repeat-y|georgian|forwards|flex-end|s-resize|fill-box|expanded|separate|ease-out|sideways|e-resize|step-end|n-resize|collapse|triangle|baseline|view-box|w-resize|armenian|absolute|xx-large|xx-small|vertical|zoom-out|contain|ease-in|running|no-drop|zoom-in|unicase|hanging|smaller|x-large|overlay|compact|lighter|lighten|objects|oblique|x-small|reverse|stretch|upright|cursive|inherit|initial|outside|pointer|decimal|default|justify|visible|balance|isolate|fantasy|paused|static|pan-up|invert|inside|italic|weight|inline|hidden|outset|larger|repeat|always|spaces|sticky|circle|digits|linear|column|smooth|nowrap|bolder|normal|sesame|dashed|groove|darken|bottom|run-in|manual|dotted|double|medium|filled|screen|scroll|center|strict|square|edges|serif|start|thick|first|clone|fixed|slice|small|under|unset|block|color|round|solid|space|right|ridge|blink|below|pan-y|avoid|large|cover|inset|alpha|local|alias|style|loose|table|mixed|pan-x|page|ruby|disc|none|snap|ease|text|show|thin|clip|left|open|wrap|fill|cell|flat|flex|flip|last|both|help|bold|over|hide|wait|icon|move|auto|copy|wavy|top|ltr|row|rtl|end|hue|dot|off|all|ink|to|on)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="\;?"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="([ \t]*\n|\s+)"> + <token type="Text"/> + </rule> + <rule pattern="[!$][\w-]+"> + <token type="NameVariable"/> + </rule> + <rule pattern="@[\w-]+"> + <token type="KeywordPseudo"/> + <push state="atrule"/> + </rule> + <rule pattern="(\.)([\w-]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="for|if|else if|else|unless|return|\&"> + <token type="Keyword"/> + </rule> + <rule pattern="([\w-]+)(\()"> + <bygroups> + <token type="NameDecorator"/> + <token type="Punctuation"/> + </bygroups> + <push state="function-start"/> + </rule> + <rule pattern="(\+)([\w-]+)(\(\))"> + <bygroups> + <token type="Keyword"/> + <token type="NameDecorator"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(-webkit-|-khtml-|prince-|-atsc-|-moz-|-rim-|-wap-|-ms-|-xv-|mso-|-ah-|-hp-|-ro-|-tc-|-o-)"> + <token type="NameProperty"/> + </rule> + <rule pattern="\b(align-content|align-items|align-self|alignment-baseline|all|animation|animation-delay|animation-direction|animation-duration|animation-fill-mode|animation-iteration-count|animation-name|animation-play-state|animation-timing-function|appearance|azimuth|backface-visibility|background|background-attachment|background-blend-mode|background-clip|background-color|background-image|background-origin|background-position|background-repeat|background-size|baseline-shift|bookmark-label|bookmark-level|bookmark-state|border|border-bottom|border-bottom-color|border-bottom-left-radius|border-bottom-right-radius|border-bottom-style|border-bottom-width|border-boundary|border-collapse|border-color|border-image|border-image-outset|border-image-repeat|border-image-slice|border-image-source|border-image-width|border-left|border-left-color|border-left-style|border-left-width|border-radius|border-right|border-right-color|border-right-style|border-right-width|border-spacing|border-style|border-top|border-top-color|border-top-left-radius|border-top-right-radius|border-top-style|border-top-width|border-width|bottom|box-decoration-break|box-shadow|box-sizing|box-snap|box-suppress|break-after|break-before|break-inside|caption-side|caret|caret-animation|caret-color|caret-shape|chains|clear|clip|clip-path|clip-rule|color|color-interpolation-filters|column-count|column-fill|column-gap|column-rule|column-rule-color|column-rule-style|column-rule-width|column-span|column-width|columns|content|counter-increment|counter-reset|counter-set|crop|cue|cue-after|cue-before|cursor|direction|display|dominant-baseline|elevation|empty-cells|filter|flex|flex-basis|flex-direction|flex-flow|flex-grow|flex-shrink|flex-wrap|float|float-defer|float-offset|float-reference|flood-color|flood-opacity|flow|flow-from|flow-into|font|font-family|font-feature-settings|font-kerning|font-language-override|font-size|font-size-adjust|font-stretch|font-style|font-synthesis|font-variant|font-variant-alternates|font-variant-caps|font-variant-east-asian|font-variant-ligatures|font-variant-numeric|font-variant-position|font-weight|footnote-display|footnote-policy|glyph-orientation-vertical|grid|grid-area|grid-auto-columns|grid-auto-flow|grid-auto-rows|grid-column|grid-column-end|grid-column-gap|grid-column-start|grid-gap|grid-row|grid-row-end|grid-row-gap|grid-row-start|grid-template|grid-template-areas|grid-template-columns|grid-template-rows|hanging-punctuation|height|hyphenate-character|hyphenate-limit-chars|hyphenate-limit-last|hyphenate-limit-lines|hyphenate-limit-zone|hyphens|image-orientation|image-resolution|initial-letter|initial-letter-align|initial-letter-wrap|isolation|justify-content|justify-items|justify-self|left|letter-spacing|lighting-color|line-break|line-grid|line-height|line-snap|list-style|list-style-image|list-style-position|list-style-type|margin|margin-bottom|margin-left|margin-right|margin-top|marker-side|marquee-direction|marquee-loop|marquee-speed|marquee-style|mask|mask-border|mask-border-mode|mask-border-outset|mask-border-repeat|mask-border-slice|mask-border-source|mask-border-width|mask-clip|mask-composite|mask-image|mask-mode|mask-origin|mask-position|mask-repeat|mask-size|mask-type|max-height|max-lines|max-width|min-height|min-width|mix-blend-mode|motion|motion-offset|motion-path|motion-rotation|move-to|nav-down|nav-left|nav-right|nav-up|object-fit|object-position|offset-after|offset-before|offset-end|offset-start|opacity|order|orphans|outline|outline-color|outline-offset|outline-style|outline-width|overflow|overflow-style|overflow-wrap|overflow-x|overflow-y|padding|padding-bottom|padding-left|padding-right|padding-top|page|page-break-after|page-break-before|page-break-inside|page-policy|pause|pause-after|pause-before|perspective|perspective-origin|pitch|pitch-range|play-during|polar-angle|polar-distance|position|presentation-level|quotes|region-fragment|resize|rest|rest-after|rest-before|richness|right|rotation|rotation-point|ruby-align|ruby-merge|ruby-position|running|scroll-snap-coordinate|scroll-snap-destination|scroll-snap-points-x|scroll-snap-points-y|scroll-snap-type|shape-image-threshold|shape-inside|shape-margin|shape-outside|size|speak|speak-as|speak-header|speak-numeral|speak-punctuation|speech-rate|stress|string-set|tab-size|table-layout|text-align|text-align-last|text-combine-upright|text-decoration|text-decoration-color|text-decoration-line|text-decoration-skip|text-decoration-style|text-emphasis|text-emphasis-color|text-emphasis-position|text-emphasis-style|text-indent|text-justify|text-orientation|text-overflow|text-shadow|text-space-collapse|text-space-trim|text-spacing|text-transform|text-underline-position|text-wrap|top|transform|transform-origin|transform-style|transition|transition-delay|transition-duration|transition-property|transition-timing-function|unicode-bidi|user-select|vertical-align|visibility|voice-balance|voice-duration|voice-family|voice-pitch|voice-range|voice-rate|voice-stress|voice-volume|volume|white-space|widows|width|will-change|word-break|word-spacing|word-wrap|wrap-after|wrap-before|wrap-flow|wrap-inside|wrap-through|writing-mode|z-index)\b(\:)?"> + <bygroups> + <token type="NameProperty"/> + <token type="Punctuation"/> + </bygroups> + <push state="values"/> + </rule> + <rule pattern="\b(a|abbr|acronym|address|applet|area|article|aside|audio|b|base(?:front)?|bd(?:i|o)|big|blockquote|body|br|button|canvas|caption|center|cite|code|col|colgroup|data|datalist|d(?:d|l|t)|del|details|dfn|dialog|dir|div|em(?:bed)?|fieldset|fig(?:caption|ure)|font|footer|form|frame(?:set)?|h[1-6]+|head(?:er)?|hr|html|i|iframe|img|input|ins|kbd|label|legend|li|link|main|map|mark|meta|meter|nav|noframes|noscript|object|ol|optgroup|option|output|p|param|picture|pre|progress|q|r(?:p|t|uby)|s|samp|script|section|select|small|source|span|strike|strong|style|sub|summary|sup|svg|table|tbody|td|template|textarea|tfoot|th|thead|time|title|tr|track|tt|u|ul|var|video|wbr)\b"> + <token type="NameTag"/> + </rule> + <rule pattern="\b(cjk-ideographic|katakana-iroha|hiragana-iroha|small-caption|bidi-override|center-right|center-left|text-bottom|message-box|continuous|status-bar|right-side|rightwards|spell-out|left-side|landscape|far-right|leftwards|narrower|portrait|katakana|far-left|text-top|pre-wrap|hiragana|pre-line|silent|x-high|faster|higher|middle|x-soft|behind|x-fast|hebrew|slower|x-loud|super|above|lower|wider|level|aural|embed|x-low|cross|crop|fast|once|high|slow|soft|loud|yes|pre|low|mix)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="\b(lightgoldenrodyellow|mediumspringgreen|mediumaquamarine|mediumslateblue|mediumturquoise|mediumvioletred|lightsteelblue|cornflowerblue|lightslategray|blanchedalmond|mediumseagreen|lightslategrey|darkolivegreen|darkgoldenrod|darkslateblue|lightseagreen|rebeccapurple|darkslategrey|darkslategray|palegoldenrod|paleturquoise|palevioletred|darkturquoise|lavenderblush|antiquewhite|mediumorchid|lightskyblue|mediumpurple|midnightblue|darkseagreen|lemonchiffon|springgreen|yellowgreen|greenyellow|navajowhite|darkmagenta|lightyellow|transparent|lightsalmon|forestgreen|saddlebrown|deepskyblue|floralwhite|dodgerblue|ghostwhite|lightcoral|sandybrown|darkviolet|papayawhip|mediumblue|chartreuse|lightgreen|whitesmoke|aquamarine|darkorange|darksalmon|powderblue|darkorchid|blueviolet|indianred|mintcream|mistyrose|olivedrab|goldenrod|orangered|lawngreen|gainsboro|lightblue|firebrick|lightcyan|peachpuff|lightgray|darkkhaki|lightgrey|darkgreen|rosybrown|royalblue|slateblue|chocolate|cadetblue|burlywood|slategray|slategrey|limegreen|steelblue|turquoise|palegreen|lightpink|aliceblue|moccasin|darkgrey|darkblue|seagreen|lavender|cornsilk|deeppink|seashell|darkgray|honeydew|darkcyan|dimgrey|magenta|crimson|darkred|hotpink|skyblue|oldlace|dimgray|fuchsia|thistle|orchid|indigo|orange|tomato|violet|salmon|yellow|silver|purple|bisque|sienna|maroon|black|linen|azure|white|wheat|khaki|green|olive|ivory|coral|brown|beige|snow|blue|navy|aqua|teal|gray|gold|grey|lime|peru|cyan|pink|plum|tan|red)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(\{|\}|\(|\)|\[|\]|,|:|;)"> + <token type="Punctuation"/> + </rule> + <rule pattern="(\.|\!|\-|\+|\~|\*\*|\*|\/|\%|\.\.\.|\.\.|\<\=|\>\=|\<|\>|\=\=|\!\=|\&\&|\|\||\=|\:\=|\?\=|\+\=|\-\=|\*\=|\/\=|\%\=|\?|\:)"> + <token type="Operator"/> + </rule> + <rule pattern="\b(and|if unless|in|is|is a|is defined|is not|isnt|or|not)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="(\#[a-f0-9]{3,6})"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + </state> + <state name="inline-comment"> + <rule pattern="\*/"> + <token type="Comment"/> + <pop depth="1"/> + </rule> + </state> + <state name="atrule"> + <rule pattern="\{"> + <token type="Punctuation"/> + <push state="atcontent"/> + </rule> + <rule pattern="$"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="atcontent"> + <rule> + <include state="root"/> + </rule> + <rule pattern="\}"> + <token type="Punctuation"/> + <pop depth="2"/> + </rule> + </state> + <state name="function-start"> + <rule pattern="\)"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/swift.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/swift.xml new file mode 100644 index 0000000..416bf90 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/swift.xml @@ -0,0 +1,207 @@ +<lexer> + <config> + <name>Swift</name> + <alias>swift</alias> + <filename>*.swift</filename> + <mime_type>text/x-swift</mime_type> + </config> + <rules> + <state name="comment"> + <rule pattern=":param: [a-zA-Z_]\w*|:returns?:|(FIXME|MARK|TODO):"> + <token type="CommentSpecial"/> + </rule> + </state> + <state name="preproc"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule pattern="[A-Za-z]\w*"> + <token type="CommentPreproc"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="comment-single"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="comment"/> + </rule> + <rule pattern="[^\n]"> + <token type="CommentSingle"/> + </rule> + </state> + <state name="module"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameClass"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="string"> + <rule pattern="\\\("> + <token type="LiteralStringInterpol"/> + <push state="string-intp"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + </state> + <state name="string-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="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="//"> + <token type="CommentSingle"/> + <push state="comment-single"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="comment-multi"/> + </rule> + <rule pattern="#(if|elseif|else|endif|available)\b"> + <token type="CommentPreproc"/> + <push state="preproc"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule pattern="(ExtendedGraphemeClusterLiteralConvertible|_SwiftNSDictionaryRequiredOverridesType|_SwiftNSStringRequiredOverridesType|_SwiftNSArrayRequiredOverridesType|AutoreleasingUnsafeMutablePointer|UnicodeScalarLiteralConvertible|RangeReplaceableCollectionType|StringInterpolationConvertible|DictionaryLiteralConvertible|UnsafeBufferPointerGenerator|_SwiftNSFastEnumerationType|LazyBidirectionalCollection|ExtendedGraphemeClusterType|FloatingPointClassification|ImplicitlyUnwrappedOptional|UnsafeMutableBufferPointer|LazyRandomAccessCollection|FilterCollectionViewIndex|_ExtensibleCollectionType|IntegerLiteralConvertible|ReverseBidirectionalIndex|BooleanLiteralConvertible|StringLiteralConvertible|BidirectionalReverseView|ReverseRandomAccessIndex|ExtensibleCollectionType|FloatLiteralConvertible|RandomAccessReverseView|_BidirectionalIndexType|ArrayLiteralConvertible|_RandomAccessIndexType|_IntegerArithmeticType|BidirectionalIndexType|StrideThroughGenerator|_SwiftNSDictionaryType|_SwiftNSEnumeratorType|BitwiseOperationsType|RandomAccessIndexType|NilLiteralConvertible|_ObjectiveCBridgeable|UnicodeDecodingResult|LazyForwardCollection|IntegerArithmeticType|MutableCollectionType|PermutationGenerator|MapSequenceGenerator|_UnsignedIntegerType|FilterCollectionView|UnsafeMutablePointer|UnsafeBufferPointer|UnsignedIntegerType|_SwiftNSCopyingType|DictionaryGenerator|_SignedIntegerType|_SwiftNSStringType|IntegerLiteralType|FilterSequenceView|EnumerateGenerator|BooleanLiteralType|HeapBufferStorage|EnumerateSequence|MirrorDisposition|_SignedNumberType|UnicodeScalarType|StringLiteralType|GeneratorSequence|_ForwardIndexType|StrideToGenerator|_SwiftNSArrayType|IndexingGenerator|_RawOptionSetType|FloatingPointType|MapCollectionView|SignedIntegerType|OutputStreamType|UnicodeCodecType|HalfOpenInterval|NSObjectProtocol|SignedNumberType|ObjectIdentifier|RawOptionSetType|_CocoaStringType|ForwardIndexType|RawRepresentable|MutableSliceable|FloatLiteralType|_ArrayBufferType|AbsoluteValuable|CFunctionPointer|QuickLookObject|MapSequenceView|EmptyCollection|FilterGenerator|_CollectionType|CollectionOfOne|ContiguousArray|DictionaryIndex|GeneratorOfOne|DebugPrintable|CVaListPointer|CUnsignedShort|COpaquePointer|EmptyGenerator|_Incrementable|RangeGenerator|NSErrorPointer|_Sequence_Type|ClosedInterval|CollectionType|ZipGenerator2|UnsafePointer|GeneratorType|StrideThrough|CUnsignedLong|UnicodeScalar|_SequenceType|LazySequence|IntervalType|SequenceType|StaticString|CUnsignedInt|_IntegerType|BooleanType|CVarArgType|_Strideable|_Comparable|GeneratorOf|IntegerType|Reflectable|CSignedChar|Streamable|SequenceOf|Dictionary|Comparable|HeapBuffer|_Sliceable|MirrorType|Strideable|CLongLong|CWideChar|Printable|Equatable|Unmanaged|Sliceable|Character|AnyObject|Optional|StrideTo|SinkType|AnyClass|Hashable|Selector|Float32|CChar16|UIntMax|Float80|Float64|RawByte|Process|CDouble|CChar32|UInt16|UInt32|C_ARGC|C_ARGV|UInt64|CFloat|String|SinkOf|Repeat|OnHeap|Double|CShort|IntMax|UTF16|Slice|CLong|UTF32|UInt8|Range|UWord|Array|Float|Int64|Int32|Int16|CBool|CChar|UInt|Int8|Word|UTF8|Zip2|Void|Bool|CInt|Any|Int|Bit)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(withUnsafeMutablePointers|withUnsafeMutablePointer|lexicographicalCompare|withExtendedLifetime|preconditionFailure|withUnsafePointers|underestimateCount|withUnsafePointer|assertionFailure|unsafeAddressOf|unsafeDowncast|countElements|unsafeBitCast|toDebugString|strideofValue|removeAtIndex|alignofValue|debugPrintln|precondition|sizeofValue|removeRange|numericCast|removeLast|debugPrint|fatalError|minElement|maxElement|startsWith|withVaList|partition|removeAll|transcode|dropFirst|enumerate|getVaList|strideof|contains|overlaps|dropLast|distance|toString|advance|println|alignof|reflect|indices|reverse|isEmpty|prefix|stride|sizeof|insert|assert|sorted|splice|filter|extend|reduce|suffix|equal|print|count|split|first|swap|dump|sort|lazy|last|join|find|abs|min|max|map)\b"> + <token type="NameBuiltinPseudo"/> + </rule> + <rule pattern="\$\d+"> + <token type="NameVariable"/> + </rule> + <rule pattern="0b[01_]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0o[0-7_]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0x[0-9a-fA-F_]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9][0-9_]*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="[(){}\[\].,:;=@#`?]|->|[<&?](?=\w)|(?<=\w)[>!?]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[/=\-+!*%<>&|^?~]+"> + <token type="Operator"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="comment-multi"> + <rule> + <include state="comment"/> + </rule> + <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="keywords"> + <rule pattern="(fallthrough|#selector|continue|default|repeat|switch|return|throw|catch|where|break|guard|defer|while|case|else|try|for|if|do|is|in|as)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="@availability\([^)]+\)"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(@UIApplicationMain|@NSApplicationMain|@IBInspectable|@availability|@IBDesignable|associativity|@autoclosure|convenience|nonmutating|@NSManaged|@NSCopying|precedence|@IBAction|@noreturn|@IBOutlet|override|optional|mutating|indirect|Protocol|rethrows|required|willSet|dynamic|postfix|unowned|throws|prefix|didSet|final|inout|@objc|infix|right|lazy|none|weak|Type|left|get|set)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(as|dynamicType|false|is|nil|self|Self|super|true|__COLUMN__|__FILE__|__FUNCTION__|__LINE__|_|#(?:file|line|column|function))\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="import\b"> + <token type="KeywordDeclaration"/> + <push state="module"/> + </rule> + <rule pattern="(class|enum|extension|struct|protocol)(\s+)([a-zA-Z_]\w*)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="(func)(\s+)([a-zA-Z_]\w*)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="(var|let)(\s+)([a-zA-Z_]\w*)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="Text"/> + <token type="NameVariable"/> + </bygroups> + </rule> + <rule pattern="(typealias|extension|subscript|internal|protocol|operator|private|public|struct|deinit|static|import|class|init|func|enum|let|var)\b"> + <token type="KeywordDeclaration"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/systemd.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/systemd.xml new file mode 100644 index 0000000..e31bfc2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/systemd.xml @@ -0,0 +1,63 @@ +<lexer> + <config> + <name>SYSTEMD</name> + <alias>systemd</alias> + <filename>*.automount</filename> + <filename>*.device</filename> + <filename>*.dnssd</filename> + <filename>*.link</filename> + <filename>*.mount</filename> + <filename>*.netdev</filename> + <filename>*.network</filename> + <filename>*.path</filename> + <filename>*.scope</filename> + <filename>*.service</filename> + <filename>*.slice</filename> + <filename>*.socket</filename> + <filename>*.swap</filename> + <filename>*.target</filename> + <filename>*.timer</filename> + <mime_type>text/plain</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[;#].*"> + <token type="Comment"/> + </rule> + <rule pattern="\[.*?\]$"> + <token type="Keyword"/> + </rule> + <rule pattern="(.*?)(=)(.*)(\\\n)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Operator"/> + <token type="LiteralString"/> + <token type="Text"/> + </bygroups> + <push state="continuation"/> + </rule> + <rule pattern="(.*?)(=)(.*)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Operator"/> + <token type="LiteralString"/> + </bygroups> + </rule> + </state> + <state name="continuation"> + <rule pattern="(.*?)(\\\n)"> + <bygroups> + <token type="LiteralString"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(.*)"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/systemverilog.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/systemverilog.xml new file mode 100644 index 0000000..fac3da2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/systemverilog.xml @@ -0,0 +1,181 @@ +<lexer> + <config> + <name>systemverilog</name> + <alias>systemverilog</alias> + <alias>sv</alias> + <filename>*.sv</filename> + <filename>*.svh</filename> + <mime_type>text/x-systemverilog</mime_type> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <state name="macro"> + <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="(?<=\\)\n"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="import"> + <rule pattern="[\w:]+\*?"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="^\s*`define"> + <token type="CommentPreproc"/> + <push state="macro"/> + </rule> + <rule pattern="^(\s*)(package)(\s+)"> + <bygroups> + <token type="Text"/> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="^(\s*)(import)(\s+)("DPI(?:-C)?")(\s+)"> + <bygroups> + <token type="Text"/> + <token type="KeywordNamespace"/> + <token type="Text"/> + <token type="LiteralString"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="^(\s*)(import)(\s+)"> + <bygroups> + <token type="Text"/> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="import"/> + </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)?/(\n|(.|\n)*?[^\\]\n)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/(\\\n)?[*](.|\n)*?[*](\\\n)?/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="[{}#@]"> + <token type="Punctuation"/> + </rule> + <rule pattern="L?""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+|\d+[fF])[fF]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="([0-9]+)|(\'h)[0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="([0-9]+)|(\'b)[01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="([0-9]+)|(\'d)[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="([0-9]+)|(\'o)[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="\'[01xz]"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="\d+[Ll]?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\*/"> + <token type="Error"/> + </rule> + <rule pattern="[~!%^&*+=|?:<>/-]"> + <token type="Operator"/> + </rule> + <rule pattern="[()\[\],.;\']"> + <token type="Punctuation"/> + </rule> + <rule pattern="`[a-zA-Z_]\w*"> + <token type="NameConstant"/> + </rule> + <rule pattern="(pulsestyle_ondetect|pulsestyle_onevent|noshowcancelled|sync_accept_on|sync_reject_on|showcancelled|timeprecision|endprimitive|randsequence|s_until_with|s_eventually|always_latch|endinterface|illegal_bins|macromodule|always_comb|endfunction|endproperty|first_match|endsequence|endgenerate|ignore_bins|endclocking|until_with|localparam|coverpoint|eventually|throughout|s_nexttime|endprogram|endspecify|endchecker|wait_order|constraint|covergroup|endpackage|endconfig|interface|accept_on|shortreal|parameter|primitive|intersect|protected|join_none|automatic|reject_on|always_ff|specparam|endmodule|shortint|join_any|endclass|sequence|defparam|scalared|deassign|endgroup|timeunit|instance|continue|restrict|clocking|nexttime|s_always|rtranif1|endtable|rtranif0|unsigned|priority|vectored|property|pulldown|wildcard|generate|function|realtime|forkjoin|randcase|context|forever|release|virtual|strong0|program|untyped|posedge|package|foreach|extends|specify|unique0|typedef|chandle|implies|checker|negedge|tranif1|initial|modport|strong1|matches|tranif0|endtask|integer|supply0|endcase|supply1|longint|disable|s_until|default|liblist|library|include|bufif0|design|tagged|struct|inside|medium|signed|config|highz1|incdir|import|expect|triand|trireg|export|unique|notif0|notif1|return|ifnone|output|highz0|packed|bufif1|repeat|global|genvar|binsof|extern|string|before|static|assume|assign|pullup|assert|always|within|strong|module|final|union|rcmos|casex|casez|trior|alias|pull1|pull0|break|uwire|randc|rnmos|rpmos|rtran|class|const|cover|weak1|until|logic|local|weak0|large|table|force|input|inout|small|solve|begin|super|event|while|cross|void|fork|enum|wait|cmos|bind|else|edge|join|nand|task|this|dist|time|cell|nmos|tran|wand|wire|bins|with|tri1|pmos|xnor|pure|type|real|rand|case|byte|weak|tri0|null|int|use|ref|var|tri|end|for|wor|iff|xor|bit|let|new|nor|and|not|reg|buf|or|if|do)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(`nounconnected_drive|`unconnected_drive|`default_nettype|`begin_keywords|`endcelldefine|`end_keywords|`undefineall|`celldefine|`timescale|`__LINE__|`resetall|`__FILE__|`include|`ifndef|`pragma|`define|`undef|`endif|`elsif|`ifdef|`else|`line)\b"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="(\$dumpportsflush|\$dumpportslimit|\$value\$plusargs|\$dumpportsoff|\$dumpportsall|\$dumpportson|\$monitoroff|\$writememb|\$fdisplayo|\$fdisplayh|\$dumpports|\$dumplimit|\$dumpflush|\$fmonitorb|\$fmonitoro|\$monitoron|\$fdisplayb|\$writememh|\$fmonitorh|\$readmemb|\$fdisplay|\$monitorh|\$dumpfile|\$sformatf|\$monitorb|\$monitoro|\$displayb|\$plusargs|\$fmonitor|\$displayo|\$fstrobeo|\$displayh|\$fstrobeh|\$fstrobeb|\$readmemh|\$dumpvars|\$fstrobe|\$sformat|\$strobeb|\$swriteh|\$strobeh|\$strobeo|\$swriteb|\$fwriteh|\$fwriteo|\$monitor|\$dumpall|\$dumpoff|\$fwriteb|\$display|\$swriteo|\$fflush|\$random|\$dumpon|\$fscanf|\$rewind|\$writeh|\$writeo|\$sscanf|\$strobe|\$writeb|\$finish|\$ungetc|\$fclose|\$ferror|\$swrite|\$fwrite|\$fgetc|\$fseek|\$fgets|\$write|\$fopen|\$fread|\$ftell|\$test|\$feof)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(class)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="classname"/> + </rule> + <rule pattern="(woshortreal|shortint|realtime|longint|integer|supply0|supply1|triand|trireg|uwire|logic|trior|byte|wand|tri0|tri1|time|real|wire|reg|bit|int|tri)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[a-zA-Z_]\w*:(?!:)"> + <token type="NameLabel"/> + </rule> + <rule pattern="\$?[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="classname"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tablegen.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tablegen.xml new file mode 100644 index 0000000..a020ce8 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tablegen.xml @@ -0,0 +1,69 @@ +<lexer> + <config> + <name>TableGen</name> + <alias>tablegen</alias> + <filename>*.td</filename> + <mime_type>text/x-tablegen</mime_type> + </config> + <rules> + <state name="whitespace"> + <rule pattern="(\n|\s)+"> + <token type="Text"/> + </rule> + <rule pattern="//.*?\n"> + <token type="Comment"/> + </rule> + </state> + <state name="keyword"> + <rule pattern="(multiclass|foreach|string|class|field|defm|bits|code|list|def|int|let|dag|bit|in)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="macro"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="c?"[^"]*?""> + <token type="LiteralString"/> + </rule> + <rule> + <include state="keyword"/> + </rule> + <rule pattern="\$[_a-zA-Z][_\w]*"> + <token type="NameVariable"/> + </rule> + <rule pattern="\d*[_a-zA-Z][_\w]*"> + <token type="NameVariable"/> + </rule> + <rule pattern="\[\{[\w\W]*?\}\]"> + <token type="LiteralString"/> + </rule> + <rule pattern="[+-]?\d+|0x[\da-fA-F]+|0b[01]+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[=<>{}\[\]()*.,!:;]"> + <token type="Punctuation"/> + </rule> + </state> + <state name="macro"> + <rule pattern="(#include\s+)("[^"]*")"> + <bygroups> + <token type="CommentPreproc"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="^\s*#(ifdef|ifndef)\s+[_\w][_\w\d]*"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="^\s*#define\s+[_\w][_\w\d]*"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="^\s*#endif"> + <token type="CommentPreproc"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tasm.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tasm.xml new file mode 100644 index 0000000..1347f53 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tasm.xml @@ -0,0 +1,135 @@ +<lexer> + <config> + <name>TASM</name> + <alias>tasm</alias> + <filename>*.asm</filename> + <filename>*.ASM</filename> + <filename>*.tasm</filename> + <mime_type>text/x-tasm</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="preproc"> + <rule pattern="[^;\n]+"> + <token type="CommentPreproc"/> + </rule> + <rule pattern=";.*?\n"> + <token type="CommentSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="[\n\r]"> + <token type="Text"/> + </rule> + <rule pattern="\\[\n\r]"> + <token type="Text"/> + </rule> + <rule pattern="[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern=";.*"> + <token type="CommentSingle"/> + </rule> + </state> + <state name="punctuation"> + <rule pattern="[,():\[\]]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="[&|^<>+*=/%~-]+"> + <token type="Operator"/> + </rule> + <rule pattern="[$]+"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="seg|wrt|strict"> + <token type="OperatorWord"/> + </rule> + <rule pattern="byte|[dq]?word"> + <token type="KeywordType"/> + </rule> + </state> + <state name="root"> + <rule pattern="^\s*%"> + <token type="CommentPreproc"/> + <push state="preproc"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="[@a-z$._?][\w$.?#@~]*:"> + <token type="NameLabel"/> + </rule> + <rule pattern="BITS|USE16|USE32|SECTION|SEGMENT|ABSOLUTE|EXTERN|GLOBAL|ORG|ALIGN|STRUC|ENDSTRUC|ENDS|COMMON|CPU|GROUP|UPPERCASE|INCLUDE|EXPORT|LIBRARY|MODULE|PROC|ENDP|USES|ARG|DATASEG|UDATASEG|END|IDEAL|P386|MODEL|ASSUME|CODESEG|SIZE"> + <token type="Keyword"/> + <push state="instruction-args"/> + </rule> + <rule pattern="([@a-z$._?][\w$.?#@~]*)(\s+)(db|dd|dw|T[A-Z][a-z]+)"> + <bygroups> + <token type="NameConstant"/> + <token type="KeywordDeclaration"/> + <token type="KeywordDeclaration"/> + </bygroups> + <push state="instruction-args"/> + </rule> + <rule pattern="(?:res|d)[bwdqt]|times"> + <token type="KeywordDeclaration"/> + <push state="instruction-args"/> + </rule> + <rule pattern="[@a-z$._?][\w$.?#@~]*"> + <token type="NameFunction"/> + <push state="instruction-args"/> + </rule> + <rule pattern="[\r\n]+"> + <token type="Text"/> + </rule> + </state> + <state name="instruction-args"> + <rule pattern=""(\\"|[^"\n])*"|'(\\'|[^'\n])*'|`(\\`|[^`\n])*`"> + <token type="LiteralString"/> + </rule> + <rule pattern="(?:0x[0-9a-f]+|$0[0-9a-f]*|[0-9]+[0-9a-f]*h)"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-7]+q"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="[01]+b"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="[0-9]+\.e?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule> + <include state="punctuation"/> + </rule> + <rule pattern="r[0-9][0-5]?[bwd]|[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[@a-z$._?][\w$.?#@~]*"> + <token type="NameVariable"/> + </rule> + <rule pattern="(\\\s*)(;.*)([\r\n])"> + <bygroups> + <token type="Text"/> + <token type="CommentSingle"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="[\r\n]+"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule> + <include state="whitespace"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tcl.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tcl.xml new file mode 100644 index 0000000..7ed69bc --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tcl.xml @@ -0,0 +1,272 @@ +<lexer> + <config> + <name>Tcl</name> + <alias>tcl</alias> + <filename>*.tcl</filename> + <filename>*.rvt</filename> + <mime_type>text/x-tcl</mime_type> + <mime_type>text/x-script.tcl</mime_type> + <mime_type>application/x-tcl</mime_type> + </config> + <rules> + <state name="command-in-bracket"> + <rule pattern="\b(namespace|continue|variable|uplevel|foreach|return|update|elseif|global|rename|switch|upvar|error|vwait|catch|break|unset|array|apply|trace|after|while|then|else|expr|eval|proc|for|set|if)\b"> + <token type="Keyword"/> + <push state="params-in-bracket"/> + </rule> + <rule pattern="\b(platform::shell|pkg::create|pkg_mkIndex|fconfigure|re_syntax|fileevent|platform|fblocked|lreverse|mathfunc|encoding|registry|lreplace|history|bgerror|llength|lsearch|linsert|lassign|lappend|refchan|unknown|package|lrepeat|msgcat|mathop|format|interp|lrange|string|source|lindex|socket|concat|regsub|regexp|loadTk|memory|binary|append|unload|subst|split|lsort|clock|close|flush|fcopy|chan|glob|time|gets|http|dict|file|puts|tell|join|read|exit|exec|open|list|scan|seek|incr|info|lset|load|dde|pwd|pid|eof|tm|cd)\b"> + <token type="NameBuiltin"/> + <push state="params-in-bracket"/> + </rule> + <rule pattern="([\w.-]+)"> + <token type="NameVariable"/> + <push state="params-in-bracket"/> + </rule> + <rule pattern="#"> + <token type="Comment"/> + <push state="comment"/> + </rule> + </state> + <state name="command-in-paren"> + <rule pattern="\b(namespace|continue|variable|uplevel|foreach|return|update|elseif|global|rename|switch|upvar|error|vwait|catch|break|unset|array|apply|trace|after|while|then|else|expr|eval|proc|for|set|if)\b"> + <token type="Keyword"/> + <push state="params-in-paren"/> + </rule> + <rule pattern="\b(platform::shell|pkg::create|pkg_mkIndex|fconfigure|re_syntax|fileevent|platform|fblocked|lreverse|mathfunc|encoding|registry|lreplace|history|bgerror|llength|lsearch|linsert|lassign|lappend|refchan|unknown|package|lrepeat|msgcat|mathop|format|interp|lrange|string|source|lindex|socket|concat|regsub|regexp|loadTk|memory|binary|append|unload|subst|split|lsort|clock|close|flush|fcopy|chan|glob|time|gets|http|dict|file|puts|tell|join|read|exit|exec|open|list|scan|seek|incr|info|lset|load|dde|pwd|pid|eof|tm|cd)\b"> + <token type="NameBuiltin"/> + <push state="params-in-paren"/> + </rule> + <rule pattern="([\w.-]+)"> + <token type="NameVariable"/> + <push state="params-in-paren"/> + </rule> + <rule pattern="#"> + <token type="Comment"/> + <push state="comment"/> + </rule> + </state> + <state name="command-in-brace"> + <rule pattern="\b(namespace|continue|variable|uplevel|foreach|return|update|elseif|global|rename|switch|upvar|error|vwait|catch|break|unset|array|apply|trace|after|while|then|else|expr|eval|proc|for|set|if)\b"> + <token type="Keyword"/> + <push state="params-in-brace"/> + </rule> + <rule pattern="\b(platform::shell|pkg::create|pkg_mkIndex|fconfigure|re_syntax|fileevent|platform|fblocked|lreverse|mathfunc|encoding|registry|lreplace|history|bgerror|llength|lsearch|linsert|lassign|lappend|refchan|unknown|package|lrepeat|msgcat|mathop|format|interp|lrange|string|source|lindex|socket|concat|regsub|regexp|loadTk|memory|binary|append|unload|subst|split|lsort|clock|close|flush|fcopy|chan|glob|time|gets|http|dict|file|puts|tell|join|read|exit|exec|open|list|scan|seek|incr|info|lset|load|dde|pwd|pid|eof|tm|cd)\b"> + <token type="NameBuiltin"/> + <push state="params-in-brace"/> + </rule> + <rule pattern="([\w.-]+)"> + <token type="NameVariable"/> + <push state="params-in-brace"/> + </rule> + <rule pattern="#"> + <token type="Comment"/> + <push state="comment"/> + </rule> + </state> + <state name="basic"> + <rule pattern="\("> + <token type="Keyword"/> + <push state="paren"/> + </rule> + <rule pattern="\["> + <token type="Keyword"/> + <push state="bracket"/> + </rule> + <rule pattern="\{"> + <token type="Keyword"/> + <push state="brace"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="(eq|ne|in|ni)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="!=|==|<<|>>|<=|>=|&&|\|\||\*\*|[-+~!*/%<>&^|?:]"> + <token type="Operator"/> + </rule> + </state> + <state name="params-in-bracket"> + <rule pattern="\]"> + <token type="Keyword"/> + <push state="#pop" state="#pop"/> + </rule> + <rule> + <include state="params"/> + </rule> + </state> + <state name="data"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="0x[a-fA-F0-9]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="0[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="\d+\.\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\$([\w.:-]+)"> + <token type="NameVariable"/> + </rule> + <rule pattern="([\w.:-]+)"> + <token type="Text"/> + </rule> + </state> + <state name="command"> + <rule pattern="\b(namespace|continue|variable|uplevel|foreach|return|update|elseif|global|rename|switch|upvar|error|vwait|catch|break|unset|array|apply|trace|after|while|then|else|expr|eval|proc|for|set|if)\b"> + <token type="Keyword"/> + <push state="params"/> + </rule> + <rule pattern="\b(platform::shell|pkg::create|pkg_mkIndex|fconfigure|re_syntax|fileevent|platform|fblocked|lreverse|mathfunc|encoding|registry|lreplace|history|bgerror|llength|lsearch|linsert|lassign|lappend|refchan|unknown|package|lrepeat|msgcat|mathop|format|interp|lrange|string|source|lindex|socket|concat|regsub|regexp|loadTk|memory|binary|append|unload|subst|split|lsort|clock|close|flush|fcopy|chan|glob|time|gets|http|dict|file|puts|tell|join|read|exit|exec|open|list|scan|seek|incr|info|lset|load|dde|pwd|pid|eof|tm|cd)\b"> + <token type="NameBuiltin"/> + <push state="params"/> + </rule> + <rule pattern="([\w.-]+)"> + <token type="NameVariable"/> + <push state="params"/> + </rule> + <rule pattern="#"> + <token type="Comment"/> + <push state="comment"/> + </rule> + </state> + <state name="params-in-brace"> + <rule pattern="\}"> + <token type="Keyword"/> + <push state="#pop" state="#pop"/> + </rule> + <rule> + <include state="params"/> + </rule> + </state> + <state name="string-square"> + <rule pattern="\["> + <token type="LiteralStringDouble"/> + <push state="string-square"/> + </rule> + <rule pattern="(?s)(\\\\|\\[0-7]+|\\.|\\\n|[^\]\\])"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\]"> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + <state name="bracket"> + <rule pattern="\]"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <include state="command-in-bracket"/> + </rule> + <rule> + <include state="basic"/> + </rule> + <rule> + <include state="data"/> + </rule> + </state> + <state name="params-in-paren"> + <rule pattern="\)"> + <token type="Keyword"/> + <push state="#pop" state="#pop"/> + </rule> + <rule> + <include state="params"/> + </rule> + </state> + <state name="paren"> + <rule pattern="\)"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <include state="command-in-paren"/> + </rule> + <rule> + <include state="basic"/> + </rule> + <rule> + <include state="data"/> + </rule> + </state> + <state name="comment"> + <rule pattern=".*[^\\]\n"> + <token type="Comment"/> + <pop depth="1"/> + </rule> + <rule pattern=".*\\\n"> + <token type="Comment"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="command"/> + </rule> + <rule> + <include state="basic"/> + </rule> + <rule> + <include state="data"/> + </rule> + <rule pattern="\}"> + <token type="Keyword"/> + </rule> + </state> + <state name="brace"> + <rule pattern="\}"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <include state="command-in-brace"/> + </rule> + <rule> + <include state="basic"/> + </rule> + <rule> + <include state="data"/> + </rule> + </state> + <state name="params"> + <rule pattern=";"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern="(else|elseif|then)\b"> + <token type="Keyword"/> + </rule> + <rule> + <include state="basic"/> + </rule> + <rule> + <include state="data"/> + </rule> + </state> + <state name="string"> + <rule pattern="\["> + <token type="LiteralStringDouble"/> + <push state="string-square"/> + </rule> + <rule pattern="(?s)(\\\\|\\[0-7]+|\\.|[^"\\])"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tcsh.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tcsh.xml new file mode 100644 index 0000000..9895643 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tcsh.xml @@ -0,0 +1,121 @@ +<lexer> + <config> + <name>Tcsh</name> + <alias>tcsh</alias> + <alias>csh</alias> + <filename>*.tcsh</filename> + <filename>*.csh</filename> + <mime_type>application/x-csh</mime_type> + </config> + <rules> + <state name="basic"> + <rule pattern="\b(if|endif|else|while|then|foreach|case|default|continue|goto|breaksw|end|switch|endsw)\s*\b"> + <token type="Keyword"/> + </rule> + <rule pattern="\b(alias|alloc|bg|bindkey|break|builtins|bye|caller|cd|chdir|complete|dirs|echo|echotc|eval|exec|exit|fg|filetest|getxvers|glob|getspath|hashstat|history|hup|inlib|jobs|kill|limit|log|login|logout|ls-F|migrate|newgrp|nice|nohup|notify|onintr|popd|printenv|pushd|rehash|repeat|rootnode|popd|pushd|set|shift|sched|setenv|setpath|settc|setty|setxvers|shift|source|stop|suspend|source|suspend|telltc|time|umask|unalias|uncomplete|unhash|universe|unlimit|unset|unsetenv|ver|wait|warp|watchlog|where|which)\s*\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="#.*"> + <token type="Comment"/> + </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="<<\s*(\'?)\\?(\w+)[\w\W]+?\2"> + <token type="LiteralString"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + </rule> + </state> + <state name="data"> + <rule pattern="(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[^=\s\[\]{}()$"\'`\\;#]+"> + <token type="Text"/> + </rule> + <rule pattern="\d+(?= |\Z)"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="\$#?(\w+|.)"> + <token type="NameVariable"/> + </rule> + </state> + <state name="curly"> + <rule pattern="\}"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule pattern=":-"> + <token type="Keyword"/> + </rule> + <rule pattern="\w+"> + <token type="NameVariable"/> + </rule> + <rule pattern="[^}:"\'`$]+"> + <token type="Punctuation"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="paren"> + <rule pattern="\)"> + <token type="Keyword"/> + <pop depth="1"/> + </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="Keyword"/> + <push state="paren"/> + </rule> + <rule pattern="\$\{#?"> + <token type="Keyword"/> + <push state="curly"/> + </rule> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <push state="backticks"/> + </rule> + <rule> + <include state="data"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/termcap.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/termcap.xml new file mode 100644 index 0000000..e863bbd --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/termcap.xml @@ -0,0 +1,75 @@ +<lexer> + <config> + <name>Termcap</name> + <alias>termcap</alias> + <filename>termcap</filename> + <filename>termcap.src</filename> + </config> + <rules> + <state name="defs"> + <rule pattern="\\\n[ \t]*"> + <token type="Text"/> + </rule> + <rule pattern="\n[ \t]*"> + <token type="Text"/> + <pop depth="2"/> + </rule> + <rule pattern="(#)([0-9]+)"> + <bygroups> + <token type="Operator"/> + <token type="LiteralNumber"/> + </bygroups> + </rule> + <rule pattern="="> + <token type="Operator"/> + <push state="data"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + </rule> + <rule pattern="[^\s:=#]+"> + <token type="NameClass"/> + </rule> + </state> + <state name="data"> + <rule pattern="\\072"> + <token type="Literal"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule pattern="[^:\\]+"> + <token type="Literal"/> + </rule> + <rule pattern="."> + <token type="Literal"/> + </rule> + </state> + <state name="root"> + <rule pattern="^#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="^[^\s#:|]+"> + <token type="NameTag"/> + <push state="names"/> + </rule> + </state> + <state name="names"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern=":"> + <token type="Punctuation"/> + <push state="defs"/> + </rule> + <rule pattern="\|"> + <token type="Punctuation"/> + </rule> + <rule pattern="[^:|]+"> + <token type="NameAttribute"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/terminfo.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/terminfo.xml new file mode 100644 index 0000000..9e8f56e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/terminfo.xml @@ -0,0 +1,84 @@ +<lexer> + <config> + <name>Terminfo</name> + <alias>terminfo</alias> + <filename>terminfo</filename> + <filename>terminfo.src</filename> + </config> + <rules> + <state name="names"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + <rule pattern="(,)([ \t]*)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + <push state="defs"/> + </rule> + <rule pattern="\|"> + <token type="Punctuation"/> + </rule> + <rule pattern="[^,|]+"> + <token type="NameAttribute"/> + </rule> + </state> + <state name="defs"> + <rule pattern="\n[ \t]+"> + <token type="Text"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="2"/> + </rule> + <rule pattern="(#)([0-9]+)"> + <bygroups> + <token type="Operator"/> + <token type="LiteralNumber"/> + </bygroups> + </rule> + <rule pattern="="> + <token type="Operator"/> + <push state="data"/> + </rule> + <rule pattern="(,)([ \t]*)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="[^\s,=#]+"> + <token type="NameClass"/> + </rule> + </state> + <state name="data"> + <rule pattern="\\[,\\]"> + <token type="Literal"/> + </rule> + <rule pattern="(,)([ \t]*)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + <pop depth="1"/> + </rule> + <rule pattern="[^\\,]+"> + <token type="Literal"/> + </rule> + <rule pattern="."> + <token type="Literal"/> + </rule> + </state> + <state name="root"> + <rule pattern="^#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="^[^\s#,|]+"> + <token type="NameTag"/> + <push state="names"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/terraform.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/terraform.xml new file mode 100644 index 0000000..452f211 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/terraform.xml @@ -0,0 +1,140 @@ +<lexer> + <config> + <name>Terraform</name> + <alias>terraform</alias> + <alias>tf</alias> + <filename>*.tf</filename> + <mime_type>application/x-tf</mime_type> + <mime_type>application/x-terraform</mime_type> + </config> + <rules> + <state name="string"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\\\\""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="interp-inside"/> + </rule> + <rule pattern="\$"> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="[^"\\\\$]+"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="interp-inside"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="root"> + <rule pattern="[\[\](),.{}]"> + <token type="Punctuation"/> + </rule> + <rule pattern="-?[0-9]+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="=>"> + <token type="Punctuation"/> + </rule> + <rule pattern="(false|true)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="/(?s)\*(((?!\*/).)*)\*/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="\s*(#|//).*\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="([a-zA-Z]\w*)(\s*)(=(?!>))"> + <bygroups> + <token type="NameAttribute"/> + <token type="Text"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="^\s*(provisioner|variable|resource|provider|module|output|data)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(for|in)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(module|count|data|each|var)"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(parseint|signum|floor|ceil|log|max|min|abs|pow)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(trimsuffix|formatlist|trimprefix|trimspace|regexall|replace|indent|strrev|format|substr|chomp|split|title|regex|lower|upper|trim|join)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[^.](setintersection|coalescelist|setsubtract|setproduct|matchkeys|chunklist|transpose|contains|distinct|coalesce|setunion|reverse|flatten|element|compact|lookup|length|concat|values|zipmap|range|merge|slice|index|list|sort|keys|map)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[^.](base64decode|base64encode|base64gzip|jsondecode|jsonencode|yamldecode|yamlencode|csvdecode|urlencode)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(templatefile|filebase64|fileexists|pathexpand|basename|abspath|fileset|dirname|file)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(formatdate|timestamp|timeadd)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(filebase64sha256|filebase64sha512|base64sha512|base64sha256|filesha256|rsadecrypt|filesha512|filesha1|filemd5|uuidv5|bcrypt|sha256|sha512|sha1|uuid|md5)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(cidrnetmask|cidrsubnet|cidrhost)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(tostring|tonumber|tobool|tolist|tomap|toset|can|try)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="=(?!>)|\+|-|\*|\/|:|!|%|>|<(?!<)|>=|<=|==|!=|&&|\||\?"> + <token type="Operator"/> + </rule> + <rule pattern="\n|\s+|\\\n"> + <token type="Text"/> + </rule> + <rule pattern="[a-zA-Z]\w*"> + <token type="NameOther"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <push state="string"/> + </rule> + <rule pattern="(?s)(<<-?)(\w+)(\n\s*(?:(?!\2).)*\s*\n\s*)(\2)"> + <bygroups> + <token type="Operator"/> + <token type="Operator"/> + <token type="LiteralString"/> + <token type="Operator"/> + </bygroups> + </rule> + </state> + <state name="declaration"> + <rule pattern="(\s*)("(?:\\\\|\\"|[^"])*")(\s*)"> + <bygroups> + <token type="Text"/> + <token type="NameVariable"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="\{"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tex.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tex.xml new file mode 100644 index 0000000..809bb9a --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tex.xml @@ -0,0 +1,113 @@ +<lexer> + <config> + <name>TeX</name> + <alias>tex</alias> + <alias>latex</alias> + <filename>*.tex</filename> + <filename>*.aux</filename> + <filename>*.toc</filename> + <mime_type>text/x-tex</mime_type> + <mime_type>text/x-latex</mime_type> + </config> + <rules> + <state name="displaymath"> + <rule pattern="\\\]"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\$\$"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\$"> + <token type="NameBuiltin"/> + </rule> + <rule> + <include state="math"/> + </rule> + </state> + <state name="command"> + <rule pattern="\[.*?\]"> + <token type="NameAttribute"/> + </rule> + <rule pattern="\*"> + <token type="Keyword"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="general"> + <rule pattern="%.*?\n"> + <token type="Comment"/> + </rule> + <rule pattern="[{}]"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[&_^]"> + <token type="NameBuiltin"/> + </rule> + </state> + <state name="root"> + <rule pattern="\\\["> + <token type="LiteralStringBacktick"/> + <push state="displaymath"/> + </rule> + <rule pattern="\\\("> + <token type="LiteralString"/> + <push state="inlinemath"/> + </rule> + <rule pattern="\$\$"> + <token type="LiteralStringBacktick"/> + <push state="displaymath"/> + </rule> + <rule pattern="\$"> + <token type="LiteralString"/> + <push state="inlinemath"/> + </rule> + <rule pattern="\\([a-zA-Z]+|.)"> + <token type="Keyword"/> + <push state="command"/> + </rule> + <rule pattern="\\$"> + <token type="Keyword"/> + </rule> + <rule> + <include state="general"/> + </rule> + <rule pattern="[^\\$%&_^{}]+"> + <token type="Text"/> + </rule> + </state> + <state name="math"> + <rule pattern="\\([a-zA-Z]+|.)"> + <token type="NameVariable"/> + </rule> + <rule> + <include state="general"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="[-=!+*/()\[\]]"> + <token type="Operator"/> + </rule> + <rule pattern="[^=!+*/()\[\]\\$%&_^{}0-9-]+"> + <token type="NameBuiltin"/> + </rule> + </state> + <state name="inlinemath"> + <rule pattern="\\\)"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\$"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <include state="math"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/thrift.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/thrift.xml new file mode 100644 index 0000000..f14257d --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/thrift.xml @@ -0,0 +1,154 @@ +<lexer> + <config> + <name>Thrift</name> + <alias>thrift</alias> + <filename>*.thrift</filename> + <mime_type>application/x-thrift</mime_type> + </config> + <rules> + <state name="class"> + <rule pattern="[a-zA-Z_]\w*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(async|oneway|extends|throws|required|optional)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(const|typedef)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(smalltalk_category|smalltalk_prefix|delphi_namespace|csharp_namespace|ruby_namespace|xsd_namespace|cpp_namespace|php_namespace|xsd_nillable|xsd_optional|java_package|cocoa_prefix|perl_package|cpp_include|py_module|xsd_attrs|cpp_type|xsd_all|include)\b"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="(double|binary|string|slist|senum|bool|void|byte|list|i64|map|set|i32|i16)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="\b(__NAMESPACE__|synchronized|__FUNCTION__|__METHOD__|endforeach|implements|enddeclare|instanceof|transient|endswitch|protected|interface|__CLASS__|continue|__FILE__|abstract|function|endwhile|unsigned|register|volatile|__LINE__|declare|foreach|default|__DIR__|private|finally|dynamic|virtual|lambda|elseif|inline|switch|unless|endfor|delete|import|return|module|ensure|native|rescue|assert|sizeof|static|global|except|public|float|BEGIN|super|endif|yield|elsif|throw|clone|class|catch|until|break|retry|begin|raise|alias|while|print|undef|exec|with|when|case|redo|args|elif|this|then|self|goto|else|pass|next|var|for|xor|END|not|try|del|and|def|new|use|nil|end|if|do|is|or|in|as)\b"> + <token type="KeywordReserved"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="[+-]?(\d+\.\d+([eE][+-]?\d+)?|\.?\d+[eE][+-]?\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+-]?0x[0-9A-Fa-f]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[+-]?[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule> + <include state="comments"/> + </rule> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <combined state="stringescape" state="dqs"/> + </rule> + <rule pattern="\'"> + <token type="LiteralStringSingle"/> + <combined state="stringescape" state="sqs"/> + </rule> + <rule pattern="(namespace)(\s+)"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="TextWhitespace"/> + </bygroups> + <push state="namespace"/> + </rule> + <rule pattern="(enum|union|struct|service|exception)(\s+)"> + <bygroups> + <token type="KeywordDeclaration"/> + <token type="TextWhitespace"/> + </bygroups> + <push state="class"/> + </rule> + <rule pattern="((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\s+)+?)((?:[^\W\d]|\$)[\w$]*)(\s*)(\()"> + <bygroups> + <usingself state="root"/> + <token type="NameFunction"/> + <token type="Text"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule pattern="[&=]"> + <token type="Operator"/> + </rule> + <rule pattern="[:;,{}()<>\[\]]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[a-zA-Z_](\.\w|\w)*"> + <token type="Name"/> + </rule> + </state> + <state name="dqs"> + <rule pattern="""> + <token type="LiteralStringDouble"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\\"\n]+"> + <token type="LiteralStringDouble"/> + </rule> + </state> + <state name="namespace"> + <rule pattern="[a-z*](\.\w|\w)*"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\n"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + </state> + <state name="comments"> + <rule pattern="#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="//.*?\n"> + <token type="Comment"/> + </rule> + <rule pattern="/\*[\w\W]*?\*/"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="stringescape"> + <rule pattern="\\([\\nrt"\'])"> + <token type="LiteralStringEscape"/> + </rule> + </state> + <state name="sqs"> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\\\'\n]+"> + <token type="LiteralStringSingle"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/toml.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/toml.xml new file mode 100644 index 0000000..3598cd7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/toml.xml @@ -0,0 +1,42 @@ +<lexer> + <config> + <name>TOML</name> + <alias>toml</alias> + <filename>*.toml</filename> + <mime_type>text/x-toml</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="#.*"> + <token type="Comment"/> + </rule> + <rule pattern="(false|true)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="\d\d\d\d-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d\+)?(Z|[+-]\d{2}:\d{2})"> + <token type="LiteralDate"/> + </rule> + <rule pattern="[+-]?[0-9](_?\d)*\.\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+-]?[0-9](_?\d)*"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="[.,=\[\]{}]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[A-Za-z0-9_-]+"> + <token type="NameOther"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tradingview.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tradingview.xml new file mode 100644 index 0000000..3671f61 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/tradingview.xml @@ -0,0 +1,81 @@ +<lexer> + <config> + <name>TradingView</name> + <alias>tradingview</alias> + <alias>tv</alias> + <filename>*.tv</filename> + <mime_type>text/x-tradingview</mime_type> + <dot_all>true</dot_all> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <state name="root"> + <rule pattern="[^\S\n]+|\n|[()]"> + <token type="Text"/> + </rule> + <rule pattern="(//.*?)(\n)"> + <bygroups> + <token type="CommentSingle"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern=">=|<=|==|!=|>|<|\?|-|\+|\*|\/|%|\[|\]"> + <token type="Operator"/> + </rule> + <rule pattern="[:,.]"> + <token type="Punctuation"/> + </rule> + <rule pattern="="> + <token type="KeywordPseudo"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"\n])*["\n]"> + <token type="LiteralString"/> + </rule> + <rule pattern="'\\.'|'[^\\]'"> + <token type="LiteralString"/> + </rule> + <rule pattern="[0-9](\.[0-9]*)?([eE][+-][0-9]+)?"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="#[a-fA-F0-9]{8}|#[a-fA-F0-9]{6}|#[a-fA-F0-9]{3}"> + <token type="LiteralStringOther"/> + </rule> + <rule pattern="(abs|acos|alertcondition|alma|asin|atan|atr|avg|barcolor|barssince|bgcolor|cci|ceil|change|cog|color\.new|correlation|cos|crossover|crossunder|cum|dev|ema|exp|falling|fill|fixnan|floor|heikinashi|highest|highestbars|hline|iff|kagi|label\.(delete|get_text|get_x|get_y|new|set_color|set_size|set_style|set_text|set_textcolor|set_x|set_xloc|set_xy|set_y|set_yloc)|line\.(new|delete|get_x1|get_x2|get_y1|get_y2|set_color|set_width|set_style|set_extend|set_xy1|set_xy2|set_x1|set_x2|set_y1|set_y2|set_xloc)|linebreak|linreg|log|log10|lowest|lowestbars|macd|max|max_bars_back|min|mom|nz|percentile_(linear_interpolation|nearest_rank)|percentrank|pivothigh|pivotlow|plot|plotarrow|plotbar|plotcandle|plotchar|plotshape|pointfigure|pow|renko|rising|rma|roc|round|rsi|sar|security|sign|sin|sma|sqrt|stdev|stoch|study|sum|swma|tan|timestamp|tostring|tsi|valuewhen|variance|vwma|wma|strategy\.(cancel|cancel_all|close|close_all|entry|exit|order|risk\.(allow_entry_in|max_cons_loss_days|max_drawdown|max_intraday_filled_orders|max_intraday_loss|max_position_size)))\b"> + <token type="NameFunction"/> + </rule> + <rule pattern="\b(bool|color|cross|dayofmonth|dayofweek|float|hour|input|int|label|line|minute|month|na|offset|second|strategy|string|tickerid|time|tr|vwap|weekofyear|year)(\()"> + <bygroups> + <token type="NameFunction"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(accdist|adjustment\.(dividends|none|splits)|aqua|area|areabr|bar_index|black|blue|bool|circles|close|columns|currency\.(AUD|CAD|CHF|EUR|GBP|HKD|JPY|NOK|NONE|NZD|RUB|SEK|SGD|TRY|USD|ZAR)|color\.(aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)|dashed|dotted|dayofweek\.(monday|tuesday|wednesday|thursday|friday|saturday|sunday)|extend\.(both|left|right|none)|float|format\.(inherit|price|volume)|friday|fuchsia|gray|green|high|histogram|hl2|hlc3|hline\.style_(dotted|solid|dashed)|input\.(bool|float|integer|resolution|session|source|string|symbol)|integer|interval|isdaily|isdwm|isintraday|ismonthly|isweekly|label\.style_(arrowdown|arrowup|circle|cross|diamond|flag|labeldown|labelup|none|square|triangledown|triangleup|xcross)|lime|line\.style_(dashed|dotted|solid|arrow_both|arrow_left|arrow_right)|linebr|location\.(abovebar|absolute|belowbar|bottom|top)|low|maroon|monday|n|navy|ohlc4|olive|open|orange|period|plot\.style_(area|areabr|circles|columns|cross|histogram|line|linebr|stepline)|purple|red|resolution|saturday|scale\.(left|none|right)|session|session\.(extended|regular)|silver|size\.(auto|huge|large|normal|small|tiny)|solid|source|stepline|string|sunday|symbol|syminfo\.(mintick|pointvalue|prefix|root|session|ticker|tickerid|timezone)|teal|thursday|ticker|timeframe\.(isdaily|isdwm|isintraday|ismonthly|isweekly|multiplier|period)|timenow|tuesday|volume|wednesday|white|yellow|strategy\.(cash|closedtrades|commission\.(cash_per_contract|cash_per_order|percent)|direction\.(all|long|short)|equity|eventrades|fixed|grossloss|grossprofit|initial_capital|long|losstrades|max_contracts_held_(all|long|short)|max_drawdown|netprofit|oca\.(cancel|none|reduce)|openprofit|opentrades|percent_of_equity|position_avg_price|position_entry_name|position_size|short|wintrades)|shape\.(arrowdown|arrowup|circle|cross|diamond|flag|labeldown|labelup|square|triangledown|triangleup|xcross)|barstate\.is(first|history|last|new|realtime)|barmerge\.(gaps_on|gaps_off|lookahead_on|lookahead_off)|xloc\.bar_(index|time)|yloc\.(abovebar|belowbar|price))\b"> + <token type="NameVariable"/> + </rule> + <rule pattern="(cross|dayofmonth|dayofweek|hour|minute|month|na|second|tickerid|time|tr|vwap|weekofyear|year)(\b[^\(])"> + <bygroups> + <token type="NameVariable"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(int|float|bool|color|string|label|line)(\b[^\(=.])"> + <bygroups> + <token type="KeywordType"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="(var)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(and|or|not|if|else|for|to)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="@?[_a-zA-Z]\w*"> + <token type="Text"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/transact-sql.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/transact-sql.xml new file mode 100644 index 0000000..1c9f38e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/transact-sql.xml @@ -0,0 +1,137 @@ +<lexer> + <config> + <name>Transact-SQL</name> + <alias>tsql</alias> + <alias>t-sql</alias> + <mime_type>text/x-tsql</mime_type> + <case_insensitive>true</case_insensitive> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="--(?m).*?$\n?"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="multiline-comments"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <push state="string"/> + </rule> + <rule pattern="""> + <token type="LiteralStringName"/> + <push state="quoted-ident"/> + </rule> + <rule pattern="(\*=|!=|!>|\^=|<=|<>|\|=|&=|>=|%=|\+=|/=|-=|!<|::|/|-|%|\+|&|>|\||=|\^|<|~|\*)"> + <token type="Operator"/> + </rule> + <rule pattern="(intersect|between|except|exists|union|some|like|all|any|not|and|or|in)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="(uniqueidentifier|datetimeoffset|smalldatetime|hierarchyid|sql_variant|smallmoney|varbinary|datetime2|timestamp|datetime|smallint|nvarchar|decimal|tinyint|varchar|numeric|binary|bigint|cursor|image|nchar|money|float|table|ntext|text|time|real|date|char|int|bit|xml)\b"> + <token type="NameClass"/> + </rule> + <rule pattern="(get_filestream_transaction_context|datetimeoffsetfromparts|fulltextserviceproperty|fulltextcatalogproperty|current_transaction_id|smalldatetimefromparts|min_active_rowversion|database_principal_id|current_request_id|databasepropertyex|connectionproperty|datetime2fromparts|object_schema_name|indexkey_property|filegroupproperty|current_timestamp|sysdatetimeoffset|has_perms_by_name|object_definition|datetimefromparts|assemblyproperty|todatetimeoffset|original_db_name|objectpropertyex|is_srvrolemember|error_procedure|binary_checksum|session_context|sp_helplanguage|newsequentialid|error_severity|original_login|objectproperty|opendatasource|columnproperty|sysutcdatetime|scope_identity|serverproperty|certprivatekey|filegroup_name|cursor_status|formatmessage|indexproperty|is_rolemember|datefromparts|timefromparts|string_escape|error_message|switchoffset|filegroup_id|string_split|current_user|checksum_agg|applock_test|session_user|typeproperty|rowcount_big|context_info|fileproperty|error_number|datediff_big|applock_mode|sysdatetime|error_state|json_modify|grouping_id|getansinull|try_convert|certencoded|system_user|permissions|schema_name|object_name|suser_sname|difference|xact_state|json_value|\$partition|row_number|json_query|getutcdate|col_length|decompress|error_line|openrowset|stats_date|pwdcompare|dense_rank|pwdencrypt|suser_name|is_member|index_col|quotename|host_name|charindex|parsename|isnumeric|user_name|replicate|openquery|count_big|type_name|object_id|try_parse|file_idex|substring|file_name|textvalid|suser_sid|schema_id|compress|grouping|suser_id|app_name|try_cast|col_name|datepart|datename|datediff|checksum|patindex|openjson|getdate|convert|openxml|file_id|db_name|radians|ceiling|unicode|reverse|dateadd|soundex|degrees|eomonth|user_id|type_id|host_id|textptr|replace|concat|square|isdate|stdevp|isjson|isnull|choose|format|stuff|floor|round|right|upper|log10|rtrim|lower|power|ltrim|space|db_id|month|parse|stdev|nchar|newid|count|ntile|ascii|char|year|varp|rank|left|sign|cast|acos|atn2|atan|asin|rand|sqrt|sin|max|min|tan|avg|cos|log|len|abs|cot|str|iif|exp|var|day|sum|pi)\b"> + <token type="NameFunction"/> + </rule> + <rule pattern="(goto)(\s+)(\w+\b)"> + <bygroups> + <token type="Keyword"/> + <token type="TextWhitespace"/> + <token type="NameLabel"/> + </bygroups> + </rule> + <rule pattern="(current_transform_group_for_type|current_default_transform_group|semanticsimilaritydetailstable|semanticsimilaritytable|semantickeyphrasetable|occurrences_regex|current_timestamp|character_length|percentile_cont|identity_insert|current_catalog|translate_regex|timezone_minute|substring_regex|percentile_disc|regr_intercept|localtimestamp|current_schema|opendatasource|position_regex|deterministic|timezone_hour|authorization|xmlattributes|corresponding|xmlnamespaces|fulltexttable|containstable|securityaudit|freetexttable|current_date|width_bucket|specifictype|session_user|intersection|percent_rank|sqlexception|current_path|current_role|current_time|xmlserialize|octet_length|nonclustered|current_user|reconfigure|xmlvalidate|cardinality|replication|try_convert|char_length|xmldocument|tablesample|identitycol|system_user|referencing|translation|submultiset|diagnostics|insensitive|distributed|constructor|constraints|stddev_samp|transaction|fillfactor|completion|destructor|descriptor|connection|dictionary|disconnect|initialize|statistics|sqlwarning|stddev_pop|constraint|references|privileges|parameters|deferrable|covar_samp|asymmetric|deallocate|asensitive|checkpoint|regr_count|xmlcomment|regr_slope|updatetext|like_regex|xmliterate|ordinality|openrowset|rowguidcol|xmlelement|bit_length|parameter|temporary|immediate|initially|cume_dist|symmetric|recursive|timestamp|substring|collation|regr_avgy|normalize|covar_pop|indicator|raiserror|structure|procedure|intersect|terminate|isolation|savepoint|precision|condition|openquery|assertion|translate|aggregate|operation|xmlconcat|character|xmlexists|partition|clustered|sensitive|exception|statement|xmlbinary|localtime|xmlforest|regr_avgx|writetext|smallint|shutdown|specific|allocate|overlaps|sqlstate|coalesce|sequence|xmlparse|external|distinct|truncate|absolute|position|sqlerror|xmlquery|xmltable|cascaded|rowcount|preorder|preserve|describe|rollback|freetext|regr_sxy|interval|restrict|continue|function|modifies|trailing|readtext|whenever|relative|deferred|multiset|regr_sxx|grouping|textsize|database|end-exec|var_samp|regr_syy|identity|national|variable|holdlock|contains|language|breadth|include|varying|varchar|waitfor|regr_r2|var_pop|release|unpivot|between|general|restore|integer|unknown|without|returns|cascade|primary|routine|iterate|fortran|foreign|section|overlay|postfix|uescape|lateral|leading|tsequal|xmlcast|catalog|extract|execute|percent|session|partial|setuser|similar|trigger|element|locator|sqlcode|dynamic|collate|nocheck|openxml|collect|compute|destroy|offsets|connect|convert|boolean|numeric|default|declare|decimal|current|natural|xmltext|prepare|window|unnest|called|exists|select|unique|escape|action|filter|nullif|module|object|modify|second|search|except|minute|scroll|schema|errlvl|equals|browse|method|update|member|atomic|option|xmlagg|rollup|double|domain|revoke|output|revert|return|fusion|global|delete|having|before|lineno|pascal|values|binary|system|cursor|column|insert|commit|public|static|ignore|create|prefix|within|backup|result|cross|names|prior|large|cycle|begin|usage|pivot|range|table|reads|input|close|inout|inner|while|index|where|level|limit|using|value|treat|class|group|grant|local|depth|check|deref|lower|state|print|write|start|upper|outer|right|xmlpi|match|order|found|sqlca|array|float|space|catch|under|first|alter|scope|alias|after|admin|throw|month|nchar|fetch|false|every|break|nclob|union|merge|count|zone|exit|file|save|size|rule|some|rows|both|else|bulk|blob|each|dump|drop|free|role|from|full|disk|call|desc|view|when|deny|goto|hold|dbcc|host|hour|real|date|read|data|proc|into|cube|than|then|with|time|join|kill|last|user|left|corr|tran|plan|less|like|clob|path|load|trim|work|char|over|sets|cast|case|only|null|none|year|next|open|exec|true|are|top|use|not|day|sum|dec|sql|end|set|for|row|get|bit|ada|add|mod|ref|int|new|off|key|old|pad|map|out|all|avg|max|and|asc|any|min|try|as|at|on|or|ln|is|of|in|if|go|to|no|by)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(\[)([^]]+)(\])"> + <bygroups> + <token type="Operator"/> + <token type="Name"/> + <token type="Operator"/> + </bygroups> + </rule> + <rule pattern="0x[0-9a-f]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9]+\.[0-9]*(e[+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\.[0-9]+(e[+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+e[+-]?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[;(),.]"> + <token type="Punctuation"/> + </rule> + <rule pattern="@@\w+"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="@\w+"> + <token type="NameVariable"/> + </rule> + <rule pattern="(\w+)(:)"> + <bygroups> + <token type="NameLabel"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="#?#?\w+"> + <token type="Name"/> + </rule> + <rule pattern="\?"> + <token type="NameVariableMagic"/> + </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> + <state name="string"> + <rule pattern="[^']+"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="''"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="'"> + <token type="LiteralStringSingle"/> + <pop depth="1"/> + </rule> + </state> + <state name="quoted-ident"> + <rule pattern="[^"]+"> + <token type="LiteralStringName"/> + </rule> + <rule pattern=""""> + <token type="LiteralStringName"/> + </rule> + <rule pattern="""> + <token type="LiteralStringName"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/turing.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/turing.xml new file mode 100644 index 0000000..4eab69b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/turing.xml @@ -0,0 +1,82 @@ +<lexer> + <config> + <name>Turing</name> + <alias>turing</alias> + <filename>*.turing</filename> + <filename>*.tu</filename> + <mime_type>text/x-turing</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </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="(var|fcn|function|proc|procedure|process|class|end|record|type|begin|case|loop|for|const|union|monitor|module|handler)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(all|asm|assert|bind|bits|body|break|by|cheat|checked|close|condition|decreasing|def|deferred|else|elsif|exit|export|external|flexible|fork|forward|free|get|if|implement|import|include|inherit|init|invariant|label|new|objectclass|of|opaque|open|packed|pause|pervasive|post|pre|priority|put|quit|read|register|result|seek|self|set|signal|skip|tag|tell|then|timeout|to|unchecked|unqualified|wait|when|write)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(true|false)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(addressint|boolean|pointer|string|array|real4|real8|nat1|int8|int4|int2|nat2|nat4|nat8|int1|real|char|enum|nat|int)\b"> + <token type="KeywordType"/> + </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][+\-]?\d+|\.\d*|[eE][+\-]?\d+)"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\.\d+([eE][+\-]?\d+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(0|[1-9][0-9]*)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(div|mod|rem|\*\*|=|<|>|>=|<=|not=|not|and|or|xor|=>|in|shl|shr|->|~|~=|~in|&|:=|\.\.|[\^+\-*/&#])"> + <token type="Operator"/> + </rule> + <rule pattern="'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralString"/> + </rule> + <rule pattern="[()\[\]{}.,:]"> + <token type="Punctuation"/> + </rule> + <rule pattern="[^\W\d]\w*"> + <token type="NameOther"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/turtle.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/turtle.xml new file mode 100644 index 0000000..7c572f9 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/turtle.xml @@ -0,0 +1,170 @@ +<lexer> + <config> + <name>Turtle</name> + <alias>turtle</alias> + <filename>*.ttl</filename> + <mime_type>text/turtle</mime_type> + <mime_type>application/x-turtle</mime_type> + <case_insensitive>true</case_insensitive> + <not_multiline>true</not_multiline> + </config> + <rules> + <state name="triple-double-quoted-string"> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + <push state="string-escape"/> + </rule> + </state> + <state name="single-double-quoted-string"> + <rule pattern="""> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^"\\\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + <push state="string-escape"/> + </rule> + </state> + <state name="triple-single-quoted-string"> + <rule pattern="'''"> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^\\]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + <push state="string-escape"/> + </rule> + </state> + <state name="single-single-quoted-string"> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="end-of-string"/> + </rule> + <rule pattern="[^'\\\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + <push state="string-escape"/> + </rule> + </state> + <state name="string-escape"> + <rule pattern="."> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + <state name="end-of-string"> + <rule pattern="(@)([a-z]+(:?-[a-z0-9]+)*)"> + <bygroups> + <token type="Operator"/> + <token type="GenericEmph"/> + <token type="GenericEmph"/> + </bygroups> + <pop depth="2"/> + </rule> + <rule pattern="(\^\^)(<[^<>"{}|^`\\\x00-\x20]*>)"> + <bygroups> + <token type="Operator"/> + <token type="GenericEmph"/> + </bygroups> + <pop depth="2"/> + </rule> + <rule pattern="(\^\^)((?:[a-z][\w-]*)?\:)([a-z][\w-]*)"> + <bygroups> + <token type="Operator"/> + <token type="GenericEmph"/> + <token type="GenericEmph"/> + </bygroups> + <pop depth="2"/> + </rule> + <rule> + <pop depth="2"/> + </rule> + </state> + <state name="root"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="(@base|BASE)(\s+)(<[^<>"{}|^`\\\x00-\x20]*>)(\s*)(\.?)"> + <bygroups> + <token type="Keyword"/> + <token type="TextWhitespace"/> + <token type="NameVariable"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(@prefix|PREFIX)(\s+)((?:[a-z][\w-]*)?\:)(\s+)(<[^<>"{}|^`\\\x00-\x20]*>)(\s*)(\.?)"> + <bygroups> + <token type="Keyword"/> + <token type="TextWhitespace"/> + <token type="NameNamespace"/> + <token type="TextWhitespace"/> + <token type="NameVariable"/> + <token type="TextWhitespace"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(?<=\s)a(?=\s)"> + <token type="KeywordType"/> + </rule> + <rule pattern="(<[^<>"{}|^`\\\x00-\x20]*>)"> + <token type="NameVariable"/> + </rule> + <rule pattern="((?:[a-z][\w-]*)?\:)([a-z][\w-]*)"> + <bygroups> + <token type="NameNamespace"/> + <token type="NameTag"/> + </bygroups> + </rule> + <rule pattern="#[^\n]+"> + <token type="Comment"/> + </rule> + <rule pattern="\b(true|false)\b"> + <token type="Literal"/> + </rule> + <rule pattern="[+\-]?\d*\.\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+\-]?\d*(:?\.\d+)?E[+\-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[+\-]?\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[\[\](){}.;,:^]"> + <token type="Punctuation"/> + </rule> + <rule pattern="""""> + <token type="LiteralString"/> + <push state="triple-double-quoted-string"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="single-double-quoted-string"/> + </rule> + <rule pattern="'''"> + <token type="LiteralString"/> + <push state="triple-single-quoted-string"/> + </rule> + <rule pattern="'"> + <token type="LiteralString"/> + <push state="single-single-quoted-string"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/twig.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/twig.xml new file mode 100644 index 0000000..5b0496d --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/twig.xml @@ -0,0 +1,154 @@ +<lexer> + <config> + <name>Twig</name> + <alias>twig</alias> + <mime_type>application/x-twig</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="tag"> + <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*)(raw)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endraw)(\s*-?)(%\})"> + <bygroups> + <token type="CommentPreproc"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="CommentPreproc"/> + <token type="Other"/> + <token type="CommentPreproc"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="CommentPreproc"/> + </bygroups> + </rule> + <rule pattern="(\{%)(-?\s*)(verbatim)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endverbatim)(\s*-?)(%\})"> + <bygroups> + <token type="CommentPreproc"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="CommentPreproc"/> + <token type="Other"/> + <token type="CommentPreproc"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="CommentPreproc"/> + </bygroups> + </rule> + <rule pattern="(\{%)(-?\s*)(filter)(\s+)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*)"> + <bygroups> + <token type="CommentPreproc"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + <push state="tag"/> + </rule> + <rule pattern="(\{%)(-?\s*)([a-zA-Z_]\w*)"> + <bygroups> + <token type="CommentPreproc"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + <push state="tag"/> + </rule> + <rule pattern="\{"> + <token type="Other"/> + </rule> + </state> + <state name="varnames"> + <rule pattern="(\|)(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*)"> + <bygroups> + <token type="Operator"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="(is)(\s+)(not)?(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameFunction"/> + </bygroups> + </rule> + <rule pattern="(?i)(true|false|none|null)\b"> + <token type="KeywordPseudo"/> + </rule> + <rule pattern="(in|not|and|b-and|or|b-or|b-xor|isif|elseif|else|importconstant|defined|divisibleby|empty|even|iterable|odd|sameasmatches|starts\s+with|ends\s+with)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(loop|block|parent)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*"> + <token type="NameVariable"/> + </rule> + <rule pattern="\.(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*"> + <token type="NameVariable"/> + </rule> + <rule pattern="\.[0-9]+"> + <token type="LiteralNumber"/> + </rule> + <rule pattern=":?"(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern=":?'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="([{}()\[\]+\-*/,:~%]|\.\.|\?|:|\*\*|\/\/|!=|[><=]=?)"> + <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>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typescript.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typescript.xml new file mode 100644 index 0000000..cae5a76 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typescript.xml @@ -0,0 +1,261 @@ +<lexer> + <config> + <name>TypeScript</name> + <alias>ts</alias> + <alias>tsx</alias> + <alias>typescript</alias> + <filename>*.ts</filename> + <filename>*.tsx</filename> + <mime_type>text/x-typescript</mime_type> + <dot_all>true</dot_all> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <state name="expression"> + <rule pattern="{"> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="jsx"> + <rule pattern="(<)(/?)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Punctuation"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(<)([\w\.]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameTag"/> + </bygroups> + <push state="tag"/> + </rule> + <rule pattern="(<)(/)([\w\.]*)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Punctuation"/> + <token type="NameTag"/> + <token type="Punctuation"/> + </bygroups> + </rule> + </state> + <state name="tag"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="([\w]+\s*)(=)(\s*)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + <push state="attr"/> + </rule> + <rule pattern="[{}]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="[\w\.]+"> + <token type="NameAttribute"/> + </rule> + <rule pattern="(/?)(\s*)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + <state name="commentsandwhitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="<!--"> + <token type="Comment"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="CommentMultiline"/> + </rule> + </state> + <state name="badregex"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="interp"> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\\`"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="interp-inside"/> + </rule> + <rule pattern="\$"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="[^`\\$]+"> + <token type="LiteralStringBacktick"/> + </rule> + </state> + <state name="attr"> + <rule pattern="{"> + <token type="Punctuation"/> + <push state="expression"/> + </rule> + <rule pattern="".*?""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="'.*?'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="interp-inside"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </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="root"> + <rule> + <include state="jsx"/> + </rule> + <rule pattern="^(?=\s|/|<!--)"> + <token type="Text"/> + <push state="slashstartsregex"/> + </rule> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?"> + <token type="Operator"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[{(\[;,]"> + <token type="Punctuation"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[})\].]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(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"> + <token type="Keyword"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(var|let|with|function)\b"> + <token type="KeywordDeclaration"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(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"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(true|false|null|NaN|Infinity|undefined)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(Array|Boolean|Date|Error|Function|Math|Number|Object|Packages|RegExp|String|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="\b(module)(\s*)(\s*[\w?.$][\w?.$]*)(\s*)"> + <bygroups> + <token type="KeywordReserved"/> + <token type="Text"/> + <token type="NameOther"/> + <token type="Text"/> + </bygroups> + <push state="slashstartsregex"/> + </rule> + <rule pattern="\b(string|bool|number|any|never|object|symbol|unique|unknown|bigint)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="\b(constructor|declare|interface|as)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(super)(\s*)(\([\w,?.$\s]+\s*\))"> + <bygroups> + <token type="KeywordReserved"/> + <token type="Text"/> + </bygroups> + <push state="slashstartsregex"/> + </rule> + <rule pattern="([a-zA-Z_?.$][\w?.$]*)\(\) \{"> + <token type="NameOther"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)"> + <bygroups> + <token type="NameOther"/> + <token type="Text"/> + <token type="KeywordType"/> + </bygroups> + </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=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <push state="interp"/> + </rule> + <rule pattern="@\w+"> + <token type="KeywordDeclaration"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typoscriptcssdata.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typoscriptcssdata.xml new file mode 100644 index 0000000..62c42c1 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typoscriptcssdata.xml @@ -0,0 +1,52 @@ +<lexer> + <config> + <name>TypoScriptCssData</name> + <alias>typoscriptcssdata</alias> + </config> + <rules> + <state name="root"> + <rule pattern="(.*)(###\w+###)(.*)"> + <bygroups> + <token type="LiteralString"/> + <token type="NameConstant"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})"> + <bygroups> + <token type="LiteralStringSymbol"/> + <token type="Operator"/> + <token type="NameConstant"/> + <token type="NameConstant"/> + <token type="LiteralStringSymbol"/> + </bygroups> + </rule> + <rule pattern="(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)"> + <bygroups> + <token type="LiteralString"/> + <token type="LiteralStringSymbol"/> + <token type="NameConstant"/> + <token type="Operator"/> + <token type="NameConstant"/> + <token type="LiteralStringSymbol"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="/\*(?:(?!\*/).)*\*/"> + <token type="Comment"/> + </rule> + <rule pattern="(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)"> + <token type="Comment"/> + </rule> + <rule pattern="[<>,:=.*%+|]"> + <token type="LiteralString"/> + </rule> + <rule pattern="[\w"\-!/&;(){}]+"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typoscripthtmldata.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typoscripthtmldata.xml new file mode 100644 index 0000000..1b0af3a --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/typoscripthtmldata.xml @@ -0,0 +1,52 @@ +<lexer> + <config> + <name>TypoScriptHtmlData</name> + <alias>typoscripthtmldata</alias> + </config> + <rules> + <state name="root"> + <rule pattern="(INCLUDE_TYPOSCRIPT)"> + <token type="NameClass"/> + </rule> + <rule pattern="(EXT|FILE|LLL):[^}\n"]*"> + <token type="LiteralString"/> + </rule> + <rule pattern="(.*)(###\w+###)(.*)"> + <bygroups> + <token type="LiteralString"/> + <token type="NameConstant"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})"> + <bygroups> + <token type="LiteralStringSymbol"/> + <token type="Operator"/> + <token type="NameConstant"/> + <token type="NameConstant"/> + <token type="LiteralStringSymbol"/> + </bygroups> + </rule> + <rule pattern="(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)"> + <bygroups> + <token type="LiteralString"/> + <token type="LiteralStringSymbol"/> + <token type="NameConstant"/> + <token type="Operator"/> + <token type="NameConstant"/> + <token type="LiteralStringSymbol"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[<>,:=.*%+|]"> + <token type="LiteralString"/> + </rule> + <rule pattern="[\w"\-!/&;(){}#]+"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vb_net.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vb_net.xml new file mode 100644 index 0000000..9f85afd --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vb_net.xml @@ -0,0 +1,162 @@ +<lexer> + <config> + <name>VB.net</name> + <alias>vb.net</alias> + <alias>vbnet</alias> + <filename>*.vb</filename> + <filename>*.bas</filename> + <mime_type>text/x-vbnet</mime_type> + <mime_type>text/x-vba</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="dim"> + <rule pattern="[_\w][\w]*"> + <token type="NameVariable"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="funcname"> + <rule pattern="[_\w][\w]*"> + <token type="NameFunction"/> + <pop depth="1"/> + </rule> + </state> + <state name="classname"> + <rule pattern="[_\w][\w]*"> + <token type="NameClass"/> + <pop depth="1"/> + </rule> + </state> + <state name="namespace"> + <rule pattern="[_\w][\w]*"> + <token type="NameNamespace"/> + </rule> + <rule pattern="\."> + <token type="NameNamespace"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="end"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b"> + <token type="Keyword"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="root"> + <rule pattern="^\s*<.*?>"> + <token type="NameAttribute"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="rem\b.*?\n"> + <token type="Comment"/> + </rule> + <rule pattern="'.*?\n"> + <token type="Comment"/> + </rule> + <rule pattern="#If\s.*?\sThen|#ElseIf\s.*?\sThen|#Else|#End\s+If|#Const|#ExternalSource.*?\n|#End\s+ExternalSource|#Region.*?\n|#End\s+Region|#ExternalChecksum"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="[(){}!#,.:]"> + <token type="Punctuation"/> + </rule> + <rule pattern="Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text)"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(?<!\.)(NotOverridable|NotInheritable|RemoveHandler|MustOverride|Overridable|MustInherit|Implements|RaiseEvent|AddHandler|ParamArray|WithEvents|DirectCast|Overrides|Overloads|Protected|WriteOnly|Interface|Narrowing|Inherits|Widening|SyncLock|ReadOnly|Operator|Continue|Delegate|Optional|MyClass|Declare|CUShort|Handles|Default|Shadows|TryCast|Finally|Private|Nothing|Partial|CSByte|Select|Option|Return|Friend|Resume|ElseIf|MyBase|Shared|Single|Public|CShort|Static|Global|Catch|CType|Error|CUInt|Using|While|GoSub|False|CDate|Throw|Event|CChar|CULng|CBool|Erase|ByVal|ByRef|Alias|EndIf|CByte|ReDim|Stop|Call|Wend|Next|CLng|Loop|True|CDec|With|Then|GoTo|CObj|CSng|Exit|CStr|Else|Each|Case|CInt|Step|When|CDbl|Set|For|Let|Lib|Try|New|Not|Get|On|To|Do|If|Of|Me)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(?<!\.)End\b"> + <token type="Keyword"/> + <push state="end"/> + </rule> + <rule pattern="(?<!\.)(Dim|Const)\b"> + <token type="Keyword"/> + <push state="dim"/> + </rule> + <rule pattern="(?<!\.)(Function|Sub|Property)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="funcname"/> + </rule> + <rule pattern="(?<!\.)(Class|Structure|Enum)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="classname"/> + </rule> + <rule pattern="(?<!\.)(Module|Namespace|Imports)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="namespace"/> + </rule> + <rule pattern="(?<!\.)(Boolean|Byte|Char|Date|Decimal|Double|Integer|Long|Object|SByte|Short|Single|String|Variant|UInteger|ULong|UShort)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(?<!\.)(AddressOf|And|AndAlso|As|GetType|In|Is|IsNot|Like|Mod|Or|OrElse|TypeOf|Xor)\b"> + <token type="OperatorWord"/> + </rule> + <rule pattern="&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>\[\]]"> + <token type="Operator"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="_\n"> + <token type="Text"/> + </rule> + <rule pattern="[_\w][\w]*"> + <token type="Name"/> + </rule> + <rule pattern="#.*?#"> + <token type="LiteralDate"/> + </rule> + <rule pattern="(\d+\.\d*|\d*\.\d+)(F[+-]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="\d+([SILDFR]|US|UI|UL)?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="&H[0-9a-f]+([SILDFR]|US|UI|UL)?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="&O[0-7]+([SILDFR]|US|UI|UL)?"> + <token type="LiteralNumberInteger"/> + </rule> + </state> + <state name="string"> + <rule pattern=""""> + <token type="LiteralString"/> + </rule> + <rule pattern=""C?"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="[^"]+"> + <token type="LiteralString"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/verilog.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/verilog.xml new file mode 100644 index 0000000..cd4b9ff --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/verilog.xml @@ -0,0 +1,158 @@ +<lexer> + <config> + <name>verilog</name> + <alias>verilog</alias> + <alias>v</alias> + <filename>*.v</filename> + <mime_type>text/x-verilog</mime_type> + <ensure_nl>true</ensure_nl> + </config> + <rules> + <state name="root"> + <rule pattern="^\s*`define"> + <token type="CommentPreproc"/> + <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)?/(\n|(.|\n)*?[^\\]\n)"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/(\\\n)?[*](.|\n)*?[*](\\\n)?/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="[{}#@]"> + <token type="Punctuation"/> + </rule> + <rule pattern="L?""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+|\d+[fF])[fF]?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="([0-9]+)|(\'h)[0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="([0-9]+)|(\'b)[01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="([0-9]+)|(\'d)[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="([0-9]+)|(\'o)[0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="\'[01xz]"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="\d+[Ll]?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\*/"> + <token type="Error"/> + </rule> + <rule pattern="[~!%^&*+=|?:<>/-]"> + <token type="Operator"/> + </rule> + <rule pattern="[()\[\],.;\']"> + <token type="Punctuation"/> + </rule> + <rule pattern="`[a-zA-Z_]\w*"> + <token type="NameConstant"/> + </rule> + <rule pattern="^(\s*)(package)(\s+)"> + <bygroups> + <token type="Text"/> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="^(\s*)(import)(\s+)"> + <bygroups> + <token type="Text"/> + <token type="KeywordNamespace"/> + <token type="Text"/> + </bygroups> + <push state="import"/> + </rule> + <rule pattern="(endprimitive|always_latch|macromodule|always_comb|endgenerate|endfunction|endpackage|endspecify|localparam|parameter|primitive|always_ff|automatic|specparam|endmodule|rtranif1|scalared|continue|deassign|endtable|defparam|function|strength|generate|pulldown|vectored|rtranif0|unsigned|specify|endcase|negedge|strong0|disable|default|endtask|posedge|strong1|typedef|tranif1|integer|forever|release|initial|tranif0|highz0|genvar|highz1|pullup|notif0|bufif1|bufif0|repeat|medium|return|struct|assign|signed|module|packed|string|output|notif1|always|final|casex|while|table|const|large|break|begin|input|pull0|pull1|inout|weak1|rcmos|weak0|casez|force|small|rnmos|rpmos|rtran|event|type|void|enum|wait|fork|join|else|edge|pmos|nand|cmos|nmos|task|xnor|case|tran|buf|ref|end|var|and|xor|for|nor|not|do|if|or)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="`(autoexpand_vectornets|nounconnected_drive|noexpand_vectornets|noremove_gatenames|unconnected_drive|noremove_netnames|expand_vectornets|remove_gatenames|default_nettype|remove_netnames|endcelldefine|noaccelerate|endprotected|accelerate|celldefine|endprotect|protected|timescale|resetall|protect|include|ifndef|ifdef|endif|elsif|undef|else)\b"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\$(shortrealtobits|bitstoshortreal|printtimescale|showvariables|countdrivers|reset_value|reset_count|getpattern|showscopes|realtobits|bitstoreal|monitoroff|timeformat|sreadmemh|monitoron|sreadmemb|fmonitor|showvars|fdisplay|realtime|readmemb|readmemh|monitor|history|fstrobe|display|restart|incsave|strobe|fwrite|finish|random|fclose|stime|nokey|fopen|floor|nolog|scale|scope|input|reset|write|rtoi|bits|list|stop|itor|time|save|key|log)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(woshortreal|shortint|realtime|longint|integer|supply0|supply1|triand|trireg|uwire|logic|trior|byte|wand|tri0|tri1|time|real|wire|reg|bit|int|tri)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="[a-zA-Z_]\w*:(?!:)"> + <token type="NameLabel"/> + </rule> + <rule pattern="\$?[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="string"> + <rule pattern="""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\\n"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\"> + <token type="LiteralString"/> + </rule> + </state> + <state name="macro"> + <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="(?<=\\)\n"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\n"> + <token type="CommentPreproc"/> + <pop depth="1"/> + </rule> + </state> + <state name="import"> + <rule pattern="[\w:]+\*?"> + <token type="NameNamespace"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vhdl.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vhdl.xml new file mode 100644 index 0000000..aa42044 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vhdl.xml @@ -0,0 +1,171 @@ +<lexer> + <config> + <name>VHDL</name> + <alias>vhdl</alias> + <filename>*.vhdl</filename> + <filename>*.vhd</filename> + <mime_type>text/x-vhdl</mime_type> + <case_insensitive>true</case_insensitive> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="--.*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="'(U|X|0|1|Z|W|L|H|-)'"> + <token type="LiteralStringChar"/> + </rule> + <rule pattern="[~!%^&*+=|?:<>/-]"> + <token type="Operator"/> + </rule> + <rule pattern="'[a-z_]\w*"> + <token type="NameAttribute"/> + </rule> + <rule pattern="[()\[\],.;\']"> + <token type="Punctuation"/> + </rule> + <rule pattern=""[^\n\\"]*""> + <token type="LiteralString"/> + </rule> + <rule pattern="(library)(\s+)([a-z_]\w*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(use)(\s+)(entity)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(use)(\s+)([a-z_][\w.]*\.)(all)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(use)(\s+)([a-z_][\w.]*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(std|ieee)(\.[a-z_]\w*)"> + <bygroups> + <token type="NameNamespace"/> + <token type="NameNamespace"/> + </bygroups> + </rule> + <rule pattern="(ieee|work|std)\b"> + <token type="NameNamespace"/> + </rule> + <rule pattern="(entity|component)(\s+)([a-z_]\w*)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameClass"/> + </bygroups> + </rule> + <rule pattern="(architecture|configuration)(\s+)([a-z_]\w*)(\s+)(of)(\s+)([a-z_]\w*)(\s+)(is)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameClass"/> + <token type="Text"/> + <token type="Keyword"/> + <token type="Text"/> + <token type="NameClass"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="([a-z_]\w*)(:)(\s+)(process|for)"> + <bygroups> + <token type="NameClass"/> + <token type="Operator"/> + <token type="Text"/> + <token type="Keyword"/> + </bygroups> + </rule> + <rule pattern="(end)(\s+)"> + <bygroups> + <token type="Keyword"/> + <token type="Text"/> + </bygroups> + <push state="endblock"/> + </rule> + <rule> + <include state="types"/> + </rule> + <rule> + <include state="keywords"/> + </rule> + <rule> + <include state="numbers"/> + </rule> + <rule pattern="[a-z_]\w*"> + <token type="Name"/> + </rule> + </state> + <state name="endblock"> + <rule> + <include state="keywords"/> + </rule> + <rule pattern="[a-z_]\w*"> + <token type="NameClass"/> + </rule> + <rule pattern="(\s+)"> + <token type="Text"/> + </rule> + <rule pattern=";"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + </state> + <state name="types"> + <rule pattern="(std_ulogic_vector|file_open_status|std_logic_vector|severity_level|file_open_kind|delay_length|std_ulogic|bit_vector|character|std_logic|positive|unsigned|boolean|natural|integer|signed|string|time|bit)\b"> + <token type="KeywordType"/> + </rule> + </state> + <state name="keywords"> + <rule pattern="(configuration|architecture|disconnect|attribute|transport|postponed|procedure|component|function|variable|severity|constant|generate|register|inertial|package|library|guarded|linkage|generic|subtype|process|literal|record|entity|others|shared|signal|downto|access|assert|return|reject|buffer|impure|select|elsif|inout|until|label|range|group|units|begin|array|alias|after|block|while|null|next|file|when|wait|open|nand|exit|then|case|port|type|loop|else|pure|with|xnor|body|not|rem|bus|rol|ror|xor|abs|end|and|sla|sll|sra|srl|all|out|nor|mod|map|for|new|use|or|on|of|in|if|is|to)\b"> + <token type="Keyword"/> + </rule> + </state> + <state name="numbers"> + <rule pattern="\d{1,2}#[0-9a-f_]+#?"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\d+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(\d+\.\d*|\.\d+|\d+)E[+-]?\d+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="X"[0-9a-f_]+""> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="O"[0-7_]+""> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="B"[01_]+""> + <token type="LiteralNumberBin"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vue.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vue.xml new file mode 100644 index 0000000..7518020 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/vue.xml @@ -0,0 +1,305 @@ +<lexer> + <config> + <name>vue</name> + <alias>vue</alias> + <alias>vuejs</alias> + <filename>*.vue</filename> + <mime_type>text/x-vue</mime_type> + <mime_type>application/x-vue</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="interp-inside"> + <rule pattern="\}"> + <token type="LiteralStringInterpol"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="attr"> + <rule pattern="{"> + <token type="Punctuation"/> + <push state="expression"/> + </rule> + <rule pattern="".*?""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="'.*?'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule> + <pop depth="1"/> + </rule> + </state> + <state name="interp"> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <pop depth="1"/> + </rule> + <rule pattern="\\\\"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\\`"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="\$\{"> + <token type="LiteralStringInterpol"/> + <push state="interp-inside"/> + </rule> + <rule pattern="\$"> + <token type="LiteralStringBacktick"/> + </rule> + <rule pattern="[^`\\$]+"> + <token type="LiteralStringBacktick"/> + </rule> + </state> + <state name="tag"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="(-)([\w]+)"> + <token type="NameTag"/> + </rule> + <rule pattern="(@[\w]+)(="[\S]+")(>)"> + <bygroups> + <token type="NameTag"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(@[\w]+)(="[\S]+")"> + <bygroups> + <token type="NameTag"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(@[\S]+)(="[\S]+")"> + <bygroups> + <token type="NameTag"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(:[\S]+)(="[\S]+")"> + <bygroups> + <token type="NameTag"/> + <token type="LiteralString"/> + </bygroups> + </rule> + <rule pattern="(:)"> + <token type="Operator"/> + </rule> + <rule pattern="(v-b-[\S]+)"> + <token type="NameTag"/> + </rule> + <rule pattern="(v-[\w]+)(=".+)([:][\w]+)(="[\w]+")(>)"> + <bygroups> + <token type="NameTag"/> + <token type="LiteralString"/> + <token type="NameTag"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(v-[\w]+)(="[\S]+")(>)"> + <bygroups> + <token type="NameTag"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(v-[\w]+)(>)"> + <bygroups> + <token type="NameTag"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(v-[\w]+)(=".+")(>)"> + <bygroups> + <token type="NameTag"/> + <token type="LiteralString"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="(<)([\w]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameTag"/> + </bygroups> + </rule> + <rule pattern="(<)(/)([\w]+)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Punctuation"/> + <token type="NameTag"/> + <token type="Punctuation"/> + </bygroups> + </rule> + <rule pattern="([\w]+\s*)(=)(\s*)"> + <bygroups> + <token type="NameAttribute"/> + <token type="Operator"/> + <token type="Text"/> + </bygroups> + <push state="attr"/> + </rule> + <rule pattern="[{}]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="[\w\.]+"> + <token type="NameAttribute"/> + </rule> + <rule pattern="(/?)(\s*)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Text"/> + <token type="Punctuation"/> + </bygroups> + <pop depth="1"/> + </rule> + </state> + <state name="slashstartsregex"> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gimuy]+\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="root"> + <rule> + <include state="vue"/> + </rule> + <rule pattern="\A#! ?/.*?\n"> + <token type="CommentHashbang"/> + </rule> + <rule pattern="^(?=\s|/|<!--)"> + <token type="Text"/> + <push state="slashstartsregex"/> + </rule> + <rule> + <include state="commentsandwhitespace"/> + </rule> + <rule pattern="(\.\d+|[0-9]+\.[0-9]*)([eE][-+]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0[bB][01]+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0[oO][0-7]+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="\.\.\.|=>"> + <token type="Punctuation"/> + </rule> + <rule pattern="\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?"> + <token type="Operator"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[{(\[;,]"> + <token type="Punctuation"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="[})\].]"> + <token type="Punctuation"/> + </rule> + <rule pattern="(for|in|while|do|break|return|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|void|yield|this|of)\b"> + <token type="Keyword"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(var|let|with|function)\b"> + <token type="KeywordDeclaration"/> + <push state="slashstartsregex"/> + </rule> + <rule pattern="(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"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(true|false|null|NaN|Infinity|undefined)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|Promise|Proxy|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|Error|eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|document|this|window)\b"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="(?:[$_\p{L}\p{N}]|\\u[a-fA-F0-9]{4})(?:(?:[$\p{L}\p{N}]|\\u[a-fA-F0-9]{4}))*"> + <token type="NameOther"/> + </rule> + <rule pattern=""(\\\\|\\"|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(\\\\|\\'|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="`"> + <token type="LiteralStringBacktick"/> + <push state="interp"/> + </rule> + </state> + <state name="badregex"> + <rule pattern="\n"> + <token type="Text"/> + <pop depth="1"/> + </rule> + </state> + <state name="vue"> + <rule pattern="(<)([\w]+)"> + <bygroups> + <token type="Punctuation"/> + <token type="NameTag"/> + </bygroups> + <push state="tag"/> + </rule> + <rule pattern="(<)(/)([\w]+)(>)"> + <bygroups> + <token type="Punctuation"/> + <token type="Punctuation"/> + <token type="NameTag"/> + <token type="Punctuation"/> + </bygroups> + </rule> + </state> + <state name="expression"> + <rule pattern="{"> + <token type="Punctuation"/> + <push/> + </rule> + <rule pattern="}"> + <token type="Punctuation"/> + <pop depth="1"/> + </rule> + <rule> + <include state="root"/> + </rule> + </state> + <state name="commentsandwhitespace"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="<!--"> + <token type="Comment"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/\*.*?\*/"> + <token type="CommentMultiline"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/wdte.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/wdte.xml new file mode 100644 index 0000000..c663ee2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/wdte.xml @@ -0,0 +1,43 @@ +<lexer> + <config> + <name>WDTE</name> + <filename>*.wdte</filename> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="#(.*?)\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="-?[0-9]+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="-?[0-9]*\.[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern=""[^"]*""> + <token type="LiteralString"/> + </rule> + <rule pattern="'[^']*'"> + <token type="LiteralString"/> + </rule> + <rule pattern="(default|switch|memo)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="{|}|;|->|=>|\(|\)|\[|\]|\."> + <token type="Operator"/> + </rule> + <rule pattern="[^{};()[\].\s]+"> + <token type="NameVariable"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/whiley.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/whiley.xml new file mode 100644 index 0000000..1762c96 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/whiley.xml @@ -0,0 +1,57 @@ +<lexer> + <config> + <name>Whiley</name> + <alias>whiley</alias> + <filename>*.whiley</filename> + <mime_type>text/x-whiley</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="Text"/> + </rule> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="\\\n"> + <token type="Text"/> + </rule> + <rule pattern="/[*](.|\n)*?[*]/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(function|import|from|method|property|type|with|variant)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="(assert|assume|all|break|case|continue|debug|default|do|else|ensures|export|fail|final|for|if|in|is|native|no|new|private|protected|public|return|requires|skip|some|switch|unsafe|where|while)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(true|false|null)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(bool|byte|int|void)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="0b(?:_?[01])+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0[xX][0-9a-fA-F]+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(0|[1-9][0-9]*)"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="[+%=><|^!?/\-*&~:]"> + <token type="Operator"/> + </rule> + <rule pattern="[{}()\[\],.;\|]"> + <token type="Punctuation"/> + </rule> + </state> + </rules> +</lexer> diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/xml.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/xml.xml new file mode 100644 index 0000000..2c6a4d9 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/xml.xml @@ -0,0 +1,95 @@ +<lexer> + <config> + <name>XML</name> + <alias>xml</alias> + <filename>*.xml</filename> + <filename>*.xsl</filename> + <filename>*.rss</filename> + <filename>*.xslt</filename> + <filename>*.xsd</filename> + <filename>*.wsdl</filename> + <filename>*.wsf</filename> + <filename>*.svg</filename> + <filename>*.csproj</filename> + <filename>*.vcxproj</filename> + <filename>*.fsproj</filename> + <mime_type>text/xml</mime_type> + <mime_type>application/xml</mime_type> + <mime_type>image/svg+xml</mime_type> + <mime_type>application/rss+xml</mime_type> + <mime_type>application/atom+xml</mime_type> + <dot_all>true</dot_all> + </config> + <rules> + <state name="root"> + <rule pattern="[^<&]+"> + <token type="Text"/> + </rule> + <rule pattern="&\S*?;"> + <token type="NameEntity"/> + </rule> + <rule pattern="\<\!\[CDATA\[.*?\]\]\>"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="<!--"> + <token type="Comment"/> + <push state="comment"/> + </rule> + <rule pattern="<\?.*?\?>"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="<![^>]*>"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="<\s*[\w:.-]+"> + <token type="NameTag"/> + <push state="tag"/> + </rule> + <rule pattern="<\s*/\s*[\w:.-]+\s*>"> + <token type="NameTag"/> + </rule> + </state> + <state name="comment"> + <rule pattern="[^-]+"> + <token type="Comment"/> + </rule> + <rule pattern="-->"> + <token type="Comment"/> + <pop depth="1"/> + </rule> + <rule pattern="-"> + <token type="Comment"/> + </rule> + </state> + <state name="tag"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="[\w.:-]+\s*="> + <token type="NameAttribute"/> + <push state="attr"/> + </rule> + <rule pattern="/?\s*>"> + <token type="NameTag"/> + <pop depth="1"/> + </rule> + </state> + <state name="attr"> + <rule pattern="\s+"> + <token type="Text"/> + </rule> + <rule pattern="".*?""> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="'.*?'"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + <rule pattern="[^\s>]+"> + <token type="LiteralString"/> + <pop depth="1"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/xorg.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/xorg.xml new file mode 100644 index 0000000..53bf432 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/xorg.xml @@ -0,0 +1,35 @@ +<lexer> + <config> + <name>Xorg</name> + <alias>xorg.conf</alias> + <filename>xorg.conf</filename> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="((|Sub)Section)(\s+)("\w+")"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="LiteralStringEscape"/> + <token type="TextWhitespace"/> + <token type="LiteralStringEscape"/> + </bygroups> + </rule> + <rule pattern="(End(|Sub)Section)"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="(\w+)(\s+)([^\n#]+)"> + <bygroups> + <token type="NameKeyword"/> + <token type="TextWhitespace"/> + <token type="LiteralString"/> + </bygroups> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/yaml.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/yaml.xml new file mode 100644 index 0000000..baa7bd5 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/yaml.xml @@ -0,0 +1,122 @@ +<lexer> + <config> + <name>YAML</name> + <alias>yaml</alias> + <filename>*.yaml</filename> + <filename>*.yml</filename> + <mime_type>text/x-yaml</mime_type> + </config> + <rules> + <state name="root"> + <rule> + <include state="whitespace"/> + </rule> + <rule pattern="^---"> + <token type="NameNamespace"/> + </rule> + <rule pattern="^\.\.\."> + <token type="NameNamespace"/> + </rule> + <rule pattern="[\n?]?\s*- "> + <token type="Text"/> + </rule> + <rule pattern="#.*$"> + <token type="Comment"/> + </rule> + <rule pattern="!![^\s]+"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="&[^\s]+"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="\*[^\s]+"> + <token type="CommentPreproc"/> + </rule> + <rule pattern="^%include\s+[^\n\r]+"> + <token type="CommentPreproc"/> + </rule> + <rule> + <include state="key"/> + </rule> + <rule> + <include state="value"/> + </rule> + <rule pattern="[?:,\[\]]"> + <token type="Punctuation"/> + </rule> + <rule pattern="."> + <token type="Text"/> + </rule> + </state> + <state name="value"> + <rule pattern="([>|](?:[+-])?)(\n(^ {1,})(?:.*\n*(?:^\3 *).*)*)"> + <bygroups> + <token type="Punctuation"/> + <token type="LiteralStringDoc"/> + <token type="TextWhitespace"/> + </bygroups> + </rule> + <rule pattern="(false|False|FALSE|true|True|TRUE|null|Off|off|yes|Yes|YES|OFF|On|ON|no|No|on|NO|n|N|Y|y)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern=""(?:\\.|[^"])*""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(?:\\.|[^'])*'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="\d\d\d\d-\d\d-\d\d([T ]\d\d:\d\d:\d\d(\.\d+)?(Z|\s+[-+]\d+)?)?"> + <token type="LiteralDate"/> + </rule> + <rule pattern="\b[+\-]?(0x[\da-f]+|0o[0-7]+|(\d+\.?\d*|\.?\d+)(e[\+\-]?\d+)?|\.inf|\.nan)\b"> + <token type="LiteralNumber"/> + </rule> + <rule pattern="([^\{\}\[\]\?,\:\!\-\*&\@].*)( )+(#.*)"> + <bygroups> + <token type="Literal"/> + <token type="TextWhitespace"/> + <token type="Comment"/> + </bygroups> + </rule> + <rule pattern="[^\{\}\[\]\?,\:\!\-\*&\@].*"> + <token type="Literal"/> + </rule> + </state> + <state name="key"> + <rule pattern=""[^"\n].*": "> + <token type="NameTag"/> + </rule> + <rule pattern="(-)( )([^"\n{]*)(:)( )"> + <bygroups> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + <token type="NameTag"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + </bygroups> + </rule> + <rule pattern="([^"\n{]*)(:)( )"> + <bygroups> + <token type="NameTag"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + </bygroups> + </rule> + <rule pattern="([^"\n{]*)(:)(\n)"> + <bygroups> + <token type="NameTag"/> + <token type="Punctuation"/> + <token type="TextWhitespace"/> + </bygroups> + </rule> + </state> + <state name="whitespace"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="\n+"> + <token type="TextWhitespace"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/yang.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/yang.xml new file mode 100644 index 0000000..f3da7ce --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/yang.xml @@ -0,0 +1,99 @@ +<lexer> + <config> + <name>YANG</name> + <alias>yang</alias> + <filename>*.yang</filename> + <mime_type>application/yang</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="[\{\}\;]+"> + <token type="Punctuation"/> + </rule> + <rule pattern="(?<![\-\w])(and|or|not|\+|\.)(?![\-\w])"> + <token type="Operator"/> + </rule> + <rule pattern=""(?:\\"|[^"])*?""> + <token type="LiteralStringDouble"/> + </rule> + <rule pattern="'(?:\\'|[^'])*?'"> + <token type="LiteralStringSingle"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="comments"/> + </rule> + <rule pattern="//.*?$"> + <token type="CommentSingle"/> + </rule> + <rule pattern="(?:^|(?<=[\s{};]))([\w.-]+)(:)([\w.-]+)(?=[\s{};])"> + <bygroups> + <token type="KeywordNamespace"/> + <token type="Punctuation"/> + <token type="Text"/> + </bygroups> + </rule> + <rule pattern="([0-9]{4}\-[0-9]{2}\-[0-9]{2})(?=[\s\{\}\;])"> + <token type="LiteralDate"/> + </rule> + <rule pattern="([0-9]+\.[0-9]+)(?=[\s\{\}\;])"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="([0-9]+)(?=[\s\{\}\;])"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="(submodule|module)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(yang-version|belongs-to|namespace|prefix)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(organization|description|reference|revision|contact)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(revision-date|include|import)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(notification|if-feature|deviation|extension|identity|argument|grouping|typedef|feature|augment|output|action|input|rpc)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(leaf-list|container|presence|anydata|deviate|choice|config|anyxml|refine|leaf|must|list|case|uses|when)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(require-instance|fraction-digits|error-app-tag|error-message|min-elements|max-elements|yin-element|ordered-by|position|modifier|default|pattern|length|status|units|value|range|type|path|enum|base|bit)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(mandatory|unique|key)(?=[^\w\-\:])"> + <token type="Keyword"/> + </rule> + <rule pattern="(not-supported|invert-match|deprecated|unbounded|obsolete|current|replace|delete|false|true|user|min|max|add)(?=[^\w\-\:])"> + <token type="NameClass"/> + </rule> + <rule pattern="(instance-identifier|identityref|enumeration|decimal64|boolean|leafref|uint64|uint32|string|binary|uint16|int32|int64|int16|empty|uint8|union|int8|bits)(?=[^\w\-\:])"> + <token type="NameClass"/> + </rule> + <rule pattern="[^;{}\s\'\"]+"> + <token type="Text"/> + </rule> + </state> + <state name="comments"> + <rule pattern="[^*/]"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="/\*"> + <token type="CommentMultiline"/> + <push state="comment"/> + </rule> + <rule pattern="\*/"> + <token type="CommentMultiline"/> + <pop depth="1"/> + </rule> + <rule pattern="[*/]"> + <token type="CommentMultiline"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/zed.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/zed.xml new file mode 100644 index 0000000..929f495 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/zed.xml @@ -0,0 +1,51 @@ +<lexer> + <config> + <name>Zed</name> + <alias>zed</alias> + <filename>*.zed</filename> + <mime_type>text/zed</mime_type> + </config> + <rules> + <state name="root"> + <rule pattern="\n"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="\s+"> + <token type="TextWhitespace"/> + </rule> + <rule pattern="//.*?\n"> + <token type="CommentSingle"/> + </rule> + <rule pattern="/(\\\n)?[*][\w\W]*?[*](\\\n)?/"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="/(\\\n)?[*][\w\W]*"> + <token type="CommentMultiline"/> + </rule> + <rule pattern="(definition)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(relation)\b"> + <token type="KeywordNamespace"/> + </rule> + <rule pattern="(permission)\b"> + <token type="KeywordDeclaration"/> + </rule> + <rule pattern="[a-zA-Z_]\w*/"> + <token type="NameNamespace"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="#[a-zA-Z_]\w*"> + <token type="NameVariable"/> + </rule> + <rule pattern="[+%=><|^!?/\-*&~:]"> + <token type="Operator"/> + </rule> + <rule pattern="[{}()\[\],.;]"> + <token type="Punctuation"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/zig.xml b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/zig.xml new file mode 100644 index 0000000..fb51cc1 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/embedded/zig.xml @@ -0,0 +1,112 @@ +<lexer> + <config> + <name>Zig</name> + <alias>zig</alias> + <filename>*.zig</filename> + <mime_type>text/zig</mime_type> + </config> + <rules> + <state name="string"> + <rule pattern="\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="[^\\"\n]+"> + <token type="LiteralString"/> + </rule> + <rule pattern="""> + <token type="LiteralString"/> + <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="CommentSingle"/> + </rule> + <rule pattern="(unreachable|continue|errdefer|suspend|return|resume|cancel|break|catch|async|await|defer|asm|try)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(threadlocal|linksection|allowzero|stdcallcc|volatile|comptime|noalias|nakedcc|inline|export|packed|extern|align|const|pub|var)\b"> + <token type="KeywordReserved"/> + </rule> + <rule pattern="(struct|union|error|enum)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(while|for)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(comptime_float|comptime_int|c_longdouble|c_ulonglong|c_longlong|c_voidi8|noreturn|c_ushort|anyerror|promise|c_short|c_ulong|c_uint|c_long|isize|c_int|usize|void|f128|i128|type|bool|u128|u16|f64|f32|u64|i16|f16|i32|u32|i64|u8|i0|u0)\b"> + <token type="KeywordType"/> + </rule> + <rule pattern="(undefined|false|true|null)\b"> + <token type="KeywordConstant"/> + </rule> + <rule pattern="(switch|orelse|else|and|if|or)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="(usingnamespace|test|fn)\b"> + <token type="Keyword"/> + </rule> + <rule pattern="0x[0-9a-fA-F]+\.[0-9a-fA-F]+([pP][\-+]?[0-9a-fA-F]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0x[0-9a-fA-F]+\.?[pP][\-+]?[0-9a-fA-F]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+\.[0-9]+([eE][-+]?[0-9]+)?"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="[0-9]+\.?[eE][-+]?[0-9]+"> + <token type="LiteralNumberFloat"/> + </rule> + <rule pattern="0b(?:_?[01])+"> + <token type="LiteralNumberBin"/> + </rule> + <rule pattern="0o(?:_?[0-7])+"> + <token type="LiteralNumberOct"/> + </rule> + <rule pattern="0x(?:_?[0-9a-fA-F])+"> + <token type="LiteralNumberHex"/> + </rule> + <rule pattern="(?:_?[0-9])+"> + <token type="LiteralNumberInteger"/> + </rule> + <rule pattern="@[a-zA-Z_]\w*"> + <token type="NameBuiltin"/> + </rule> + <rule pattern="[a-zA-Z_]\w*"> + <token type="Name"/> + </rule> + <rule pattern="\'\\\'\'"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\'\\(|x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])\'"> + <token type="LiteralStringEscape"/> + </rule> + <rule pattern="\'[^\\\']\'"> + <token type="LiteralString"/> + </rule> + <rule pattern="\\\\[^\n]*"> + <token type="LiteralStringHeredoc"/> + </rule> + <rule pattern="c\\\\[^\n]*"> + <token type="LiteralStringHeredoc"/> + </rule> + <rule pattern="c?""> + <token type="LiteralString"/> + <push state="string"/> + </rule> + <rule pattern="[+%=><|^!?/\-*&~:]"> + <token type="Operator"/> + </rule> + <rule pattern="[{}()\[\],.;]"> + <token type="Punctuation"/> + </rule> + </state> + </rules> +</lexer>
\ No newline at end of file diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/fortran_fixed.go b/vendor/github.com/alecthomas/chroma/v2/lexers/fortran_fixed.go new file mode 100644 index 0000000..d93ac1e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/fortran_fixed.go @@ -0,0 +1,38 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// FortranFixed lexer. +var FortranFixed = Register(MustNewLexer( + &Config{ + Name: "FortranFixed", + Aliases: []string{"fortranfixed"}, + Filenames: []string{"*.f", "*.F"}, + MimeTypes: []string{"text/x-fortran"}, + NotMultiline: true, + CaseInsensitive: true, + }, + func() Rules { + return Rules{ + "root": { + {`[C*].*\n`, Comment, nil}, + {`#.*\n`, CommentPreproc, nil}, + {`[\t ]*!.*\n`, Comment, nil}, + {`(.{5})`, NameLabel, Push("cont-char")}, + {`.*\n`, Using("Fortran"), nil}, + }, + "cont-char": { + {` `, Text, Push("code")}, + {`0`, Comment, Push("code")}, + {`.`, GenericStrong, Push("code")}, + }, + "code": { + {`(.{66})(.*)(\n)`, ByGroups(Using("Fortran"), Comment, Text), Push("root")}, + {`.*\n`, Using("Fortran"), Push("root")}, + Default(Push("root")), + }, + } + }, +)) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/genshi.go b/vendor/github.com/alecthomas/chroma/v2/lexers/genshi.go new file mode 100644 index 0000000..7f396f4 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/genshi.go @@ -0,0 +1,118 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Genshi Text lexer. +var GenshiText = Register(MustNewLexer( + &Config{ + Name: "Genshi Text", + Aliases: []string{"genshitext"}, + Filenames: []string{}, + MimeTypes: []string{"application/x-genshi-text", "text/x-genshi"}, + }, + genshiTextRules, +)) + +func genshiTextRules() Rules { + return Rules{ + "root": { + {`[^#$\s]+`, Other, nil}, + {`^(\s*)(##.*)$`, ByGroups(Text, Comment), nil}, + {`^(\s*)(#)`, ByGroups(Text, CommentPreproc), Push("directive")}, + Include("variable"), + {`[#$\s]`, Other, nil}, + }, + "directive": { + {`\n`, Text, Pop(1)}, + {`(?:def|for|if)\s+.*`, Using("Python"), Pop(1)}, + {`(choose|when|with)([^\S\n]+)(.*)`, ByGroups(Keyword, Text, Using("Python")), Pop(1)}, + {`(choose|otherwise)\b`, Keyword, Pop(1)}, + {`(end\w*)([^\S\n]*)(.*)`, ByGroups(Keyword, Text, Comment), Pop(1)}, + }, + "variable": { + {`(?<!\$)(\$\{)(.+?)(\})`, ByGroups(CommentPreproc, Using("Python"), CommentPreproc), nil}, + {`(?<!\$)(\$)([a-zA-Z_][\w.]*)`, NameVariable, nil}, + }, + } +} + +// Html+Genshi lexer. +var GenshiHTMLTemplate = Register(MustNewLexer( + &Config{ + Name: "Genshi HTML", + Aliases: []string{"html+genshi", "html+kid"}, + Filenames: []string{}, + MimeTypes: []string{"text/html+genshi"}, + NotMultiline: true, + DotAll: true, + }, + genshiMarkupRules, +)) + +// Genshi lexer. +var Genshi = Register(MustNewLexer( + &Config{ + Name: "Genshi", + Aliases: []string{"genshi", "kid", "xml+genshi", "xml+kid"}, + Filenames: []string{"*.kid"}, + MimeTypes: []string{"application/x-genshi", "application/x-kid"}, + NotMultiline: true, + DotAll: true, + }, + genshiMarkupRules, +)) + +func genshiMarkupRules() Rules { + return Rules{ + "root": { + {`[^<$]+`, Other, nil}, + {`(<\?python)(.*?)(\?>)`, ByGroups(CommentPreproc, Using("Python"), CommentPreproc), nil}, + {`<\s*(script|style)\s*.*?>.*?<\s*/\1\s*>`, Other, nil}, + {`<\s*py:[a-zA-Z0-9]+`, NameTag, Push("pytag")}, + {`<\s*[a-zA-Z0-9:.]+`, NameTag, Push("tag")}, + Include("variable"), + {`[<$]`, Other, nil}, + }, + "pytag": { + {`\s+`, Text, nil}, + {`[\w:-]+\s*=`, NameAttribute, Push("pyattr")}, + {`/?\s*>`, NameTag, Pop(1)}, + }, + "pyattr": { + {`(")(.*?)(")`, ByGroups(LiteralString, Using("Python"), LiteralString), Pop(1)}, + {`(')(.*?)(')`, ByGroups(LiteralString, Using("Python"), LiteralString), Pop(1)}, + {`[^\s>]+`, LiteralString, Pop(1)}, + }, + "tag": { + {`\s+`, Text, nil}, + {`py:[\w-]+\s*=`, NameAttribute, Push("pyattr")}, + {`[\w:-]+\s*=`, NameAttribute, Push("attr")}, + {`/?\s*>`, NameTag, Pop(1)}, + }, + "attr": { + {`"`, LiteralString, Push("attr-dstring")}, + {`'`, LiteralString, Push("attr-sstring")}, + {`[^\s>]*`, LiteralString, Pop(1)}, + }, + "attr-dstring": { + {`"`, LiteralString, Pop(1)}, + Include("strings"), + {`'`, LiteralString, nil}, + }, + "attr-sstring": { + {`'`, LiteralString, Pop(1)}, + Include("strings"), + {`'`, LiteralString, nil}, + }, + "strings": { + {`[^"'$]+`, LiteralString, nil}, + Include("variable"), + }, + "variable": { + {`(?<!\$)(\$\{)(.+?)(\})`, ByGroups(CommentPreproc, Using("Python"), CommentPreproc), nil}, + {`(?<!\$)(\$)([a-zA-Z_][\w\.]*)`, NameVariable, nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/go.go b/vendor/github.com/alecthomas/chroma/v2/lexers/go.go new file mode 100644 index 0000000..8a11ffc --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/go.go @@ -0,0 +1,82 @@ +package lexers + +import ( + "strings" + + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Go lexer. +var Go = Register(MustNewLexer( + &Config{ + Name: "Go", + Aliases: []string{"go", "golang"}, + Filenames: []string{"*.go"}, + MimeTypes: []string{"text/x-gosrc"}, + EnsureNL: true, + }, + goRules, +).SetAnalyser(func(text string) float32 { + if strings.Contains(text, "fmt.") && strings.Contains(text, "package ") { + return 0.5 + } + if strings.Contains(text, "package ") { + return 0.1 + } + return 0.0 +})) + +func goRules() Rules { + return Rules{ + "root": { + {`\n`, Text, nil}, + {`\s+`, Text, nil}, + {`\\\n`, Text, nil}, + {`//(.*?)\n`, CommentSingle, nil}, + {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, + {`(import|package)\b`, KeywordNamespace, nil}, + {`(var|func|struct|map|chan|type|interface|const)\b`, KeywordDeclaration, nil}, + {Words(``, `\b`, `break`, `default`, `select`, `case`, `defer`, `go`, `else`, `goto`, `switch`, `fallthrough`, `if`, `range`, `continue`, `for`, `return`), Keyword, nil}, + {`(true|false|iota|nil)\b`, KeywordConstant, nil}, + {Words(``, `\b(\()`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`, `int`, `int8`, `int16`, `int32`, `int64`, `float`, `float32`, `float64`, `complex64`, `complex128`, `byte`, `rune`, `string`, `bool`, `error`, `uintptr`, `print`, `println`, `panic`, `recover`, `close`, `complex`, `real`, `imag`, `len`, `cap`, `append`, `copy`, `delete`, `new`, `make`), ByGroups(NameBuiltin, Punctuation), nil}, + {Words(``, `\b`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`, `int`, `int8`, `int16`, `int32`, `int64`, `float`, `float32`, `float64`, `complex64`, `complex128`, `byte`, `rune`, `string`, `bool`, `error`, `uintptr`), KeywordType, nil}, + {`\d+i`, LiteralNumber, nil}, + {`\d+\.\d*([Ee][-+]\d+)?i`, LiteralNumber, nil}, + {`\.\d+([Ee][-+]\d+)?i`, LiteralNumber, nil}, + {`\d+[Ee][-+]\d+i`, LiteralNumber, nil}, + {`\d+(\.\d+[eE][+\-]?\d+|\.\d*|[eE][+\-]?\d+)`, LiteralNumberFloat, nil}, + {`\.\d+([eE][+\-]?\d+)?`, LiteralNumberFloat, nil}, + {`0[0-7]+`, LiteralNumberOct, nil}, + {`0[xX][0-9a-fA-F_]+`, LiteralNumberHex, nil}, + {`0b[01_]+`, LiteralNumberBin, nil}, + {`(0|[1-9][0-9_]*)`, LiteralNumberInteger, nil}, + {`'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'`, LiteralStringChar, nil}, + {"(`)([^`]*)(`)", ByGroups(LiteralString, UsingLexer(TypeRemappingLexer(GoTextTemplate, TypeMapping{{Other, LiteralString, nil}})), LiteralString), nil}, + {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, + {`(<<=|>>=|<<|>>|<=|>=|&\^=|&\^|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\||<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&])`, Operator, nil}, + {`([a-zA-Z_]\w*)(\s*)(\()`, ByGroups(NameFunction, UsingSelf("root"), Punctuation), nil}, + {`[|^<>=!()\[\]{}.,;:]`, Punctuation, nil}, + {`[^\W\d]\w*`, NameOther, nil}, + }, + } +} + +var GoHTMLTemplate = Register(DelegatingLexer(HTML, MustNewXMLLexer( + embedded, + "embedded/go_template.xml", +).SetConfig( + &Config{ + Name: "Go HTML Template", + Aliases: []string{"go-html-template"}, + }, +))) + +var GoTextTemplate = Register(MustNewXMLLexer( + embedded, + "embedded/go_template.xml", +).SetConfig( + &Config{ + Name: "Go Text Template", + Aliases: []string{"go-text-template"}, + }, +)) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/haxe.go b/vendor/github.com/alecthomas/chroma/v2/lexers/haxe.go new file mode 100644 index 0000000..6e23938 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/haxe.go @@ -0,0 +1,645 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Haxe lexer. +var Haxe = Register(MustNewLexer( + &Config{ + Name: "Haxe", + Aliases: []string{"hx", "haxe", "hxsl"}, + Filenames: []string{"*.hx", "*.hxsl"}, + MimeTypes: []string{"text/haxe", "text/x-haxe", "text/x-hx"}, + DotAll: true, + }, + haxeRules, +)) + +func haxeRules() Rules { + return Rules{ + "root": { + Include("spaces"), + Include("meta"), + {`(?:package)\b`, KeywordNamespace, Push("semicolon", "package")}, + {`(?:import)\b`, KeywordNamespace, Push("semicolon", "import")}, + {`(?:using)\b`, KeywordNamespace, Push("semicolon", "using")}, + {`(?:extern|private)\b`, KeywordDeclaration, nil}, + {`(?:abstract)\b`, KeywordDeclaration, Push("abstract")}, + {`(?:class|interface)\b`, KeywordDeclaration, Push("class")}, + {`(?:enum)\b`, KeywordDeclaration, Push("enum")}, + {`(?:typedef)\b`, KeywordDeclaration, Push("typedef")}, + {`(?=.)`, Text, Push("expr-statement")}, + }, + "spaces": { + {`\s+`, Text, nil}, + {`//[^\n\r]*`, CommentSingle, nil}, + {`/\*.*?\*/`, CommentMultiline, nil}, + {`(#)(if|elseif|else|end|error)\b`, CommentPreproc, MutatorFunc(haxePreProcMutator)}, + }, + "string-single-interpol": { + {`\$\{`, LiteralStringInterpol, Push("string-interpol-close", "expr")}, + {`\$\$`, LiteralStringEscape, nil}, + {`\$(?=(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+))`, LiteralStringInterpol, Push("ident")}, + Include("string-single"), + }, + "string-single": { + {`'`, LiteralStringSingle, Pop(1)}, + {`\\.`, LiteralStringEscape, nil}, + {`.`, LiteralStringSingle, nil}, + }, + "string-double": { + {`"`, LiteralStringDouble, Pop(1)}, + {`\\.`, LiteralStringEscape, nil}, + {`.`, LiteralStringDouble, nil}, + }, + "string-interpol-close": { + {`\$(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, LiteralStringInterpol, nil}, + {`\}`, LiteralStringInterpol, Pop(1)}, + }, + "package": { + Include("spaces"), + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil}, + {`\.`, Punctuation, Push("import-ident")}, + Default(Pop(1)), + }, + "import": { + Include("spaces"), + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil}, + {`\*`, Keyword, nil}, + {`\.`, Punctuation, Push("import-ident")}, + {`in`, KeywordNamespace, Push("ident")}, + Default(Pop(1)), + }, + "import-ident": { + Include("spaces"), + {`\*`, Keyword, Pop(1)}, + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, Pop(1)}, + }, + "using": { + Include("spaces"), + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil}, + {`\.`, Punctuation, Push("import-ident")}, + Default(Pop(1)), + }, + "preproc-error": { + {`\s+`, CommentPreproc, nil}, + {`'`, LiteralStringSingle, Push("#pop", "string-single")}, + {`"`, LiteralStringDouble, Push("#pop", "string-double")}, + Default(Pop(1)), + }, + "preproc-expr": { + {`\s+`, CommentPreproc, nil}, + {`\!`, CommentPreproc, nil}, + {`\(`, CommentPreproc, Push("#pop", "preproc-parenthesis")}, + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, CommentPreproc, Pop(1)}, + {`\.[0-9]+`, LiteralNumberFloat, nil}, + {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, nil}, + {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, nil}, + {`[0-9]+\.[0-9]+`, LiteralNumberFloat, nil}, + {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, nil}, + {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, + {`[0-9]+`, LiteralNumberInteger, nil}, + {`'`, LiteralStringSingle, Push("#pop", "string-single")}, + {`"`, LiteralStringDouble, Push("#pop", "string-double")}, + }, + "preproc-parenthesis": { + {`\s+`, CommentPreproc, nil}, + {`\)`, CommentPreproc, Pop(1)}, + Default(Push("preproc-expr-in-parenthesis")), + }, + "preproc-expr-chain": { + {`\s+`, CommentPreproc, nil}, + {`(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|/|\-|=>|=)`, CommentPreproc, Push("#pop", "preproc-expr-in-parenthesis")}, + Default(Pop(1)), + }, + "preproc-expr-in-parenthesis": { + {`\s+`, CommentPreproc, nil}, + {`\!`, CommentPreproc, nil}, + {`\(`, CommentPreproc, Push("#pop", "preproc-expr-chain", "preproc-parenthesis")}, + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, CommentPreproc, Push("#pop", "preproc-expr-chain")}, + {`\.[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, + {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, + {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, + {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, + {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, + {`0x[0-9a-fA-F]+`, LiteralNumberHex, Push("#pop", "preproc-expr-chain")}, + {`[0-9]+`, LiteralNumberInteger, Push("#pop", "preproc-expr-chain")}, + {`'`, LiteralStringSingle, Push("#pop", "preproc-expr-chain", "string-single")}, + {`"`, LiteralStringDouble, Push("#pop", "preproc-expr-chain", "string-double")}, + }, + "abstract": { + Include("spaces"), + Default(Pop(1), Push("abstract-body"), Push("abstract-relation"), Push("abstract-opaque"), Push("type-param-constraint"), Push("type-name")), + }, + "abstract-body": { + Include("spaces"), + {`\{`, Punctuation, Push("#pop", "class-body")}, + }, + "abstract-opaque": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "parenthesis-close", "type")}, + Default(Pop(1)), + }, + "abstract-relation": { + Include("spaces"), + {`(?:to|from)`, KeywordDeclaration, Push("type")}, + {`,`, Punctuation, nil}, + Default(Pop(1)), + }, + "meta": { + Include("spaces"), + {`@`, NameDecorator, Push("meta-body", "meta-ident", "meta-colon")}, + }, + "meta-colon": { + Include("spaces"), + {`:`, NameDecorator, Pop(1)}, + Default(Pop(1)), + }, + "meta-ident": { + Include("spaces"), + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameDecorator, Pop(1)}, + }, + "meta-body": { + Include("spaces"), + {`\(`, NameDecorator, Push("#pop", "meta-call")}, + Default(Pop(1)), + }, + "meta-call": { + Include("spaces"), + {`\)`, NameDecorator, Pop(1)}, + Default(Pop(1), Push("meta-call-sep"), Push("expr")), + }, + "meta-call-sep": { + Include("spaces"), + {`\)`, NameDecorator, Pop(1)}, + {`,`, Punctuation, Push("#pop", "meta-call")}, + }, + "typedef": { + Include("spaces"), + Default(Pop(1), Push("typedef-body"), Push("type-param-constraint"), Push("type-name")), + }, + "typedef-body": { + Include("spaces"), + {`=`, Operator, Push("#pop", "optional-semicolon", "type")}, + }, + "enum": { + Include("spaces"), + Default(Pop(1), Push("enum-body"), Push("bracket-open"), Push("type-param-constraint"), Push("type-name")), + }, + "enum-body": { + Include("spaces"), + Include("meta"), + {`\}`, Punctuation, Pop(1)}, + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("enum-member", "type-param-constraint")}, + }, + "enum-member": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "semicolon", "flag", "function-param")}, + Default(Pop(1), Push("semicolon"), Push("flag")), + }, + "class": { + Include("spaces"), + Default(Pop(1), Push("class-body"), Push("bracket-open"), Push("extends"), Push("type-param-constraint"), Push("type-name")), + }, + "extends": { + Include("spaces"), + {`(?:extends|implements)\b`, KeywordDeclaration, Push("type")}, + {`,`, Punctuation, nil}, + Default(Pop(1)), + }, + "bracket-open": { + Include("spaces"), + {`\{`, Punctuation, Pop(1)}, + }, + "bracket-close": { + Include("spaces"), + {`\}`, Punctuation, Pop(1)}, + }, + "class-body": { + Include("spaces"), + Include("meta"), + {`\}`, Punctuation, Pop(1)}, + {`(?:static|public|private|override|dynamic|inline|macro)\b`, KeywordDeclaration, nil}, + Default(Push("class-member")), + }, + "class-member": { + Include("spaces"), + {`(var)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "var")}, + {`(function)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "class-method")}, + }, + "function-local": { + Include("spaces"), + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameFunction, Push("#pop", "optional-expr", "flag", "function-param", "parenthesis-open", "type-param-constraint")}, + Default(Pop(1), Push("optional-expr"), Push("flag"), Push("function-param"), Push("parenthesis-open"), Push("type-param-constraint")), + }, + "optional-expr": { + Include("spaces"), + Include("expr"), + Default(Pop(1)), + }, + "class-method": { + Include("spaces"), + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameFunction, Push("#pop", "optional-expr", "flag", "function-param", "parenthesis-open", "type-param-constraint")}, + }, + "function-param": { + Include("spaces"), + {`\)`, Punctuation, Pop(1)}, + {`\?`, Punctuation, nil}, + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "function-param-sep", "assign", "flag")}, + }, + "function-param-sep": { + Include("spaces"), + {`\)`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "function-param")}, + }, + "prop-get-set": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "parenthesis-close", "prop-get-set-opt", "comma", "prop-get-set-opt")}, + Default(Pop(1)), + }, + "prop-get-set-opt": { + Include("spaces"), + {`(?:default|null|never|dynamic|get|set)\b`, Keyword, Pop(1)}, + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Text, Pop(1)}, + }, + "expr-statement": { + Include("spaces"), + Default(Pop(1), Push("optional-semicolon"), Push("expr")), + }, + "expr": { + Include("spaces"), + {`@`, NameDecorator, Push("#pop", "optional-expr", "meta-body", "meta-ident", "meta-colon")}, + {`(?:\+\+|\-\-|~(?!/)|!|\-)`, Operator, nil}, + {`\(`, Punctuation, Push("#pop", "expr-chain", "parenthesis")}, + {`(?:static|public|private|override|dynamic|inline)\b`, KeywordDeclaration, nil}, + {`(?:function)\b`, KeywordDeclaration, Push("#pop", "expr-chain", "function-local")}, + {`\{`, Punctuation, Push("#pop", "expr-chain", "bracket")}, + {`(?:true|false|null)\b`, KeywordConstant, Push("#pop", "expr-chain")}, + {`(?:this)\b`, Keyword, Push("#pop", "expr-chain")}, + {`(?:cast)\b`, Keyword, Push("#pop", "expr-chain", "cast")}, + {`(?:try)\b`, Keyword, Push("#pop", "catch", "expr")}, + {`(?:var)\b`, KeywordDeclaration, Push("#pop", "var")}, + {`(?:new)\b`, Keyword, Push("#pop", "expr-chain", "new")}, + {`(?:switch)\b`, Keyword, Push("#pop", "switch")}, + {`(?:if)\b`, Keyword, Push("#pop", "if")}, + {`(?:do)\b`, Keyword, Push("#pop", "do")}, + {`(?:while)\b`, Keyword, Push("#pop", "while")}, + {`(?:for)\b`, Keyword, Push("#pop", "for")}, + {`(?:untyped|throw)\b`, Keyword, nil}, + {`(?:return)\b`, Keyword, Push("#pop", "optional-expr")}, + {`(?:macro)\b`, Keyword, Push("#pop", "macro")}, + {`(?:continue|break)\b`, Keyword, Pop(1)}, + {`(?:\$\s*[a-z]\b|\$(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)))`, Name, Push("#pop", "dollar")}, + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "expr-chain")}, + {`\.[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, + {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, + {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, + {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, + {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Push("#pop", "expr-chain")}, + {`0x[0-9a-fA-F]+`, LiteralNumberHex, Push("#pop", "expr-chain")}, + {`[0-9]+`, LiteralNumberInteger, Push("#pop", "expr-chain")}, + {`'`, LiteralStringSingle, Push("#pop", "expr-chain", "string-single-interpol")}, + {`"`, LiteralStringDouble, Push("#pop", "expr-chain", "string-double")}, + {`~/(\\\\|\\/|[^/\n])*/[gimsu]*`, LiteralStringRegex, Push("#pop", "expr-chain")}, + {`\[`, Punctuation, Push("#pop", "expr-chain", "array-decl")}, + }, + "expr-chain": { + Include("spaces"), + {`(?:\+\+|\-\-)`, Operator, nil}, + {`(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|/|\-|=>|=)`, Operator, Push("#pop", "expr")}, + {`(?:in)\b`, Keyword, Push("#pop", "expr")}, + {`\?`, Operator, Push("#pop", "expr", "ternary", "expr")}, + {`(\.)((?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+))`, ByGroups(Punctuation, Name), nil}, + {`\[`, Punctuation, Push("array-access")}, + {`\(`, Punctuation, Push("call")}, + Default(Pop(1)), + }, + "macro": { + Include("spaces"), + Include("meta"), + {`:`, Punctuation, Push("#pop", "type")}, + {`(?:extern|private)\b`, KeywordDeclaration, nil}, + {`(?:abstract)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "abstract")}, + {`(?:class|interface)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "macro-class")}, + {`(?:enum)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "enum")}, + {`(?:typedef)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "typedef")}, + Default(Pop(1), Push("expr")), + }, + "macro-class": { + {`\{`, Punctuation, Push("#pop", "class-body")}, + Include("class"), + }, + "cast": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "parenthesis-close", "cast-type", "expr")}, + Default(Pop(1), Push("expr")), + }, + "cast-type": { + Include("spaces"), + {`,`, Punctuation, Push("#pop", "type")}, + Default(Pop(1)), + }, + "catch": { + Include("spaces"), + {`(?:catch)\b`, Keyword, Push("expr", "function-param", "parenthesis-open")}, + Default(Pop(1)), + }, + "do": { + Include("spaces"), + Default(Pop(1), Push("do-while"), Push("expr")), + }, + "do-while": { + Include("spaces"), + {`(?:while)\b`, Keyword, Push("#pop", "parenthesis", "parenthesis-open")}, + }, + "while": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "expr", "parenthesis")}, + }, + "for": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "expr", "parenthesis")}, + }, + "if": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "else", "optional-semicolon", "expr", "parenthesis")}, + }, + "else": { + Include("spaces"), + {`(?:else)\b`, Keyword, Push("#pop", "expr")}, + Default(Pop(1)), + }, + "switch": { + Include("spaces"), + Default(Pop(1), Push("switch-body"), Push("bracket-open"), Push("expr")), + }, + "switch-body": { + Include("spaces"), + {`(?:case|default)\b`, Keyword, Push("case-block", "case")}, + {`\}`, Punctuation, Pop(1)}, + }, + "case": { + Include("spaces"), + {`:`, Punctuation, Pop(1)}, + Default(Pop(1), Push("case-sep"), Push("case-guard"), Push("expr")), + }, + "case-sep": { + Include("spaces"), + {`:`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "case")}, + }, + "case-guard": { + Include("spaces"), + {`(?:if)\b`, Keyword, Push("#pop", "parenthesis", "parenthesis-open")}, + Default(Pop(1)), + }, + "case-block": { + Include("spaces"), + {`(?!(?:case|default)\b|\})`, Keyword, Push("expr-statement")}, + Default(Pop(1)), + }, + "new": { + Include("spaces"), + Default(Pop(1), Push("call"), Push("parenthesis-open"), Push("type")), + }, + "array-decl": { + Include("spaces"), + {`\]`, Punctuation, Pop(1)}, + Default(Pop(1), Push("array-decl-sep"), Push("expr")), + }, + "array-decl-sep": { + Include("spaces"), + {`\]`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "array-decl")}, + }, + "array-access": { + Include("spaces"), + Default(Pop(1), Push("array-access-close"), Push("expr")), + }, + "array-access-close": { + Include("spaces"), + {`\]`, Punctuation, Pop(1)}, + }, + "comma": { + Include("spaces"), + {`,`, Punctuation, Pop(1)}, + }, + "colon": { + Include("spaces"), + {`:`, Punctuation, Pop(1)}, + }, + "semicolon": { + Include("spaces"), + {`;`, Punctuation, Pop(1)}, + }, + "optional-semicolon": { + Include("spaces"), + {`;`, Punctuation, Pop(1)}, + Default(Pop(1)), + }, + "ident": { + Include("spaces"), + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Pop(1)}, + }, + "dollar": { + Include("spaces"), + {`\{`, Punctuation, Push("#pop", "expr-chain", "bracket-close", "expr")}, + Default(Pop(1), Push("expr-chain")), + }, + "type-name": { + Include("spaces"), + {`_*[A-Z]\w*`, Name, Pop(1)}, + }, + "type-full-name": { + Include("spaces"), + {`\.`, Punctuation, Push("ident")}, + Default(Pop(1)), + }, + "type": { + Include("spaces"), + {`\?`, Punctuation, nil}, + {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "type-check", "type-full-name")}, + {`\{`, Punctuation, Push("#pop", "type-check", "type-struct")}, + {`\(`, Punctuation, Push("#pop", "type-check", "type-parenthesis")}, + }, + "type-parenthesis": { + Include("spaces"), + Default(Pop(1), Push("parenthesis-close"), Push("type")), + }, + "type-check": { + Include("spaces"), + {`->`, Punctuation, Push("#pop", "type")}, + {`<(?!=)`, Punctuation, Push("type-param")}, + Default(Pop(1)), + }, + "type-struct": { + Include("spaces"), + {`\}`, Punctuation, Pop(1)}, + {`\?`, Punctuation, nil}, + {`>`, Punctuation, Push("comma", "type")}, + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "type-struct-sep", "type", "colon")}, + Include("class-body"), + }, + "type-struct-sep": { + Include("spaces"), + {`\}`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "type-struct")}, + }, + "type-param-type": { + {`\.[0-9]+`, LiteralNumberFloat, Pop(1)}, + {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Pop(1)}, + {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Pop(1)}, + {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Pop(1)}, + {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Pop(1)}, + {`0x[0-9a-fA-F]+`, LiteralNumberHex, Pop(1)}, + {`[0-9]+`, LiteralNumberInteger, Pop(1)}, + {`'`, LiteralStringSingle, Push("#pop", "string-single")}, + {`"`, LiteralStringDouble, Push("#pop", "string-double")}, + {`~/(\\\\|\\/|[^/\n])*/[gim]*`, LiteralStringRegex, Pop(1)}, + {`\[`, Operator, Push("#pop", "array-decl")}, + Include("type"), + }, + "type-param": { + Include("spaces"), + Default(Pop(1), Push("type-param-sep"), Push("type-param-type")), + }, + "type-param-sep": { + Include("spaces"), + {`>`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "type-param")}, + }, + "type-param-constraint": { + Include("spaces"), + {`<(?!=)`, Punctuation, Push("#pop", "type-param-constraint-sep", "type-param-constraint-flag", "type-name")}, + Default(Pop(1)), + }, + "type-param-constraint-sep": { + Include("spaces"), + {`>`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "type-param-constraint-sep", "type-param-constraint-flag", "type-name")}, + }, + "type-param-constraint-flag": { + Include("spaces"), + {`:`, Punctuation, Push("#pop", "type-param-constraint-flag-type")}, + Default(Pop(1)), + }, + "type-param-constraint-flag-type": { + Include("spaces"), + {`\(`, Punctuation, Push("#pop", "type-param-constraint-flag-type-sep", "type")}, + Default(Pop(1), Push("type")), + }, + "type-param-constraint-flag-type-sep": { + Include("spaces"), + {`\)`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("type")}, + }, + "parenthesis": { + Include("spaces"), + Default(Pop(1), Push("parenthesis-close"), Push("flag"), Push("expr")), + }, + "parenthesis-open": { + Include("spaces"), + {`\(`, Punctuation, Pop(1)}, + }, + "parenthesis-close": { + Include("spaces"), + {`\)`, Punctuation, Pop(1)}, + }, + "var": { + Include("spaces"), + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Text, Push("#pop", "var-sep", "assign", "flag", "prop-get-set")}, + }, + "var-sep": { + Include("spaces"), + {`,`, Punctuation, Push("#pop", "var")}, + Default(Pop(1)), + }, + "assign": { + Include("spaces"), + {`=`, Operator, Push("#pop", "expr")}, + Default(Pop(1)), + }, + "flag": { + Include("spaces"), + {`:`, Punctuation, Push("#pop", "type")}, + Default(Pop(1)), + }, + "ternary": { + Include("spaces"), + {`:`, Operator, Pop(1)}, + }, + "call": { + Include("spaces"), + {`\)`, Punctuation, Pop(1)}, + Default(Pop(1), Push("call-sep"), Push("expr")), + }, + "call-sep": { + Include("spaces"), + {`\)`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "call")}, + }, + "bracket": { + Include("spaces"), + {`(?!(?:\$\s*[a-z]\b|\$(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+))))(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "bracket-check")}, + {`'`, LiteralStringSingle, Push("#pop", "bracket-check", "string-single")}, + {`"`, LiteralStringDouble, Push("#pop", "bracket-check", "string-double")}, + Default(Pop(1), Push("block")), + }, + "bracket-check": { + Include("spaces"), + {`:`, Punctuation, Push("#pop", "object-sep", "expr")}, + Default(Pop(1), Push("block"), Push("optional-semicolon"), Push("expr-chain")), + }, + "block": { + Include("spaces"), + {`\}`, Punctuation, Pop(1)}, + Default(Push("expr-statement")), + }, + "object": { + Include("spaces"), + {`\}`, Punctuation, Pop(1)}, + Default(Pop(1), Push("object-sep"), Push("expr"), Push("colon"), Push("ident-or-string")), + }, + "ident-or-string": { + Include("spaces"), + {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Pop(1)}, + {`'`, LiteralStringSingle, Push("#pop", "string-single")}, + {`"`, LiteralStringDouble, Push("#pop", "string-double")}, + }, + "object-sep": { + Include("spaces"), + {`\}`, Punctuation, Pop(1)}, + {`,`, Punctuation, Push("#pop", "object")}, + }, + } +} + +func haxePreProcMutator(state *LexerState) error { + stack, ok := state.Get("haxe-pre-proc").([][]string) + if !ok { + stack = [][]string{} + } + + proc := state.Groups[2] + switch proc { + case "if": + stack = append(stack, state.Stack) + case "else", "elseif": + if len(stack) > 0 { + state.Stack = stack[len(stack)-1] + } + case "end": + stack = stack[:len(stack)-1] + } + + if proc == "if" || proc == "elseif" { + state.Stack = append(state.Stack, "preproc-expr") + } + + if proc == "error" { + state.Stack = append(state.Stack, "preproc-error") + } + state.Set("haxe-pre-proc", stack) + return nil +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/html.go b/vendor/github.com/alecthomas/chroma/v2/lexers/html.go new file mode 100644 index 0000000..2fa5cc0 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/html.go @@ -0,0 +1,60 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// HTML lexer. +var HTML = Register(MustNewLexer( + &Config{ + Name: "HTML", + Aliases: []string{"html"}, + Filenames: []string{"*.html", "*.htm", "*.xhtml", "*.xslt"}, + MimeTypes: []string{"text/html", "application/xhtml+xml"}, + NotMultiline: true, + DotAll: true, + CaseInsensitive: true, + }, + htmlRules, +)) + +func htmlRules() Rules { + return Rules{ + "root": { + {`[^<&]+`, Text, nil}, + {`&\S*?;`, NameEntity, nil}, + {`\<\!\[CDATA\[.*?\]\]\>`, CommentPreproc, nil}, + {`<!--`, Comment, Push("comment")}, + {`<\?.*?\?>`, CommentPreproc, nil}, + {`<![^>]*>`, CommentPreproc, nil}, + {`(<)(\s*)(script)(\s*)`, ByGroups(Punctuation, Text, NameTag, Text), Push("script-content", "tag")}, + {`(<)(\s*)(style)(\s*)`, ByGroups(Punctuation, Text, NameTag, Text), Push("style-content", "tag")}, + {`(<)(\s*)([\w:.-]+)`, ByGroups(Punctuation, Text, NameTag), Push("tag")}, + {`(<)(\s*)(/)(\s*)([\w:.-]+)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation, Text, NameTag, Text, Punctuation), nil}, + }, + "comment": { + {`[^-]+`, Comment, nil}, + {`-->`, Comment, Pop(1)}, + {`-`, Comment, nil}, + }, + "tag": { + {`\s+`, Text, nil}, + {`([\w:-]+\s*)(=)(\s*)`, ByGroups(NameAttribute, Operator, Text), Push("attr")}, + {`[\w:-]+`, NameAttribute, nil}, + {`(/?)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation), Pop(1)}, + }, + "script-content": { + {`(<)(\s*)(/)(\s*)(script)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation, Text, NameTag, Text, Punctuation), Pop(1)}, + {`.+?(?=<\s*/\s*script\s*>)`, Using("Javascript"), nil}, + }, + "style-content": { + {`(<)(\s*)(/)(\s*)(style)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation, Text, NameTag, Text, Punctuation), Pop(1)}, + {`.+?(?=<\s*/\s*style\s*>)`, Using("CSS"), nil}, + }, + "attr": { + {`".*?"`, LiteralString, Pop(1)}, + {`'.*?'`, LiteralString, Pop(1)}, + {`[^\s>]+`, LiteralString, Pop(1)}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/http.go b/vendor/github.com/alecthomas/chroma/v2/lexers/http.go new file mode 100644 index 0000000..e756202 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/http.go @@ -0,0 +1,131 @@ +package lexers + +import ( + "strings" + + . "github.com/alecthomas/chroma/v2" // nolint +) + +// HTTP lexer. +var HTTP = Register(httpBodyContentTypeLexer(MustNewLexer( + &Config{ + Name: "HTTP", + Aliases: []string{"http"}, + Filenames: []string{}, + MimeTypes: []string{}, + NotMultiline: true, + DotAll: true, + }, + httpRules, +))) + +func httpRules() Rules { + return Rules{ + "root": { + {`(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}, + {`([\t ]+)([^\r\n]+)(\r?\n|\Z)`, EmitterFunc(httpContinuousHeaderBlock), nil}, + {`\r?\n`, Text, Push("content")}, + }, + "content": { + {`.+`, EmitterFunc(httpContentBlock), nil}, + }, + } +} + +func httpContentBlock(groups []string, state *LexerState) Iterator { + tokens := []Token{ + {Generic, groups[0]}, + } + return Literator(tokens...) +} + +func httpHeaderBlock(groups []string, state *LexerState) Iterator { + tokens := []Token{ + {Name, groups[1]}, + {Text, groups[2]}, + {Operator, groups[3]}, + {Text, groups[4]}, + {Literal, groups[5]}, + {Text, groups[6]}, + } + return Literator(tokens...) +} + +func httpContinuousHeaderBlock(groups []string, state *LexerState) Iterator { + tokens := []Token{ + {Text, groups[1]}, + {Literal, groups[2]}, + {Text, groups[3]}, + } + return Literator(tokens...) +} + +func httpBodyContentTypeLexer(lexer Lexer) Lexer { return &httpBodyContentTyper{lexer} } + +type httpBodyContentTyper struct{ Lexer } + +func (d *httpBodyContentTyper) Tokenise(options *TokeniseOptions, text string) (Iterator, error) { // nolint: gocognit + var contentType string + var isContentType bool + var subIterator Iterator + + it, err := d.Lexer.Tokenise(options, text) + if err != nil { + return nil, err + } + + return func() Token { + token := it() + + if token == EOF { + if subIterator != nil { + return subIterator() + } + return EOF + } + + switch { + case token.Type == Name && strings.ToLower(token.Value) == "content-type": + { + isContentType = true + } + case token.Type == Literal && isContentType: + { + isContentType = false + contentType = strings.TrimSpace(token.Value) + pos := strings.Index(contentType, ";") + if pos > 0 { + contentType = strings.TrimSpace(contentType[:pos]) + } + } + case token.Type == Generic && contentType != "": + { + lexer := MatchMimeType(contentType) + + // application/calendar+xml can be treated as application/xml + // if there's not a better match. + if lexer == nil && strings.Contains(contentType, "+") { + slashPos := strings.Index(contentType, "/") + plusPos := strings.LastIndex(contentType, "+") + contentType = contentType[:slashPos+1] + contentType[plusPos+1:] + lexer = MatchMimeType(contentType) + } + + if lexer == nil { + token.Type = Text + } else { + subIterator, err = lexer.Tokenise(nil, token.Value) + if err != nil { + panic(err) + } + return EOF + } + } + } + return token + }, nil +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/lexers.go b/vendor/github.com/alecthomas/chroma/v2/lexers/lexers.go new file mode 100644 index 0000000..161caef --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/lexers.go @@ -0,0 +1,73 @@ +package lexers + +import ( + "embed" + "io/fs" + + "github.com/alecthomas/chroma/v2" +) + +//go:embed embedded +var embedded embed.FS + +// GlobalLexerRegistry is the global LexerRegistry of Lexers. +var GlobalLexerRegistry = func() *chroma.LexerRegistry { + reg := chroma.NewLexerRegistry() + // index(reg) + paths, err := fs.Glob(embedded, "embedded/*.xml") + if err != nil { + panic(err) + } + for _, path := range paths { + reg.Register(chroma.MustNewXMLLexer(embedded, path)) + } + return reg +}() + +// Names of all lexers, optionally including aliases. +func Names(withAliases bool) []string { + return GlobalLexerRegistry.Names(withAliases) +} + +// Get a Lexer by name, alias or file extension. +func Get(name string) chroma.Lexer { + return GlobalLexerRegistry.Get(name) +} + +// MatchMimeType attempts to find a lexer for the given MIME type. +func MatchMimeType(mimeType string) chroma.Lexer { + return GlobalLexerRegistry.MatchMimeType(mimeType) +} + +// Match returns the first lexer matching filename. +func Match(filename string) chroma.Lexer { + return GlobalLexerRegistry.Match(filename) +} + +// Register a Lexer with the global registry. +func Register(lexer chroma.Lexer) chroma.Lexer { + return GlobalLexerRegistry.Register(lexer) +} + +// Analyse text content and return the "best" lexer.. +func Analyse(text string) chroma.Lexer { + return GlobalLexerRegistry.Analyse(text) +} + +// PlaintextRules is used for the fallback lexer as well as the explicit +// plaintext lexer. +func PlaintextRules() chroma.Rules { + return chroma.Rules{ + "root": []chroma.Rule{ + {`.+`, chroma.Text, nil}, + {`\n`, chroma.Text, nil}, + }, + } +} + +// Fallback lexer if no other is found. +var Fallback chroma.Lexer = chroma.MustNewLexer(&chroma.Config{ + Name: "fallback", + Filenames: []string{"*"}, + Priority: -1, +}, PlaintextRules) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/make.go b/vendor/github.com/alecthomas/chroma/v2/lexers/make.go new file mode 100644 index 0000000..48bdc13 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/make.go @@ -0,0 +1,56 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Makefile lexer. +var Makefile = 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, + }, + makefileRules, +)) + +func makefileRules() Rules { + return 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}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/mako.go b/vendor/github.com/alecthomas/chroma/v2/lexers/mako.go new file mode 100644 index 0000000..0de18fe --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/mako.go @@ -0,0 +1,62 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Mako lexer. +var Mako = Register(MustNewLexer( + &Config{ + Name: "Mako", + Aliases: []string{"mako"}, + Filenames: []string{"*.mao"}, + MimeTypes: []string{"application/x-mako"}, + }, + makoRules, +)) + +func makoRules() Rules { + return 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)}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/markdown.go b/vendor/github.com/alecthomas/chroma/v2/lexers/markdown.go new file mode 100644 index 0000000..1fb9f5b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/markdown.go @@ -0,0 +1,47 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Markdown lexer. +var Markdown = Register(DelegatingLexer(HTML, MustNewLexer( + &Config{ + Name: "markdown", + Aliases: []string{"md", "mkd"}, + Filenames: []string{"*.md", "*.mkd", "*.markdown"}, + MimeTypes: []string{"text/x-markdown"}, + }, + markdownRules, +))) + +func markdownRules() Rules { + return 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(2, 4, String, String, String, Text, String), + nil, + }, + Include("inline"), + }, + "inline": { + {`\\.`, Text, nil}, + {`(\s)(\*|_)((?:(?!\2).)*)(\2)((?=\W|\n))`, ByGroups(Text, GenericEmph, GenericEmph, 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}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/mason.go b/vendor/github.com/alecthomas/chroma/v2/lexers/mason.go new file mode 100644 index 0000000..57e6120 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/mason.go @@ -0,0 +1,44 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Mason lexer. +var Mason = Register(MustNewLexer( + &Config{ + Name: "Mason", + Aliases: []string{"mason"}, + Filenames: []string{"*.m", "*.mhtml", "*.mc", "*.mi", "autohandler", "dhandler"}, + MimeTypes: []string{"application/x-mason"}, + Priority: 0.1, + }, + masonRules, +)) + +func masonRules() Rules { + return 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}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/myghty.go b/vendor/github.com/alecthomas/chroma/v2/lexers/myghty.go new file mode 100644 index 0000000..42ff0e6 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/myghty.go @@ -0,0 +1,42 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Myghty lexer. +var Myghty = Register(MustNewLexer( + &Config{ + Name: "Myghty", + Aliases: []string{"myghty"}, + Filenames: []string{"*.myt", "autodelegate"}, + MimeTypes: []string{"application/x-myghty"}, + }, + myghtyRules, +)) + +func myghtyRules() Rules { + return 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("Python2"), NameTag), nil}, + {`(<&[^|])(.*?)(,.*?)?(&>)`, ByGroups(NameTag, NameFunction, Using("Python2"), NameTag), nil}, + {`(<&\|)(.*?)(,.*?)?(&>)(?s)`, ByGroups(NameTag, NameFunction, Using("Python2"), NameTag), nil}, + {`</&>`, NameTag, nil}, + {`(<%!?)(.*?)(%>)(?s)`, ByGroups(NameTag, Using("Python2"), NameTag), nil}, + {`(?<=^)#[^\n]*(\n|\Z)`, Comment, nil}, + {`(?<=^)(%)([^\n]*)(\n|\Z)`, ByGroups(NameTag, Using("Python2"), 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}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/mysql.go b/vendor/github.com/alecthomas/chroma/v2/lexers/mysql.go new file mode 100644 index 0000000..32e94c2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/mysql.go @@ -0,0 +1,33 @@ +package lexers + +import ( + "regexp" +) + +var ( + mysqlAnalyserNameBetweenBacktickRe = regexp.MustCompile("`[a-zA-Z_]\\w*`") + mysqlAnalyserNameBetweenBracketRe = regexp.MustCompile(`\[[a-zA-Z_]\w*\]`) +) + +func init() { // nolint: gochecknoinits + Get("mysql"). + SetAnalyser(func(text string) float32 { + nameBetweenBacktickCount := len(mysqlAnalyserNameBetweenBacktickRe.FindAllString(text, -1)) + nameBetweenBracketCount := len(mysqlAnalyserNameBetweenBracketRe.FindAllString(text, -1)) + + var result float32 + + // Same logic as above in the TSQL analysis. + dialectNameCount := nameBetweenBacktickCount + nameBetweenBracketCount + if dialectNameCount >= 1 && nameBetweenBacktickCount >= (2*nameBetweenBracketCount) { + // Found at least twice as many `name` as [name]. + result += 0.5 + } else if nameBetweenBacktickCount > nameBetweenBracketCount { + result += 0.2 + } else if nameBetweenBacktickCount > 0 { + result += 0.1 + } + + return result + }) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/openedgeabl.go b/vendor/github.com/alecthomas/chroma/v2/lexers/openedgeabl.go new file mode 100644 index 0000000..ea19631 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/openedgeabl.go @@ -0,0 +1,49 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// OpenedgeAbl lexer. +var OpenEdgeABL = Register(MustNewLexer( + &Config{ + Name: "OpenEdge ABL", + Aliases: []string{"openedge", "abl", "progress", "openedgeabl"}, + Filenames: []string{"*.p", "*.cls", "*.w", "*.i"}, + MimeTypes: []string{"text/x-openedge", "application/x-openedge"}, + }, + func() Rules { + return Rules{ + "root": { + {`/\*`, CommentMultiline, Push("comment")}, + {`//.*?$`, CommentSingle, nil}, + {`\{`, CommentPreproc, Push("preprocessor")}, + {`\s*&.*`, CommentPreproc, nil}, + {`0[xX][0-9a-fA-F]+[LlUu]*`, LiteralNumberHex, nil}, + {`(?i)(DEFINE|DEF|DEFI|DEFIN)\b`, KeywordDeclaration, nil}, + {`(?i)(^|(?<=[^\w\-]))(CHARACTER|CHAR|CHARA|CHARAC|CHARACT|CHARACTE|COM-HANDLE|DATE|DATETIME|DATETIME-TZ|DECIMAL|DEC|DECI|DECIM|DECIMA|HANDLE|INT64|INTEGER|INT|INTE|INTEG|INTEGE|LOGICAL|LONGCHAR|MEMPTR|RAW|RECID|ROWID)\s*($|(?=[^\w\-]))`, KeywordType, nil}, + {Words(`(?i)(^|(?<=[^\w\-]))`, `\s*($|(?=[^\w\-]))`, `ABS`, `ABSO`, `ABSOL`, `ABSOLU`, `ABSOLUT`, `ABSOLUTE`, `ABSTRACT`, `ACCELERATOR`, `ACCUM`, `ACCUMU`, `ACCUMUL`, `ACCUMULA`, `ACCUMULAT`, `ACCUMULATE`, `ACTIVE-FORM`, `ACTIVE-WINDOW`, `ADD`, `ADD-BUFFER`, `ADD-CALC-COLUMN`, `ADD-COLUMNS-FROM`, `ADD-EVENTS-PROCEDURE`, `ADD-FIELDS-FROM`, `ADD-FIRST`, `ADD-INDEX-FIELD`, `ADD-LAST`, `ADD-LIKE-COLUMN`, `ADD-LIKE-FIELD`, `ADD-LIKE-INDEX`, `ADD-NEW-FIELD`, `ADD-NEW-INDEX`, `ADD-SCHEMA-LOCATION`, `ADD-SUPER-PROCEDURE`, `ADM-DATA`, `ADVISE`, `ALERT-BOX`, `ALIAS`, `ALL`, `ALLOW-COLUMN-SEARCHING`, `ALLOW-REPLICATION`, `ALTER`, `ALWAYS-ON-TOP`, `AMBIG`, `AMBIGU`, `AMBIGUO`, `AMBIGUOU`, `AMBIGUOUS`, `ANALYZ`, `ANALYZE`, `AND`, `ANSI-ONLY`, `ANY`, `ANYWHERE`, `APPEND`, `APPL-ALERT`, `APPL-ALERT-`, `APPL-ALERT-B`, `APPL-ALERT-BO`, `APPL-ALERT-BOX`, `APPL-ALERT-BOXE`, `APPL-ALERT-BOXES`, `APPL-CONTEXT-ID`, `APPLICATION`, `APPLY`, `APPSERVER-INFO`, `APPSERVER-PASSWORD`, `APPSERVER-USERID`, `ARRAY-MESSAGE`, `AS`, `ASC`, `ASCE`, `ASCEN`, `ASCEND`, `ASCENDI`, `ASCENDIN`, `ASCENDING`, `ASK-OVERWRITE`, `ASSEMBLY`, `ASSIGN`, `ASYNC-REQUEST-COUNT`, `ASYNC-REQUEST-HANDLE`, `ASYNCHRONOUS`, `AT`, `ATTACHED-PAIRLIST`, `ATTR`, `ATTR-SPACE`, `ATTRI`, `ATTRIB`, `ATTRIBU`, `ATTRIBUT`, `AUDIT-CONTROL`, `AUDIT-ENABLED`, `AUDIT-EVENT-CONTEXT`, `AUDIT-POLICY`, `AUTHENTICATION-FAILED`, `AUTHORIZATION`, `AUTO-COMP`, `AUTO-COMPL`, `AUTO-COMPLE`, `AUTO-COMPLET`, `AUTO-COMPLETI`, `AUTO-COMPLETIO`, `AUTO-COMPLETION`, `AUTO-END-KEY`, `AUTO-ENDKEY`, `AUTO-GO`, `AUTO-IND`, `AUTO-INDE`, `AUTO-INDEN`, `AUTO-INDENT`, `AUTO-RESIZE`, `AUTO-RET`, `AUTO-RETU`, `AUTO-RETUR`, `AUTO-RETURN`, `AUTO-SYNCHRONIZE`, `AUTO-Z`, `AUTO-ZA`, `AUTO-ZAP`, `AUTOMATIC`, `AVAIL`, `AVAILA`, `AVAILAB`, `AVAILABL`, `AVAILABLE`, `AVAILABLE-FORMATS`, `AVE`, `AVER`, `AVERA`, `AVERAG`, `AVERAGE`, `AVG`, `BACK`, `BACKG`, `BACKGR`, `BACKGRO`, `BACKGROU`, `BACKGROUN`, `BACKGROUND`, `BACKWARD`, `BACKWARDS`, `BASE64-DECODE`, `BASE64-ENCODE`, `BASE-ADE`, `BASE-KEY`, `BATCH`, `BATCH-`, `BATCH-M`, `BATCH-MO`, `BATCH-MOD`, `BATCH-MODE`, `BATCH-SIZE`, `BEFORE-H`, `BEFORE-HI`, `BEFORE-HID`, `BEFORE-HIDE`, `BEGIN-EVENT-GROUP`, `BEGINS`, `BELL`, `BETWEEN`, `BGC`, `BGCO`, `BGCOL`, `BGCOLO`, `BGCOLOR`, `BIG-ENDIAN`, `BINARY`, `BIND`, `BIND-WHERE`, `BLANK`, `BLOCK-ITERATION-DISPLAY`, `BLOCK-LEVEL`, `BORDER-B`, `BORDER-BO`, `BORDER-BOT`, `BORDER-BOTT`, `BORDER-BOTTO`, `BORDER-BOTTOM-CHARS`, `BORDER-BOTTOM-P`, `BORDER-BOTTOM-PI`, `BORDER-BOTTOM-PIX`, `BORDER-BOTTOM-PIXE`, `BORDER-BOTTOM-PIXEL`, `BORDER-BOTTOM-PIXELS`, `BORDER-L`, `BORDER-LE`, `BORDER-LEF`, `BORDER-LEFT`, `BORDER-LEFT-`, `BORDER-LEFT-C`, `BORDER-LEFT-CH`, `BORDER-LEFT-CHA`, `BORDER-LEFT-CHAR`, `BORDER-LEFT-CHARS`, `BORDER-LEFT-P`, `BORDER-LEFT-PI`, `BORDER-LEFT-PIX`, `BORDER-LEFT-PIXE`, `BORDER-LEFT-PIXEL`, `BORDER-LEFT-PIXELS`, `BORDER-R`, `BORDER-RI`, `BORDER-RIG`, `BORDER-RIGH`, `BORDER-RIGHT`, `BORDER-RIGHT-`, `BORDER-RIGHT-C`, `BORDER-RIGHT-CH`, `BORDER-RIGHT-CHA`, `BORDER-RIGHT-CHAR`, `BORDER-RIGHT-CHARS`, `BORDER-RIGHT-P`, `BORDER-RIGHT-PI`, `BORDER-RIGHT-PIX`, `BORDER-RIGHT-PIXE`, `BORDER-RIGHT-PIXEL`, `BORDER-RIGHT-PIXELS`, `BORDER-T`, `BORDER-TO`, `BORDER-TOP`, `BORDER-TOP-`, `BORDER-TOP-C`, `BORDER-TOP-CH`, `BORDER-TOP-CHA`, `BORDER-TOP-CHAR`, `BORDER-TOP-CHARS`, `BORDER-TOP-P`, `BORDER-TOP-PI`, `BORDER-TOP-PIX`, `BORDER-TOP-PIXE`, `BORDER-TOP-PIXEL`, `BORDER-TOP-PIXELS`, `BOX`, `BOX-SELECT`, `BOX-SELECTA`, `BOX-SELECTAB`, `BOX-SELECTABL`, `BOX-SELECTABLE`, `BREAK`, `BROWSE`, `BUFFER`, `BUFFER-CHARS`, `BUFFER-COMPARE`, `BUFFER-COPY`, `BUFFER-CREATE`, `BUFFER-DELETE`, `BUFFER-FIELD`, `BUFFER-HANDLE`, `BUFFER-LINES`, `BUFFER-NAME`, `BUFFER-PARTITION-ID`, `BUFFER-RELEASE`, `BUFFER-VALUE`, `BUTTON`, `BUTTONS`, `BY`, `BY-POINTER`, `BY-VARIANT-POINTER`, `CACHE`, `CACHE-SIZE`, `CALL`, `CALL-NAME`, `CALL-TYPE`, `CAN-CREATE`, `CAN-DELETE`, `CAN-DO`, `CAN-DO-DOMAIN-SUPPORT`, `CAN-FIND`, `CAN-QUERY`, `CAN-READ`, `CAN-SET`, `CAN-WRITE`, `CANCEL-BREAK`, `CANCEL-BUTTON`, `CAPS`, `CAREFUL-PAINT`, `CASE`, `CASE-SEN`, `CASE-SENS`, `CASE-SENSI`, `CASE-SENSIT`, `CASE-SENSITI`, `CASE-SENSITIV`, `CASE-SENSITIVE`, `CAST`, `CATCH`, `CDECL`, `CENTER`, `CENTERE`, `CENTERED`, `CHAINED`, `CHARACTER`, `CHARACTER_LENGTH`, `CHARSET`, `CHECK`, `CHECKED`, `CHOOSE`, `CHR`, `CLASS`, `CLASS-TYPE`, `CLEAR`, `CLEAR-APPL-CONTEXT`, `CLEAR-LOG`, `CLEAR-SELECT`, `CLEAR-SELECTI`, `CLEAR-SELECTIO`, `CLEAR-SELECTION`, `CLEAR-SORT-ARROW`, `CLEAR-SORT-ARROWS`, `CLIENT-CONNECTION-ID`, `CLIENT-PRINCIPAL`, `CLIENT-TTY`, `CLIENT-TYPE`, `CLIENT-WORKSTATION`, `CLIPBOARD`, `CLOSE`, `CLOSE-LOG`, `CODE`, `CODEBASE-LOCATOR`, `CODEPAGE`, `CODEPAGE-CONVERT`, `COL`, `COL-OF`, `COLLATE`, `COLON`, `COLON-ALIGN`, `COLON-ALIGNE`, `COLON-ALIGNED`, `COLOR`, `COLOR-TABLE`, `COLU`, `COLUM`, `COLUMN`, `COLUMN-BGCOLOR`, `COLUMN-DCOLOR`, `COLUMN-FGCOLOR`, `COLUMN-FONT`, `COLUMN-LAB`, `COLUMN-LABE`, `COLUMN-LABEL`, `COLUMN-MOVABLE`, `COLUMN-OF`, `COLUMN-PFCOLOR`, `COLUMN-READ-ONLY`, `COLUMN-RESIZABLE`, `COLUMN-SCROLLING`, `COLUMNS`, `COM-HANDLE`, `COM-SELF`, `COMBO-BOX`, `COMMAND`, `COMPARES`, `COMPILE`, `COMPILER`, `COMPLETE`, `CONFIG-NAME`, `CONNECT`, `CONNECTED`, `CONSTRUCTOR`, `CONTAINS`, `CONTENTS`, `CONTEXT`, `CONTEXT-HELP`, `CONTEXT-HELP-FILE`, `CONTEXT-HELP-ID`, `CONTEXT-POPUP`, `CONTROL`, `CONTROL-BOX`, `CONTROL-FRAME`, `CONVERT`, `CONVERT-3D-COLORS`, `CONVERT-TO-OFFS`, `CONVERT-TO-OFFSE`, `CONVERT-TO-OFFSET`, `COPY-DATASET`, `COPY-LOB`, `COPY-SAX-ATTRIBUTES`, `COPY-TEMP-TABLE`, `COUNT`, `COUNT-OF`, `CPCASE`, `CPCOLL`, `CPINTERNAL`, `CPLOG`, `CPPRINT`, `CPRCODEIN`, `CPRCODEOUT`, `CPSTREAM`, `CPTERM`, `CRC-VALUE`, `CREATE`, `CREATE-LIKE`, `CREATE-LIKE-SEQUENTIAL`, `CREATE-NODE-NAMESPACE`, `CREATE-RESULT-LIST-ENTRY`, `CREATE-TEST-FILE`, `CURRENT`, `CURRENT-CHANGED`, `CURRENT-COLUMN`, `CURRENT-ENV`, `CURRENT-ENVI`, `CURRENT-ENVIR`, `CURRENT-ENVIRO`, `CURRENT-ENVIRON`, `CURRENT-ENVIRONM`, `CURRENT-ENVIRONME`, `CURRENT-ENVIRONMEN`, `CURRENT-ENVIRONMENT`, `CURRENT-ITERATION`, `CURRENT-LANG`, `CURRENT-LANGU`, `CURRENT-LANGUA`, `CURRENT-LANGUAG`, `CURRENT-LANGUAGE`, `CURRENT-QUERY`, `CURRENT-REQUEST-INFO`, `CURRENT-RESPONSE-INFO`, `CURRENT-RESULT-ROW`, `CURRENT-ROW-MODIFIED`, `CURRENT-VALUE`, `CURRENT-WINDOW`, `CURRENT_DATE`, `CURS`, `CURSO`, `CURSOR`, `CURSOR-CHAR`, `CURSOR-LINE`, `CURSOR-OFFSET`, `DATA-BIND`, `DATA-ENTRY-RET`, `DATA-ENTRY-RETU`, `DATA-ENTRY-RETUR`, `DATA-ENTRY-RETURN`, `DATA-REL`, `DATA-RELA`, `DATA-RELAT`, `DATA-RELATI`, `DATA-RELATIO`, `DATA-RELATION`, `DATA-SOURCE`, `DATA-SOURCE-COMPLETE-MAP`, `DATA-SOURCE-MODIFIED`, `DATA-SOURCE-ROWID`, `DATA-T`, `DATA-TY`, `DATA-TYP`, `DATA-TYPE`, `DATABASE`, `DATASERVERS`, `DATASET`, `DATASET-HANDLE`, `DATE`, `DATE-F`, `DATE-FO`, `DATE-FOR`, `DATE-FORM`, `DATE-FORMA`, `DATE-FORMAT`, `DAY`, `DB-CONTEXT`, `DB-REFERENCES`, `DBCODEPAGE`, `DBCOLLATION`, `DBNAME`, `DBPARAM`, `DBREST`, `DBRESTR`, `DBRESTRI`, `DBRESTRIC`, `DBRESTRICT`, `DBRESTRICTI`, `DBRESTRICTIO`, `DBRESTRICTION`, `DBRESTRICTIONS`, `DBTASKID`, `DBTYPE`, `DBVERS`, `DBVERSI`, `DBVERSIO`, `DBVERSION`, `DCOLOR`, `DDE`, `DDE-ERROR`, `DDE-I`, `DDE-ID`, `DDE-ITEM`, `DDE-NAME`, `DDE-TOPIC`, `DEBLANK`, `DEBU`, `DEBUG`, `DEBUG-ALERT`, `DEBUG-LIST`, `DEBUGGER`, `DECIMAL`, `DECIMALS`, `DECLARE`, `DECLARE-NAMESPACE`, `DECRYPT`, `DEFAULT`, `DEFAULT-B`, `DEFAULT-BU`, `DEFAULT-BUFFER-HANDLE`, `DEFAULT-BUT`, `DEFAULT-BUTT`, `DEFAULT-BUTTO`, `DEFAULT-BUTTON`, `DEFAULT-COMMIT`, `DEFAULT-EX`, `DEFAULT-EXT`, `DEFAULT-EXTE`, `DEFAULT-EXTEN`, `DEFAULT-EXTENS`, `DEFAULT-EXTENSI`, `DEFAULT-EXTENSIO`, `DEFAULT-EXTENSION`, `DEFAULT-NOXL`, `DEFAULT-NOXLA`, `DEFAULT-NOXLAT`, `DEFAULT-NOXLATE`, `DEFAULT-VALUE`, `DEFAULT-WINDOW`, `DEFINE`, `DEFINE-USER-EVENT-MANAGER`, `DEFINED`, `DEL`, `DELE`, `DELEGATE`, `DELET`, `DELETE PROCEDURE`, `DELETE`, `DELETE-CHAR`, `DELETE-CHARA`, `DELETE-CHARAC`, `DELETE-CHARACT`, `DELETE-CHARACTE`, `DELETE-CHARACTER`, `DELETE-CURRENT-ROW`, `DELETE-LINE`, `DELETE-RESULT-LIST-ENTRY`, `DELETE-SELECTED-ROW`, `DELETE-SELECTED-ROWS`, `DELIMITER`, `DESC`, `DESCE`, `DESCEN`, `DESCEND`, `DESCENDI`, `DESCENDIN`, `DESCENDING`, `DESELECT-FOCUSED-ROW`, `DESELECT-ROWS`, `DESELECT-SELECTED-ROW`, `DESELECTION`, `DESTRUCTOR`, `DIALOG-BOX`, `DICT`, `DICTI`, `DICTIO`, `DICTION`, `DICTIONA`, `DICTIONAR`, `DICTIONARY`, `DIR`, `DISABLE`, `DISABLE-AUTO-ZAP`, `DISABLE-DUMP-TRIGGERS`, `DISABLE-LOAD-TRIGGERS`, `DISABLED`, `DISCON`, `DISCONN`, `DISCONNE`, `DISCONNEC`, `DISCONNECT`, `DISP`, `DISPL`, `DISPLA`, `DISPLAY`, `DISPLAY-MESSAGE`, `DISPLAY-T`, `DISPLAY-TY`, `DISPLAY-TYP`, `DISPLAY-TYPE`, `DISTINCT`, `DO`, `DOMAIN-DESCRIPTION`, `DOMAIN-NAME`, `DOMAIN-TYPE`, `DOS`, `DOUBLE`, `DOWN`, `DRAG-ENABLED`, `DROP`, `DROP-DOWN`, `DROP-DOWN-LIST`, `DROP-FILE-NOTIFY`, `DROP-TARGET`, `DS-CLOSE-CURSOR`, `DSLOG-MANAGER`, `DUMP`, `DYNAMIC`, `DYNAMIC-ENUM`, `DYNAMIC-FUNCTION`, `DYNAMIC-INVOKE`, `EACH`, `ECHO`, `EDGE`, `EDGE-`, `EDGE-C`, `EDGE-CH`, `EDGE-CHA`, `EDGE-CHAR`, `EDGE-CHARS`, `EDGE-P`, `EDGE-PI`, `EDGE-PIX`, `EDGE-PIXE`, `EDGE-PIXEL`, `EDGE-PIXELS`, `EDIT-CAN-PASTE`, `EDIT-CAN-UNDO`, `EDIT-CLEAR`, `EDIT-COPY`, `EDIT-CUT`, `EDIT-PASTE`, `EDIT-UNDO`, `EDITING`, `EDITOR`, `ELSE`, `EMPTY`, `EMPTY-TEMP-TABLE`, `ENABLE`, `ENABLED-FIELDS`, `ENCODE`, `ENCRYPT`, `ENCRYPT-AUDIT-MAC-KEY`, `ENCRYPTION-SALT`, `END`, `END-DOCUMENT`, `END-ELEMENT`, `END-EVENT-GROUP`, `END-FILE-DROP`, `END-KEY`, `END-MOVE`, `END-RESIZE`, `END-ROW-RESIZE`, `END-USER-PROMPT`, `ENDKEY`, `ENTERED`, `ENTITY-EXPANSION-LIMIT`, `ENTRY`, `ENUM`, `EQ`, `ERROR`, `ERROR-COL`, `ERROR-COLU`, `ERROR-COLUM`, `ERROR-COLUMN`, `ERROR-ROW`, `ERROR-STACK-TRACE`, `ERROR-STAT`, `ERROR-STATU`, `ERROR-STATUS`, `ESCAPE`, `ETIME`, `EVENT`, `EVENT-GROUP-ID`, `EVENT-PROCEDURE`, `EVENT-PROCEDURE-CONTEXT`, `EVENT-T`, `EVENT-TY`, `EVENT-TYP`, `EVENT-TYPE`, `EVENTS`, `EXCEPT`, `EXCLUSIVE`, `EXCLUSIVE-`, `EXCLUSIVE-ID`, `EXCLUSIVE-L`, `EXCLUSIVE-LO`, `EXCLUSIVE-LOC`, `EXCLUSIVE-LOCK`, `EXCLUSIVE-WEB-USER`, `EXECUTE`, `EXISTS`, `EXP`, `EXPAND`, `EXPANDABLE`, `EXPLICIT`, `EXPORT`, `EXPORT-PRINCIPAL`, `EXTENDED`, `EXTENT`, `EXTERNAL`, `FALSE`, `FETCH`, `FETCH-SELECTED-ROW`, `FGC`, `FGCO`, `FGCOL`, `FGCOLO`, `FGCOLOR`, `FIELD`, `FIELDS`, `FILE`, `FILE-CREATE-DATE`, `FILE-CREATE-TIME`, `FILE-INFO`, `FILE-INFOR`, `FILE-INFORM`, `FILE-INFORMA`, `FILE-INFORMAT`, `FILE-INFORMATI`, `FILE-INFORMATIO`, `FILE-INFORMATION`, `FILE-MOD-DATE`, `FILE-MOD-TIME`, `FILE-NAME`, `FILE-OFF`, `FILE-OFFS`, `FILE-OFFSE`, `FILE-OFFSET`, `FILE-SIZE`, `FILE-TYPE`, `FILENAME`, `FILL`, `FILL-IN`, `FILLED`, `FILTERS`, `FINAL`, `FINALLY`, `FIND`, `FIND-BY-ROWID`, `FIND-CASE-SENSITIVE`, `FIND-CURRENT`, `FIND-FIRST`, `FIND-GLOBAL`, `FIND-LAST`, `FIND-NEXT-OCCURRENCE`, `FIND-PREV-OCCURRENCE`, `FIND-SELECT`, `FIND-UNIQUE`, `FIND-WRAP-AROUND`, `FINDER`, `FIRST`, `FIRST-ASYNCH-REQUEST`, `FIRST-CHILD`, `FIRST-COLUMN`, `FIRST-FORM`, `FIRST-OBJECT`, `FIRST-OF`, `FIRST-PROC`, `FIRST-PROCE`, `FIRST-PROCED`, `FIRST-PROCEDU`, `FIRST-PROCEDUR`, `FIRST-PROCEDURE`, `FIRST-SERVER`, `FIRST-TAB-I`, `FIRST-TAB-IT`, `FIRST-TAB-ITE`, `FIRST-TAB-ITEM`, `FIT-LAST-COLUMN`, `FIXED-ONLY`, `FLAT-BUTTON`, `FLOAT`, `FOCUS`, `FOCUSED-ROW`, `FOCUSED-ROW-SELECTED`, `FONT`, `FONT-TABLE`, `FOR`, `FORCE-FILE`, `FORE`, `FOREG`, `FOREGR`, `FOREGRO`, `FOREGROU`, `FOREGROUN`, `FOREGROUND`, `FORM INPUT`, `FORM`, `FORM-LONG-INPUT`, `FORMA`, `FORMAT`, `FORMATTE`, `FORMATTED`, `FORWARD`, `FORWARDS`, `FRAGMEN`, `FRAGMENT`, `FRAM`, `FRAME`, `FRAME-COL`, `FRAME-DB`, `FRAME-DOWN`, `FRAME-FIELD`, `FRAME-FILE`, `FRAME-INDE`, `FRAME-INDEX`, `FRAME-LINE`, `FRAME-NAME`, `FRAME-ROW`, `FRAME-SPA`, `FRAME-SPAC`, `FRAME-SPACI`, `FRAME-SPACIN`, `FRAME-SPACING`, `FRAME-VAL`, `FRAME-VALU`, `FRAME-VALUE`, `FRAME-X`, `FRAME-Y`, `FREQUENCY`, `FROM`, `FROM-C`, `FROM-CH`, `FROM-CHA`, `FROM-CHAR`, `FROM-CHARS`, `FROM-CUR`, `FROM-CURR`, `FROM-CURRE`, `FROM-CURREN`, `FROM-CURRENT`, `FROM-P`, `FROM-PI`, `FROM-PIX`, `FROM-PIXE`, `FROM-PIXEL`, `FROM-PIXELS`, `FULL-HEIGHT`, `FULL-HEIGHT-`, `FULL-HEIGHT-C`, `FULL-HEIGHT-CH`, `FULL-HEIGHT-CHA`, `FULL-HEIGHT-CHAR`, `FULL-HEIGHT-CHARS`, `FULL-HEIGHT-P`, `FULL-HEIGHT-PI`, `FULL-HEIGHT-PIX`, `FULL-HEIGHT-PIXE`, `FULL-HEIGHT-PIXEL`, `FULL-HEIGHT-PIXELS`, `FULL-PATHN`, `FULL-PATHNA`, `FULL-PATHNAM`, `FULL-PATHNAME`, `FULL-WIDTH`, `FULL-WIDTH-`, `FULL-WIDTH-C`, `FULL-WIDTH-CH`, `FULL-WIDTH-CHA`, `FULL-WIDTH-CHAR`, `FULL-WIDTH-CHARS`, `FULL-WIDTH-P`, `FULL-WIDTH-PI`, `FULL-WIDTH-PIX`, `FULL-WIDTH-PIXE`, `FULL-WIDTH-PIXEL`, `FULL-WIDTH-PIXELS`, `FUNCTION`, `FUNCTION-CALL-TYPE`, `GATEWAY`, `GATEWAYS`, `GE`, `GENERATE-MD5`, `GENERATE-PBE-KEY`, `GENERATE-PBE-SALT`, `GENERATE-RANDOM-KEY`, `GENERATE-UUID`, `GET`, `GET-ATTR-CALL-TYPE`, `GET-ATTRIBUTE-NODE`, `GET-BINARY-DATA`, `GET-BLUE`, `GET-BLUE-`, `GET-BLUE-V`, `GET-BLUE-VA`, `GET-BLUE-VAL`, `GET-BLUE-VALU`, `GET-BLUE-VALUE`, `GET-BROWSE-COLUMN`, `GET-BUFFER-HANDLE`, `GET-BYTE`, `GET-CALLBACK-PROC-CONTEXT`, `GET-CALLBACK-PROC-NAME`, `GET-CGI-LIST`, `GET-CGI-LONG-VALUE`, `GET-CGI-VALUE`, `GET-CLASS`, `GET-CODEPAGES`, `GET-COLLATIONS`, `GET-CONFIG-VALUE`, `GET-CURRENT`, `GET-DOUBLE`, `GET-DROPPED-FILE`, `GET-DYNAMIC`, `GET-ERROR-COLUMN`, `GET-ERROR-ROW`, `GET-FILE`, `GET-FILE-NAME`, `GET-FILE-OFFSE`, `GET-FILE-OFFSET`, `GET-FIRST`, `GET-FLOAT`, `GET-GREEN`, `GET-GREEN-`, `GET-GREEN-V`, `GET-GREEN-VA`, `GET-GREEN-VAL`, `GET-GREEN-VALU`, `GET-GREEN-VALUE`, `GET-INDEX-BY-NAMESPACE-NAME`, `GET-INDEX-BY-QNAME`, `GET-INT64`, `GET-ITERATION`, `GET-KEY-VAL`, `GET-KEY-VALU`, `GET-KEY-VALUE`, `GET-LAST`, `GET-LOCALNAME-BY-INDEX`, `GET-LONG`, `GET-MESSAGE`, `GET-NEXT`, `GET-NUMBER`, `GET-POINTER-VALUE`, `GET-PREV`, `GET-PRINTERS`, `GET-PROPERTY`, `GET-QNAME-BY-INDEX`, `GET-RED`, `GET-RED-`, `GET-RED-V`, `GET-RED-VA`, `GET-RED-VAL`, `GET-RED-VALU`, `GET-RED-VALUE`, `GET-REPOSITIONED-ROW`, `GET-RGB-VALUE`, `GET-SELECTED`, `GET-SELECTED-`, `GET-SELECTED-W`, `GET-SELECTED-WI`, `GET-SELECTED-WID`, `GET-SELECTED-WIDG`, `GET-SELECTED-WIDGE`, `GET-SELECTED-WIDGET`, `GET-SHORT`, `GET-SIGNATURE`, `GET-SIZE`, `GET-STRING`, `GET-TAB-ITEM`, `GET-TEXT-HEIGHT`, `GET-TEXT-HEIGHT-`, `GET-TEXT-HEIGHT-C`, `GET-TEXT-HEIGHT-CH`, `GET-TEXT-HEIGHT-CHA`, `GET-TEXT-HEIGHT-CHAR`, `GET-TEXT-HEIGHT-CHARS`, `GET-TEXT-HEIGHT-P`, `GET-TEXT-HEIGHT-PI`, `GET-TEXT-HEIGHT-PIX`, `GET-TEXT-HEIGHT-PIXE`, `GET-TEXT-HEIGHT-PIXEL`, `GET-TEXT-HEIGHT-PIXELS`, `GET-TEXT-WIDTH`, `GET-TEXT-WIDTH-`, `GET-TEXT-WIDTH-C`, `GET-TEXT-WIDTH-CH`, `GET-TEXT-WIDTH-CHA`, `GET-TEXT-WIDTH-CHAR`, `GET-TEXT-WIDTH-CHARS`, `GET-TEXT-WIDTH-P`, `GET-TEXT-WIDTH-PI`, `GET-TEXT-WIDTH-PIX`, `GET-TEXT-WIDTH-PIXE`, `GET-TEXT-WIDTH-PIXEL`, `GET-TEXT-WIDTH-PIXELS`, `GET-TYPE-BY-INDEX`, `GET-TYPE-BY-NAMESPACE-NAME`, `GET-TYPE-BY-QNAME`, `GET-UNSIGNED-LONG`, `GET-UNSIGNED-SHORT`, `GET-URI-BY-INDEX`, `GET-VALUE-BY-INDEX`, `GET-VALUE-BY-NAMESPACE-NAME`, `GET-VALUE-BY-QNAME`, `GET-WAIT-STATE`, `GETBYTE`, `GLOBAL`, `GO-ON`, `GO-PEND`, `GO-PENDI`, `GO-PENDIN`, `GO-PENDING`, `GRANT`, `GRAPHIC-E`, `GRAPHIC-ED`, `GRAPHIC-EDG`, `GRAPHIC-EDGE`, `GRID-FACTOR-H`, `GRID-FACTOR-HO`, `GRID-FACTOR-HOR`, `GRID-FACTOR-HORI`, `GRID-FACTOR-HORIZ`, `GRID-FACTOR-HORIZO`, `GRID-FACTOR-HORIZON`, `GRID-FACTOR-HORIZONT`, `GRID-FACTOR-HORIZONTA`, `GRID-FACTOR-HORIZONTAL`, `GRID-FACTOR-V`, `GRID-FACTOR-VE`, `GRID-FACTOR-VER`, `GRID-FACTOR-VERT`, `GRID-FACTOR-VERTI`, `GRID-FACTOR-VERTIC`, `GRID-FACTOR-VERTICA`, `GRID-FACTOR-VERTICAL`, `GRID-SNAP`, `GRID-UNIT-HEIGHT`, `GRID-UNIT-HEIGHT-`, `GRID-UNIT-HEIGHT-C`, `GRID-UNIT-HEIGHT-CH`, `GRID-UNIT-HEIGHT-CHA`, `GRID-UNIT-HEIGHT-CHARS`, `GRID-UNIT-HEIGHT-P`, `GRID-UNIT-HEIGHT-PI`, `GRID-UNIT-HEIGHT-PIX`, `GRID-UNIT-HEIGHT-PIXE`, `GRID-UNIT-HEIGHT-PIXEL`, `GRID-UNIT-HEIGHT-PIXELS`, `GRID-UNIT-WIDTH`, `GRID-UNIT-WIDTH-`, `GRID-UNIT-WIDTH-C`, `GRID-UNIT-WIDTH-CH`, `GRID-UNIT-WIDTH-CHA`, `GRID-UNIT-WIDTH-CHAR`, `GRID-UNIT-WIDTH-CHARS`, `GRID-UNIT-WIDTH-P`, `GRID-UNIT-WIDTH-PI`, `GRID-UNIT-WIDTH-PIX`, `GRID-UNIT-WIDTH-PIXE`, `GRID-UNIT-WIDTH-PIXEL`, `GRID-UNIT-WIDTH-PIXELS`, `GRID-VISIBLE`, `GROUP`, `GT`, `GUID`, `HANDLE`, `HANDLER`, `HAS-RECORDS`, `HAVING`, `HEADER`, `HEIGHT`, `HEIGHT-`, `HEIGHT-C`, `HEIGHT-CH`, `HEIGHT-CHA`, `HEIGHT-CHAR`, `HEIGHT-CHARS`, `HEIGHT-P`, `HEIGHT-PI`, `HEIGHT-PIX`, `HEIGHT-PIXE`, `HEIGHT-PIXEL`, `HEIGHT-PIXELS`, `HELP`, `HEX-DECODE`, `HEX-ENCODE`, `HIDDEN`, `HIDE`, `HORI`, `HORIZ`, `HORIZO`, `HORIZON`, `HORIZONT`, `HORIZONTA`, `HORIZONTAL`, `HOST-BYTE-ORDER`, `HTML-CHARSET`, `HTML-END-OF-LINE`, `HTML-END-OF-PAGE`, `HTML-FRAME-BEGIN`, `HTML-FRAME-END`, `HTML-HEADER-BEGIN`, `HTML-HEADER-END`, `HTML-TITLE-BEGIN`, `HTML-TITLE-END`, `HWND`, `ICON`, `IF`, `IMAGE`, `IMAGE-DOWN`, `IMAGE-INSENSITIVE`, `IMAGE-SIZE`, `IMAGE-SIZE-C`, `IMAGE-SIZE-CH`, `IMAGE-SIZE-CHA`, `IMAGE-SIZE-CHAR`, `IMAGE-SIZE-CHARS`, `IMAGE-SIZE-P`, `IMAGE-SIZE-PI`, `IMAGE-SIZE-PIX`, `IMAGE-SIZE-PIXE`, `IMAGE-SIZE-PIXEL`, `IMAGE-SIZE-PIXELS`, `IMAGE-UP`, `IMMEDIATE-DISPLAY`, `IMPLEMENTS`, `IMPORT`, `IMPORT-PRINCIPAL`, `IN`, `IN-HANDLE`, `INCREMENT-EXCLUSIVE-ID`, `INDEX`, `INDEX-HINT`, `INDEX-INFORMATION`, `INDEXED-REPOSITION`, `INDICATOR`, `INFO`, `INFOR`, `INFORM`, `INFORMA`, `INFORMAT`, `INFORMATI`, `INFORMATIO`, `INFORMATION`, `INHERIT-BGC`, `INHERIT-BGCO`, `INHERIT-BGCOL`, `INHERIT-BGCOLO`, `INHERIT-BGCOLOR`, `INHERIT-FGC`, `INHERIT-FGCO`, `INHERIT-FGCOL`, `INHERIT-FGCOLO`, `INHERIT-FGCOLOR`, `INHERITS`, `INIT`, `INITI`, `INITIA`, `INITIAL`, `INITIAL-DIR`, `INITIAL-FILTER`, `INITIALIZE-DOCUMENT-TYPE`, `INITIATE`, `INNER-CHARS`, `INNER-LINES`, `INPUT`, `INPUT-O`, `INPUT-OU`, `INPUT-OUT`, `INPUT-OUTP`, `INPUT-OUTPU`, `INPUT-OUTPUT`, `INPUT-VALUE`, `INSERT`, `INSERT-ATTRIBUTE`, `INSERT-B`, `INSERT-BA`, `INSERT-BAC`, `INSERT-BACK`, `INSERT-BACKT`, `INSERT-BACKTA`, `INSERT-BACKTAB`, `INSERT-FILE`, `INSERT-ROW`, `INSERT-STRING`, `INSERT-T`, `INSERT-TA`, `INSERT-TAB`, `INT64`, `INT`, `INTEGER`, `INTERFACE`, `INTERNAL-ENTRIES`, `INTO`, `INVOKE`, `IS`, `IS-ATTR`, `IS-ATTR-`, `IS-ATTR-S`, `IS-ATTR-SP`, `IS-ATTR-SPA`, `IS-ATTR-SPAC`, `IS-ATTR-SPACE`, `IS-CLASS`, `IS-JSON`, `IS-LEAD-BYTE`, `IS-OPEN`, `IS-PARAMETER-SET`, `IS-PARTITIONED`, `IS-ROW-SELECTED`, `IS-SELECTED`, `IS-XML`, `ITEM`, `ITEMS-PER-ROW`, `JOIN`, `JOIN-BY-SQLDB`, `KBLABEL`, `KEEP-CONNECTION-OPEN`, `KEEP-FRAME-Z`, `KEEP-FRAME-Z-`, `KEEP-FRAME-Z-O`, `KEEP-FRAME-Z-OR`, `KEEP-FRAME-Z-ORD`, `KEEP-FRAME-Z-ORDE`, `KEEP-FRAME-Z-ORDER`, `KEEP-MESSAGES`, `KEEP-SECURITY-CACHE`, `KEEP-TAB-ORDER`, `KEY`, `KEY-CODE`, `KEY-FUNC`, `KEY-FUNCT`, `KEY-FUNCTI`, `KEY-FUNCTIO`, `KEY-FUNCTION`, `KEY-LABEL`, `KEYCODE`, `KEYFUNC`, `KEYFUNCT`, `KEYFUNCTI`, `KEYFUNCTIO`, `KEYFUNCTION`, `KEYLABEL`, `KEYS`, `KEYWORD`, `KEYWORD-ALL`, `LABEL`, `LABEL-BGC`, `LABEL-BGCO`, `LABEL-BGCOL`, `LABEL-BGCOLO`, `LABEL-BGCOLOR`, `LABEL-DC`, `LABEL-DCO`, `LABEL-DCOL`, `LABEL-DCOLO`, `LABEL-DCOLOR`, `LABEL-FGC`, `LABEL-FGCO`, `LABEL-FGCOL`, `LABEL-FGCOLO`, `LABEL-FGCOLOR`, `LABEL-FONT`, `LABEL-PFC`, `LABEL-PFCO`, `LABEL-PFCOL`, `LABEL-PFCOLO`, `LABEL-PFCOLOR`, `LABELS`, `LABELS-HAVE-COLONS`, `LANDSCAPE`, `LANGUAGE`, `LANGUAGES`, `LARGE`, `LARGE-TO-SMALL`, `LAST`, `LAST-ASYNCH-REQUEST`, `LAST-BATCH`, `LAST-CHILD`, `LAST-EVEN`, `LAST-EVENT`, `LAST-FORM`, `LAST-KEY`, `LAST-OBJECT`, `LAST-OF`, `LAST-PROCE`, `LAST-PROCED`, `LAST-PROCEDU`, `LAST-PROCEDUR`, `LAST-PROCEDURE`, `LAST-SERVER`, `LAST-TAB-I`, `LAST-TAB-IT`, `LAST-TAB-ITE`, `LAST-TAB-ITEM`, `LASTKEY`, `LC`, `LDBNAME`, `LE`, `LEAVE`, `LEFT-ALIGN`, `LEFT-ALIGNE`, `LEFT-ALIGNED`, `LEFT-TRIM`, `LENGTH`, `LIBRARY`, `LIKE`, `LIKE-SEQUENTIAL`, `LINE`, `LINE-COUNT`, `LINE-COUNTE`, `LINE-COUNTER`, `LIST-EVENTS`, `LIST-ITEM-PAIRS`, `LIST-ITEMS`, `LIST-PROPERTY-NAMES`, `LIST-QUERY-ATTRS`, `LIST-SET-ATTRS`, `LIST-WIDGETS`, `LISTI`, `LISTIN`, `LISTING`, `LITERAL-QUESTION`, `LITTLE-ENDIAN`, `LOAD`, `LOAD-DOMAINS`, `LOAD-ICON`, `LOAD-IMAGE`, `LOAD-IMAGE-DOWN`, `LOAD-IMAGE-INSENSITIVE`, `LOAD-IMAGE-UP`, `LOAD-MOUSE-P`, `LOAD-MOUSE-PO`, `LOAD-MOUSE-POI`, `LOAD-MOUSE-POIN`, `LOAD-MOUSE-POINT`, `LOAD-MOUSE-POINTE`, `LOAD-MOUSE-POINTER`, `LOAD-PICTURE`, `LOAD-SMALL-ICON`, `LOCAL-NAME`, `LOCAL-VERSION-INFO`, `LOCATOR-COLUMN-NUMBER`, `LOCATOR-LINE-NUMBER`, `LOCATOR-PUBLIC-ID`, `LOCATOR-SYSTEM-ID`, `LOCATOR-TYPE`, `LOCK-REGISTRATION`, `LOCKED`, `LOG`, `LOG-AUDIT-EVENT`, `LOG-MANAGER`, `LOGICAL`, `LOGIN-EXPIRATION-TIMESTAMP`, `LOGIN-HOST`, `LOGIN-STATE`, `LOGOUT`, `LONGCHAR`, `LOOKAHEAD`, `LOOKUP`, `LT`, `MACHINE-CLASS`, `MANDATORY`, `MANUAL-HIGHLIGHT`, `MAP`, `MARGIN-EXTRA`, `MARGIN-HEIGHT`, `MARGIN-HEIGHT-`, `MARGIN-HEIGHT-C`, `MARGIN-HEIGHT-CH`, `MARGIN-HEIGHT-CHA`, `MARGIN-HEIGHT-CHAR`, `MARGIN-HEIGHT-CHARS`, `MARGIN-HEIGHT-P`, `MARGIN-HEIGHT-PI`, `MARGIN-HEIGHT-PIX`, `MARGIN-HEIGHT-PIXE`, `MARGIN-HEIGHT-PIXEL`, `MARGIN-HEIGHT-PIXELS`, `MARGIN-WIDTH`, `MARGIN-WIDTH-`, `MARGIN-WIDTH-C`, `MARGIN-WIDTH-CH`, `MARGIN-WIDTH-CHA`, `MARGIN-WIDTH-CHAR`, `MARGIN-WIDTH-CHARS`, `MARGIN-WIDTH-P`, `MARGIN-WIDTH-PI`, `MARGIN-WIDTH-PIX`, `MARGIN-WIDTH-PIXE`, `MARGIN-WIDTH-PIXEL`, `MARGIN-WIDTH-PIXELS`, `MARK-NEW`, `MARK-ROW-STATE`, `MATCHES`, `MAX`, `MAX-BUTTON`, `MAX-CHARS`, `MAX-DATA-GUESS`, `MAX-HEIGHT`, `MAX-HEIGHT-C`, `MAX-HEIGHT-CH`, `MAX-HEIGHT-CHA`, `MAX-HEIGHT-CHAR`, `MAX-HEIGHT-CHARS`, `MAX-HEIGHT-P`, `MAX-HEIGHT-PI`, `MAX-HEIGHT-PIX`, `MAX-HEIGHT-PIXE`, `MAX-HEIGHT-PIXEL`, `MAX-HEIGHT-PIXELS`, `MAX-ROWS`, `MAX-SIZE`, `MAX-VAL`, `MAX-VALU`, `MAX-VALUE`, `MAX-WIDTH`, `MAX-WIDTH-`, `MAX-WIDTH-C`, `MAX-WIDTH-CH`, `MAX-WIDTH-CHA`, `MAX-WIDTH-CHAR`, `MAX-WIDTH-CHARS`, `MAX-WIDTH-P`, `MAX-WIDTH-PI`, `MAX-WIDTH-PIX`, `MAX-WIDTH-PIXE`, `MAX-WIDTH-PIXEL`, `MAX-WIDTH-PIXELS`, `MAXI`, `MAXIM`, `MAXIMIZE`, `MAXIMU`, `MAXIMUM`, `MAXIMUM-LEVEL`, `MD5-DIGEST`, `MEMBER`, `MEMPTR-TO-NODE-VALUE`, `MENU`, `MENU-BAR`, `MENU-ITEM`, `MENU-K`, `MENU-KE`, `MENU-KEY`, `MENU-M`, `MENU-MO`, `MENU-MOU`, `MENU-MOUS`, `MENU-MOUSE`, `MENUBAR`, `MERGE-BY-FIELD`, `MESSAGE`, `MESSAGE-AREA`, `MESSAGE-AREA-FONT`, `MESSAGE-LINES`, `METHOD`, `MIN`, `MIN-BUTTON`, `MIN-COLUMN-WIDTH-C`, `MIN-COLUMN-WIDTH-CH`, `MIN-COLUMN-WIDTH-CHA`, `MIN-COLUMN-WIDTH-CHAR`, `MIN-COLUMN-WIDTH-CHARS`, `MIN-COLUMN-WIDTH-P`, `MIN-COLUMN-WIDTH-PI`, `MIN-COLUMN-WIDTH-PIX`, `MIN-COLUMN-WIDTH-PIXE`, `MIN-COLUMN-WIDTH-PIXEL`, `MIN-COLUMN-WIDTH-PIXELS`, `MIN-HEIGHT`, `MIN-HEIGHT-`, `MIN-HEIGHT-C`, `MIN-HEIGHT-CH`, `MIN-HEIGHT-CHA`, `MIN-HEIGHT-CHAR`, `MIN-HEIGHT-CHARS`, `MIN-HEIGHT-P`, `MIN-HEIGHT-PI`, `MIN-HEIGHT-PIX`, `MIN-HEIGHT-PIXE`, `MIN-HEIGHT-PIXEL`, `MIN-HEIGHT-PIXELS`, `MIN-SIZE`, `MIN-VAL`, `MIN-VALU`, `MIN-VALUE`, `MIN-WIDTH`, `MIN-WIDTH-`, `MIN-WIDTH-C`, `MIN-WIDTH-CH`, `MIN-WIDTH-CHA`, `MIN-WIDTH-CHAR`, `MIN-WIDTH-CHARS`, `MIN-WIDTH-P`, `MIN-WIDTH-PI`, `MIN-WIDTH-PIX`, `MIN-WIDTH-PIXE`, `MIN-WIDTH-PIXEL`, `MIN-WIDTH-PIXELS`, `MINI`, `MINIM`, `MINIMU`, `MINIMUM`, `MOD`, `MODIFIED`, `MODU`, `MODUL`, `MODULO`, `MONTH`, `MOUSE`, `MOUSE-P`, `MOUSE-PO`, `MOUSE-POI`, `MOUSE-POIN`, `MOUSE-POINT`, `MOUSE-POINTE`, `MOUSE-POINTER`, `MOVABLE`, `MOVE-AFTER`, `MOVE-AFTER-`, `MOVE-AFTER-T`, `MOVE-AFTER-TA`, `MOVE-AFTER-TAB`, `MOVE-AFTER-TAB-`, `MOVE-AFTER-TAB-I`, `MOVE-AFTER-TAB-IT`, `MOVE-AFTER-TAB-ITE`, `MOVE-AFTER-TAB-ITEM`, `MOVE-BEFOR`, `MOVE-BEFORE`, `MOVE-BEFORE-`, `MOVE-BEFORE-T`, `MOVE-BEFORE-TA`, `MOVE-BEFORE-TAB`, `MOVE-BEFORE-TAB-`, `MOVE-BEFORE-TAB-I`, `MOVE-BEFORE-TAB-IT`, `MOVE-BEFORE-TAB-ITE`, `MOVE-BEFORE-TAB-ITEM`, `MOVE-COL`, `MOVE-COLU`, `MOVE-COLUM`, `MOVE-COLUMN`, `MOVE-TO-B`, `MOVE-TO-BO`, `MOVE-TO-BOT`, `MOVE-TO-BOTT`, `MOVE-TO-BOTTO`, `MOVE-TO-BOTTOM`, `MOVE-TO-EOF`, `MOVE-TO-T`, `MOVE-TO-TO`, `MOVE-TO-TOP`, `MPE`, `MTIME`, `MULTI-COMPILE`, `MULTIPLE`, `MULTIPLE-KEY`, `MULTITASKING-INTERVAL`, `MUST-EXIST`, `NAME`, `NAMESPACE-PREFIX`, `NAMESPACE-URI`, `NATIVE`, `NE`, `NEEDS-APPSERVER-PROMPT`, `NEEDS-PROMPT`, `NEW`, `NEW-INSTANCE`, `NEW-ROW`, `NEXT`, `NEXT-COLUMN`, `NEXT-PROMPT`, `NEXT-ROWID`, `NEXT-SIBLING`, `NEXT-TAB-I`, `NEXT-TAB-IT`, `NEXT-TAB-ITE`, `NEXT-TAB-ITEM`, `NEXT-VALUE`, `NO`, `NO-APPLY`, `NO-ARRAY-MESSAGE`, `NO-ASSIGN`, `NO-ATTR`, `NO-ATTR-`, `NO-ATTR-L`, `NO-ATTR-LI`, `NO-ATTR-LIS`, `NO-ATTR-LIST`, `NO-ATTR-S`, `NO-ATTR-SP`, `NO-ATTR-SPA`, `NO-ATTR-SPAC`, `NO-ATTR-SPACE`, `NO-AUTO-VALIDATE`, `NO-BIND-WHERE`, `NO-BOX`, `NO-CONSOLE`, `NO-CONVERT`, `NO-CONVERT-3D-COLORS`, `NO-CURRENT-VALUE`, `NO-DEBUG`, `NO-DRAG`, `NO-ECHO`, `NO-EMPTY-SPACE`, `NO-ERROR`, `NO-F`, `NO-FI`, `NO-FIL`, `NO-FILL`, `NO-FOCUS`, `NO-HELP`, `NO-HIDE`, `NO-INDEX-HINT`, `NO-INHERIT-BGC`, `NO-INHERIT-BGCO`, `NO-INHERIT-BGCOLOR`, `NO-INHERIT-FGC`, `NO-INHERIT-FGCO`, `NO-INHERIT-FGCOL`, `NO-INHERIT-FGCOLO`, `NO-INHERIT-FGCOLOR`, `NO-JOIN-BY-SQLDB`, `NO-LABE`, `NO-LABELS`, `NO-LOBS`, `NO-LOCK`, `NO-LOOKAHEAD`, `NO-MAP`, `NO-MES`, `NO-MESS`, `NO-MESSA`, `NO-MESSAG`, `NO-MESSAGE`, `NO-PAUSE`, `NO-PREFE`, `NO-PREFET`, `NO-PREFETC`, `NO-PREFETCH`, `NO-ROW-MARKERS`, `NO-SCROLLBAR-VERTICAL`, `NO-SEPARATE-CONNECTION`, `NO-SEPARATORS`, `NO-TAB-STOP`, `NO-UND`, `NO-UNDE`, `NO-UNDER`, `NO-UNDERL`, `NO-UNDERLI`, `NO-UNDERLIN`, `NO-UNDERLINE`, `NO-UNDO`, `NO-VAL`, `NO-VALI`, `NO-VALID`, `NO-VALIDA`, `NO-VALIDAT`, `NO-VALIDATE`, `NO-WAIT`, `NO-WORD-WRAP`, `NODE-VALUE-TO-MEMPTR`, `NONAMESPACE-SCHEMA-LOCATION`, `NONE`, `NORMALIZE`, `NOT`, `NOT-ACTIVE`, `NOW`, `NULL`, `NUM-ALI`, `NUM-ALIA`, `NUM-ALIAS`, `NUM-ALIASE`, `NUM-ALIASES`, `NUM-BUFFERS`, `NUM-BUT`, `NUM-BUTT`, `NUM-BUTTO`, `NUM-BUTTON`, `NUM-BUTTONS`, `NUM-COL`, `NUM-COLU`, `NUM-COLUM`, `NUM-COLUMN`, `NUM-COLUMNS`, `NUM-COPIES`, `NUM-DBS`, `NUM-DROPPED-FILES`, `NUM-ENTRIES`, `NUM-FIELDS`, `NUM-FORMATS`, `NUM-ITEMS`, `NUM-ITERATIONS`, `NUM-LINES`, `NUM-LOCKED-COL`, `NUM-LOCKED-COLU`, `NUM-LOCKED-COLUM`, `NUM-LOCKED-COLUMN`, `NUM-LOCKED-COLUMNS`, `NUM-MESSAGES`, `NUM-PARAMETERS`, `NUM-REFERENCES`, `NUM-REPLACED`, `NUM-RESULTS`, `NUM-SELECTED`, `NUM-SELECTED-`, `NUM-SELECTED-ROWS`, `NUM-SELECTED-W`, `NUM-SELECTED-WI`, `NUM-SELECTED-WID`, `NUM-SELECTED-WIDG`, `NUM-SELECTED-WIDGE`, `NUM-SELECTED-WIDGET`, `NUM-SELECTED-WIDGETS`, `NUM-TABS`, `NUM-TO-RETAIN`, `NUM-VISIBLE-COLUMNS`, `NUMERIC`, `NUMERIC-F`, `NUMERIC-FO`, `NUMERIC-FOR`, `NUMERIC-FORM`, `NUMERIC-FORMA`, `NUMERIC-FORMAT`, `OCTET-LENGTH`, `OF`, `OFF`, `OK`, `OK-CANCEL`, `OLD`, `ON`, `ON-FRAME`, `ON-FRAME-`, `ON-FRAME-B`, `ON-FRAME-BO`, `ON-FRAME-BOR`, `ON-FRAME-BORD`, `ON-FRAME-BORDE`, `ON-FRAME-BORDER`, `OPEN`, `OPSYS`, `OPTION`, `OR`, `ORDERED-JOIN`, `ORDINAL`, `OS-APPEND`, `OS-COMMAND`, `OS-COPY`, `OS-CREATE-DIR`, `OS-DELETE`, `OS-DIR`, `OS-DRIVE`, `OS-DRIVES`, `OS-ERROR`, `OS-GETENV`, `OS-RENAME`, `OTHERWISE`, `OUTPUT`, `OVERLAY`, `OVERRIDE`, `OWNER`, `PAGE`, `PAGE-BOT`, `PAGE-BOTT`, `PAGE-BOTTO`, `PAGE-BOTTOM`, `PAGE-NUM`, `PAGE-NUMB`, `PAGE-NUMBE`, `PAGE-NUMBER`, `PAGE-SIZE`, `PAGE-TOP`, `PAGE-WID`, `PAGE-WIDT`, `PAGE-WIDTH`, `PAGED`, `PARAM`, `PARAME`, `PARAMET`, `PARAMETE`, `PARAMETER`, `PARENT`, `PARSE-STATUS`, `PARTIAL-KEY`, `PASCAL`, `PASSWORD-FIELD`, `PATHNAME`, `PAUSE`, `PBE-HASH-ALG`, `PBE-HASH-ALGO`, `PBE-HASH-ALGOR`, `PBE-HASH-ALGORI`, `PBE-HASH-ALGORIT`, `PBE-HASH-ALGORITH`, `PBE-HASH-ALGORITHM`, `PBE-KEY-ROUNDS`, `PDBNAME`, `PERSIST`, `PERSISTE`, `PERSISTEN`, `PERSISTENT`, `PERSISTENT-CACHE-DISABLED`, `PFC`, `PFCO`, `PFCOL`, `PFCOLO`, `PFCOLOR`, `PIXELS`, `PIXELS-PER-COL`, `PIXELS-PER-COLU`, `PIXELS-PER-COLUM`, `PIXELS-PER-COLUMN`, `PIXELS-PER-ROW`, `POPUP-M`, `POPUP-ME`, `POPUP-MEN`, `POPUP-MENU`, `POPUP-O`, `POPUP-ON`, `POPUP-ONL`, `POPUP-ONLY`, `PORTRAIT`, `POSITION`, `PRECISION`, `PREFER-DATASET`, `PREPARE-STRING`, `PREPARED`, `PREPROC`, `PREPROCE`, `PREPROCES`, `PREPROCESS`, `PRESEL`, `PRESELE`, `PRESELEC`, `PRESELECT`, `PREV`, `PREV-COLUMN`, `PREV-SIBLING`, `PREV-TAB-I`, `PREV-TAB-IT`, `PREV-TAB-ITE`, `PREV-TAB-ITEM`, `PRIMARY`, `PRINTER`, `PRINTER-CONTROL-HANDLE`, `PRINTER-HDC`, `PRINTER-NAME`, `PRINTER-PORT`, `PRINTER-SETUP`, `PRIVATE`, `PRIVATE-D`, `PRIVATE-DA`, `PRIVATE-DAT`, `PRIVATE-DATA`, `PRIVILEGES`, `PROC-HA`, `PROC-HAN`, `PROC-HAND`, `PROC-HANDL`, `PROC-HANDLE`, `PROC-ST`, `PROC-STA`, `PROC-STAT`, `PROC-STATU`, `PROC-STATUS`, `PROC-TEXT`, `PROC-TEXT-BUFFER`, `PROCE`, `PROCED`, `PROCEDU`, `PROCEDUR`, `PROCEDURE`, `PROCEDURE-CALL-TYPE`, `PROCEDURE-TYPE`, `PROCESS`, `PROFILER`, `PROGRAM-NAME`, `PROGRESS`, `PROGRESS-S`, `PROGRESS-SO`, `PROGRESS-SOU`, `PROGRESS-SOUR`, `PROGRESS-SOURC`, `PROGRESS-SOURCE`, `PROMPT`, `PROMPT-F`, `PROMPT-FO`, `PROMPT-FOR`, `PROMSGS`, `PROPATH`, `PROPERTY`, `PROTECTED`, `PROVERS`, `PROVERSI`, `PROVERSIO`, `PROVERSION`, `PROXY`, `PROXY-PASSWORD`, `PROXY-USERID`, `PUBLIC`, `PUBLIC-ID`, `PUBLISH`, `PUBLISHED-EVENTS`, `PUT`, `PUT-BYTE`, `PUT-DOUBLE`, `PUT-FLOAT`, `PUT-INT64`, `PUT-KEY-VAL`, `PUT-KEY-VALU`, `PUT-KEY-VALUE`, `PUT-LONG`, `PUT-SHORT`, `PUT-STRING`, `PUT-UNSIGNED-LONG`, `PUTBYTE`, `QUERY`, `QUERY-CLOSE`, `QUERY-OFF-END`, `QUERY-OPEN`, `QUERY-PREPARE`, `QUERY-TUNING`, `QUESTION`, `QUIT`, `QUOTER`, `R-INDEX`, `RADIO-BUTTONS`, `RADIO-SET`, `RANDOM`, `RAW`, `RAW-TRANSFER`, `RCODE-INFO`, `RCODE-INFOR`, `RCODE-INFORM`, `RCODE-INFORMA`, `RCODE-INFORMAT`, `RCODE-INFORMATI`, `RCODE-INFORMATIO`, `RCODE-INFORMATION`, `READ-AVAILABLE`, `READ-EXACT-NUM`, `READ-FILE`, `READ-JSON`, `READ-ONLY`, `READ-XML`, `READ-XMLSCHEMA`, `READKEY`, `REAL`, `RECID`, `RECORD-LENGTH`, `RECT`, `RECTA`, `RECTAN`, `RECTANG`, `RECTANGL`, `RECTANGLE`, `RECURSIVE`, `REFERENCE-ONLY`, `REFRESH`, `REFRESH-AUDIT-POLICY`, `REFRESHABLE`, `REGISTER-DOMAIN`, `RELEASE`, `REMOTE`, `REMOVE-EVENTS-PROCEDURE`, `REMOVE-SUPER-PROCEDURE`, `REPEAT`, `REPLACE`, `REPLACE-SELECTION-TEXT`, `REPOSITION`, `REPOSITION-BACKWARD`, `REPOSITION-FORWARD`, `REPOSITION-MODE`, `REPOSITION-TO-ROW`, `REPOSITION-TO-ROWID`, `REQUEST`, `REQUEST-INFO`, `RESET`, `RESIZA`, `RESIZAB`, `RESIZABL`, `RESIZABLE`, `RESIZE`, `RESPONSE-INFO`, `RESTART-ROW`, `RESTART-ROWID`, `RETAIN`, `RETAIN-SHAPE`, `RETRY`, `RETRY-CANCEL`, `RETURN`, `RETURN-ALIGN`, `RETURN-ALIGNE`, `RETURN-INS`, `RETURN-INSE`, `RETURN-INSER`, `RETURN-INSERT`, `RETURN-INSERTE`, `RETURN-INSERTED`, `RETURN-TO-START-DI`, `RETURN-TO-START-DIR`, `RETURN-VAL`, `RETURN-VALU`, `RETURN-VALUE`, `RETURN-VALUE-DATA-TYPE`, `RETURNS`, `REVERSE-FROM`, `REVERT`, `REVOKE`, `RGB-VALUE`, `RIGHT-ALIGNED`, `RIGHT-TRIM`, `ROLES`, `ROUND`, `ROUTINE-LEVEL`, `ROW`, `ROW-HEIGHT-CHARS`, `ROW-HEIGHT-PIXELS`, `ROW-MARKERS`, `ROW-OF`, `ROW-RESIZABLE`, `ROWID`, `RULE`, `RUN`, `RUN-PROCEDURE`, `SAVE CACHE`, `SAVE`, `SAVE-AS`, `SAVE-FILE`, `SAX-COMPLE`, `SAX-COMPLET`, `SAX-COMPLETE`, `SAX-PARSE`, `SAX-PARSE-FIRST`, `SAX-PARSE-NEXT`, `SAX-PARSER-ERROR`, `SAX-RUNNING`, `SAX-UNINITIALIZED`, `SAX-WRITE-BEGIN`, `SAX-WRITE-COMPLETE`, `SAX-WRITE-CONTENT`, `SAX-WRITE-ELEMENT`, `SAX-WRITE-ERROR`, `SAX-WRITE-IDLE`, `SAX-WRITE-TAG`, `SAX-WRITER`, `SCHEMA`, `SCHEMA-LOCATION`, `SCHEMA-MARSHAL`, `SCHEMA-PATH`, `SCREEN`, `SCREEN-IO`, `SCREEN-LINES`, `SCREEN-VAL`, `SCREEN-VALU`, `SCREEN-VALUE`, `SCROLL`, `SCROLL-BARS`, `SCROLL-DELTA`, `SCROLL-OFFSET`, `SCROLL-TO-CURRENT-ROW`, `SCROLL-TO-I`, `SCROLL-TO-IT`, `SCROLL-TO-ITE`, `SCROLL-TO-ITEM`, `SCROLL-TO-SELECTED-ROW`, `SCROLLABLE`, `SCROLLBAR-H`, `SCROLLBAR-HO`, `SCROLLBAR-HOR`, `SCROLLBAR-HORI`, `SCROLLBAR-HORIZ`, `SCROLLBAR-HORIZO`, `SCROLLBAR-HORIZON`, `SCROLLBAR-HORIZONT`, `SCROLLBAR-HORIZONTA`, `SCROLLBAR-HORIZONTAL`, `SCROLLBAR-V`, `SCROLLBAR-VE`, `SCROLLBAR-VER`, `SCROLLBAR-VERT`, `SCROLLBAR-VERTI`, `SCROLLBAR-VERTIC`, `SCROLLBAR-VERTICA`, `SCROLLBAR-VERTICAL`, `SCROLLED-ROW-POS`, `SCROLLED-ROW-POSI`, `SCROLLED-ROW-POSIT`, `SCROLLED-ROW-POSITI`, `SCROLLED-ROW-POSITIO`, `SCROLLED-ROW-POSITION`, `SCROLLING`, `SDBNAME`, `SEAL`, `SEAL-TIMESTAMP`, `SEARCH`, `SEARCH-SELF`, `SEARCH-TARGET`, `SECTION`, `SECURITY-POLICY`, `SEEK`, `SELECT`, `SELECT-ALL`, `SELECT-FOCUSED-ROW`, `SELECT-NEXT-ROW`, `SELECT-PREV-ROW`, `SELECT-ROW`, `SELECTABLE`, `SELECTED`, `SELECTION`, `SELECTION-END`, `SELECTION-LIST`, `SELECTION-START`, `SELECTION-TEXT`, `SELF`, `SEND`, `SEND-SQL-STATEMENT`, `SENSITIVE`, `SEPARATE-CONNECTION`, `SEPARATOR-FGCOLOR`, `SEPARATORS`, `SERIALIZABLE`, `SERIALIZE-HIDDEN`, `SERIALIZE-NAME`, `SERVER`, `SERVER-CONNECTION-BOUND`, `SERVER-CONNECTION-BOUND-REQUEST`, `SERVER-CONNECTION-CONTEXT`, `SERVER-CONNECTION-ID`, `SERVER-OPERATING-MODE`, `SESSION`, `SESSION-ID`, `SET`, `SET-APPL-CONTEXT`, `SET-ATTR-CALL-TYPE`, `SET-ATTRIBUTE-NODE`, `SET-BLUE`, `SET-BLUE-`, `SET-BLUE-V`, `SET-BLUE-VA`, `SET-BLUE-VAL`, `SET-BLUE-VALU`, `SET-BLUE-VALUE`, `SET-BREAK`, `SET-BUFFERS`, `SET-CALLBACK`, `SET-CLIENT`, `SET-COMMIT`, `SET-CONTENTS`, `SET-CURRENT-VALUE`, `SET-DB-CLIENT`, `SET-DYNAMIC`, `SET-EVENT-MANAGER-OPTION`, `SET-GREEN`, `SET-GREEN-`, `SET-GREEN-V`, `SET-GREEN-VA`, `SET-GREEN-VAL`, `SET-GREEN-VALU`, `SET-GREEN-VALUE`, `SET-INPUT-SOURCE`, `SET-OPTION`, `SET-OUTPUT-DESTINATION`, `SET-PARAMETER`, `SET-POINTER-VALUE`, `SET-PROPERTY`, `SET-RED`, `SET-RED-`, `SET-RED-V`, `SET-RED-VA`, `SET-RED-VAL`, `SET-RED-VALU`, `SET-RED-VALUE`, `SET-REPOSITIONED-ROW`, `SET-RGB-VALUE`, `SET-ROLLBACK`, `SET-SELECTION`, `SET-SIZE`, `SET-SORT-ARROW`, `SET-WAIT-STATE`, `SETUSER`, `SETUSERI`, `SETUSERID`, `SHA1-DIGEST`, `SHARE`, `SHARE-`, `SHARE-L`, `SHARE-LO`, `SHARE-LOC`, `SHARE-LOCK`, `SHARED`, `SHOW-IN-TASKBAR`, `SHOW-STAT`, `SHOW-STATS`, `SIDE-LAB`, `SIDE-LABE`, `SIDE-LABEL`, `SIDE-LABEL-H`, `SIDE-LABEL-HA`, `SIDE-LABEL-HAN`, `SIDE-LABEL-HAND`, `SIDE-LABEL-HANDL`, `SIDE-LABEL-HANDLE`, `SIDE-LABELS`, `SIGNATURE`, `SILENT`, `SIMPLE`, `SINGLE`, `SINGLE-RUN`, `SINGLETON`, `SIZE`, `SIZE-C`, `SIZE-CH`, `SIZE-CHA`, `SIZE-CHAR`, `SIZE-CHARS`, `SIZE-P`, `SIZE-PI`, `SIZE-PIX`, `SIZE-PIXE`, `SIZE-PIXEL`, `SIZE-PIXELS`, `SKIP`, `SKIP-DELETED-RECORD`, `SLIDER`, `SMALL-ICON`, `SMALL-TITLE`, `SMALLINT`, `SOME`, `SORT`, `SORT-ASCENDING`, `SORT-NUMBER`, `SOURCE`, `SOURCE-PROCEDURE`, `SPACE`, `SQL`, `SQRT`, `SSL-SERVER-NAME`, `STANDALONE`, `START`, `START-DOCUMENT`, `START-ELEMENT`, `START-MOVE`, `START-RESIZE`, `START-ROW-RESIZE`, `STATE-DETAIL`, `STATIC`, `STATUS`, `STATUS-AREA`, `STATUS-AREA-FONT`, `STDCALL`, `STOP`, `STOP-AFTER`, `STOP-PARSING`, `STOPPE`, `STOPPED`, `STORED-PROC`, `STORED-PROCE`, `STORED-PROCED`, `STORED-PROCEDU`, `STORED-PROCEDUR`, `STORED-PROCEDURE`, `STREAM`, `STREAM-HANDLE`, `STREAM-IO`, `STRETCH-TO-FIT`, `STRICT`, `STRICT-ENTITY-RESOLUTION`, `STRING`, `STRING-VALUE`, `STRING-XREF`, `SUB-AVE`, `SUB-AVER`, `SUB-AVERA`, `SUB-AVERAG`, `SUB-AVERAGE`, `SUB-COUNT`, `SUB-MAXIMUM`, `SUB-MENU`, `SUB-MIN`, `SUB-MINIMUM`, `SUB-TOTAL`, `SUBSCRIBE`, `SUBST`, `SUBSTI`, `SUBSTIT`, `SUBSTITU`, `SUBSTITUT`, `SUBSTITUTE`, `SUBSTR`, `SUBSTRI`, `SUBSTRIN`, `SUBSTRING`, `SUBTYPE`, `SUM`, `SUM-MAX`, `SUM-MAXI`, `SUM-MAXIM`, `SUM-MAXIMU`, `SUPER`, `SUPER-PROCEDURES`, `SUPPRESS-NAMESPACE-PROCESSING`, `SUPPRESS-W`, `SUPPRESS-WA`, `SUPPRESS-WAR`, `SUPPRESS-WARN`, `SUPPRESS-WARNI`, `SUPPRESS-WARNIN`, `SUPPRESS-WARNING`, `SUPPRESS-WARNINGS`, `SYMMETRIC-ENCRYPTION-ALGORITHM`, `SYMMETRIC-ENCRYPTION-IV`, `SYMMETRIC-ENCRYPTION-KEY`, `SYMMETRIC-SUPPORT`, `SYSTEM-ALERT`, `SYSTEM-ALERT-`, `SYSTEM-ALERT-B`, `SYSTEM-ALERT-BO`, `SYSTEM-ALERT-BOX`, `SYSTEM-ALERT-BOXE`, `SYSTEM-ALERT-BOXES`, `SYSTEM-DIALOG`, `SYSTEM-HELP`, `SYSTEM-ID`, `TAB-POSITION`, `TAB-STOP`, `TABLE`, `TABLE-HANDLE`, `TABLE-NUMBER`, `TABLE-SCAN`, `TARGET`, `TARGET-PROCEDURE`, `TEMP-DIR`, `TEMP-DIRE`, `TEMP-DIREC`, `TEMP-DIRECT`, `TEMP-DIRECTO`, `TEMP-DIRECTOR`, `TEMP-DIRECTORY`, `TEMP-TABLE`, `TEMP-TABLE-PREPARE`, `TERM`, `TERMI`, `TERMIN`, `TERMINA`, `TERMINAL`, `TERMINATE`, `TEXT`, `TEXT-CURSOR`, `TEXT-SEG-GROW`, `TEXT-SELECTED`, `THEN`, `THIS-OBJECT`, `THIS-PROCEDURE`, `THREAD-SAFE`, `THREE-D`, `THROUGH`, `THROW`, `THRU`, `TIC-MARKS`, `TIME`, `TIME-SOURCE`, `TITLE`, `TITLE-BGC`, `TITLE-BGCO`, `TITLE-BGCOL`, `TITLE-BGCOLO`, `TITLE-BGCOLOR`, `TITLE-DC`, `TITLE-DCO`, `TITLE-DCOL`, `TITLE-DCOLO`, `TITLE-DCOLOR`, `TITLE-FGC`, `TITLE-FGCO`, `TITLE-FGCOL`, `TITLE-FGCOLO`, `TITLE-FGCOLOR`, `TITLE-FO`, `TITLE-FON`, `TITLE-FONT`, `TO`, `TO-ROWID`, `TODAY`, `TOGGLE-BOX`, `TOOLTIP`, `TOOLTIPS`, `TOP-NAV-QUERY`, `TOP-ONLY`, `TOPIC`, `TOTAL`, `TRAILING`, `TRANS`, `TRANS-INIT-PROCEDURE`, `TRANSACTION`, `TRANSACTION-MODE`, `TRANSPARENT`, `TRIGGER`, `TRIGGERS`, `TRIM`, `TRUE`, `TRUNC`, `TRUNCA`, `TRUNCAT`, `TRUNCATE`, `TYPE`, `TYPE-OF`, `UNBOX`, `UNBUFF`, `UNBUFFE`, `UNBUFFER`, `UNBUFFERE`, `UNBUFFERED`, `UNDERL`, `UNDERLI`, `UNDERLIN`, `UNDERLINE`, `UNDO`, `UNFORM`, `UNFORMA`, `UNFORMAT`, `UNFORMATT`, `UNFORMATTE`, `UNFORMATTED`, `UNION`, `UNIQUE`, `UNIQUE-ID`, `UNIQUE-MATCH`, `UNIX`, `UNLESS-HIDDEN`, `UNLOAD`, `UNSIGNED-LONG`, `UNSUBSCRIBE`, `UP`, `UPDATE`, `UPDATE-ATTRIBUTE`, `URL`, `URL-DECODE`, `URL-ENCODE`, `URL-PASSWORD`, `URL-USERID`, `USE`, `USE-DICT-EXPS`, `USE-FILENAME`, `USE-INDEX`, `USE-REVVIDEO`, `USE-TEXT`, `USE-UNDERLINE`, `USE-WIDGET-POOL`, `USER`, `USER-ID`, `USERID`, `USING`, `V6DISPLAY`, `V6FRAME`, `VALID-EVENT`, `VALID-HANDLE`, `VALID-OBJECT`, `VALIDATE`, `VALIDATE-EXPRESSION`, `VALIDATE-MESSAGE`, `VALIDATE-SEAL`, `VALIDATION-ENABLED`, `VALUE`, `VALUE-CHANGED`, `VALUES`, `VAR`, `VARI`, `VARIA`, `VARIAB`, `VARIABL`, `VARIABLE`, `VERBOSE`, `VERSION`, `VERT`, `VERTI`, `VERTIC`, `VERTICA`, `VERTICAL`, `VIEW`, `VIEW-AS`, `VIEW-FIRST-COLUMN-ON-REOPEN`, `VIRTUAL-HEIGHT`, `VIRTUAL-HEIGHT-`, `VIRTUAL-HEIGHT-C`, `VIRTUAL-HEIGHT-CH`, `VIRTUAL-HEIGHT-CHA`, `VIRTUAL-HEIGHT-CHAR`, `VIRTUAL-HEIGHT-CHARS`, `VIRTUAL-HEIGHT-P`, `VIRTUAL-HEIGHT-PI`, `VIRTUAL-HEIGHT-PIX`, `VIRTUAL-HEIGHT-PIXE`, `VIRTUAL-HEIGHT-PIXEL`, `VIRTUAL-HEIGHT-PIXELS`, `VIRTUAL-WIDTH`, `VIRTUAL-WIDTH-`, `VIRTUAL-WIDTH-C`, `VIRTUAL-WIDTH-CH`, `VIRTUAL-WIDTH-CHA`, `VIRTUAL-WIDTH-CHAR`, `VIRTUAL-WIDTH-CHARS`, `VIRTUAL-WIDTH-P`, `VIRTUAL-WIDTH-PI`, `VIRTUAL-WIDTH-PIX`, `VIRTUAL-WIDTH-PIXE`, `VIRTUAL-WIDTH-PIXEL`, `VIRTUAL-WIDTH-PIXELS`, `VISIBLE`, `VOID`, `WAIT`, `WAIT-FOR`, `WARNING`, `WEB-CONTEXT`, `WEEKDAY`, `WHEN`, `WHERE`, `WHILE`, `WIDGET`, `WIDGET-E`, `WIDGET-EN`, `WIDGET-ENT`, `WIDGET-ENTE`, `WIDGET-ENTER`, `WIDGET-ID`, `WIDGET-L`, `WIDGET-LE`, `WIDGET-LEA`, `WIDGET-LEAV`, `WIDGET-LEAVE`, `WIDGET-POOL`, `WIDTH`, `WIDTH-`, `WIDTH-C`, `WIDTH-CH`, `WIDTH-CHA`, `WIDTH-CHAR`, `WIDTH-CHARS`, `WIDTH-P`, `WIDTH-PI`, `WIDTH-PIX`, `WIDTH-PIXE`, `WIDTH-PIXEL`, `WIDTH-PIXELS`, `WINDOW`, `WINDOW-MAXIM`, `WINDOW-MAXIMI`, `WINDOW-MAXIMIZ`, `WINDOW-MAXIMIZE`, `WINDOW-MAXIMIZED`, `WINDOW-MINIM`, `WINDOW-MINIMI`, `WINDOW-MINIMIZ`, `WINDOW-MINIMIZE`, `WINDOW-MINIMIZED`, `WINDOW-NAME`, `WINDOW-NORMAL`, `WINDOW-STA`, `WINDOW-STAT`, `WINDOW-STATE`, `WINDOW-SYSTEM`, `WITH`, `WORD-INDEX`, `WORD-WRAP`, `WORK-AREA-HEIGHT-PIXELS`, `WORK-AREA-WIDTH-PIXELS`, `WORK-AREA-X`, `WORK-AREA-Y`, `WORK-TAB`, `WORK-TABL`, `WORK-TABLE`, `WORKFILE`, `WRITE`, `WRITE-CDATA`, `WRITE-CHARACTERS`, `WRITE-COMMENT`, `WRITE-DATA-ELEMENT`, `WRITE-EMPTY-ELEMENT`, `WRITE-ENTITY-REF`, `WRITE-EXTERNAL-DTD`, `WRITE-FRAGMENT`, `WRITE-JSON`, `WRITE-MESSAGE`, `WRITE-PROCESSING-INSTRUCTION`, `WRITE-STATUS`, `WRITE-XML`, `WRITE-XMLSCHEMA`, `X`, `X-OF`, `XCODE`, `XML-DATA-TYPE`, `XML-ENTITY-EXPANSION-LIMIT`, `XML-NODE-TYPE`, `XML-SCHEMA-PATH`, `XML-STRICT-ENTITY-RESOLUTION`, `XML-SUPPRESS-NAMESPACE-PROCESSING`, `XREF`, `XREF-XML`, `Y`, `Y-OF`, `YEAR`, `YEAR-OFFSET`, `YES`, `YES-NO`, `YES-NO-CANCEL`), KeywordReserved, nil}, // nolint + {`"(\\\\|\\[^\\]|[^"\\])*"`, LiteralStringDouble, nil}, + {`'(\\\\|\\[^\\]|[^'\\])*'`, LiteralStringSingle, nil}, + {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, + {`[0-9]+`, LiteralNumberInteger, nil}, + {`\s+`, Text, nil}, + {`[+*/=-]`, Operator, nil}, + {`[.:()]`, Punctuation, nil}, + {`.`, NameVariable, nil}, + }, + "comment": { + {`[^*/]`, CommentMultiline, nil}, + {`/\*`, CommentMultiline, Push()}, + {`\*/`, CommentMultiline, Pop(1)}, + {`[*/]`, CommentMultiline, nil}, + {`\/\/`, CommentSingle, nil}, + }, + "preprocessor": { + {`[^{}]`, CommentPreproc, nil}, + {`\{`, CommentPreproc, Push()}, + {`\}`, CommentPreproc, Pop(1)}, + }, + } + }, +)) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/org.go b/vendor/github.com/alecthomas/chroma/v2/lexers/org.go new file mode 100644 index 0000000..aed663f --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/org.go @@ -0,0 +1,99 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Org mode lexer. +var Org = Register(MustNewLexer( + &Config{ + Name: "Org Mode", + Aliases: []string{"org", "orgmode"}, + Filenames: []string{"*.org"}, + MimeTypes: []string{"text/org"}, // https://lists.gnu.org/r/emacs-orgmode/2017-09/msg00087.html + }, + orgRules, +)) + +func orgRules() Rules { + return Rules{ + "root": { + {`^# .*$`, Comment, nil}, + // Headings + {`^(\*)( COMMENT)( .*)$`, ByGroups(GenericHeading, NameEntity, GenericStrong), nil}, + {`^(\*\*+)( COMMENT)( .*)$`, ByGroups(GenericSubheading, NameEntity, Text), nil}, + {`^(\*)( DONE)( .*)$`, ByGroups(GenericHeading, LiteralStringRegex, GenericStrong), nil}, + {`^(\*\*+)( DONE)( .*)$`, ByGroups(GenericSubheading, LiteralStringRegex, Text), nil}, + {`^(\*)( TODO)( .*)$`, ByGroups(GenericHeading, Error, GenericStrong), nil}, + {`^(\*\*+)( TODO)( .*)$`, ByGroups(GenericSubheading, Error, Text), nil}, + {`^(\*)( .+?)( :[a-zA-Z0-9_@:]+:)$`, ByGroups(GenericHeading, GenericStrong, GenericEmph), nil}, // Level 1 heading with tags + {`^(\*)( .+)$`, ByGroups(GenericHeading, GenericStrong), nil}, // // Level 1 heading with NO tags + {`^(\*\*+)( .+?)( :[a-zA-Z0-9_@:]+:)$`, ByGroups(GenericSubheading, Text, GenericEmph), nil}, // Level 2+ heading with tags + {`^(\*\*+)( .+)$`, ByGroups(GenericSubheading, Text), nil}, // Level 2+ heading with NO tags + // Checkbox lists + {`^( *)([+-] )(\[[ X]\])( .+)$`, ByGroups(Text, Keyword, Keyword, UsingSelf("inline")), nil}, + {`^( +)(\* )(\[[ X]\])( .+)$`, ByGroups(Text, Keyword, Keyword, UsingSelf("inline")), nil}, + // Definition lists + {`^( *)([+-] )([^ \n]+ ::)( .+)$`, ByGroups(Text, Keyword, Keyword, UsingSelf("inline")), nil}, + {`^( +)(\* )([^ \n]+ ::)( .+)$`, ByGroups(Text, Keyword, Keyword, UsingSelf("inline")), nil}, + // Unordered lists + {`^( *)([+-] )(.+)$`, ByGroups(Text, Keyword, UsingSelf("inline")), nil}, + {`^( +)(\* )(.+)$`, ByGroups(Text, Keyword, UsingSelf("inline")), nil}, + // Ordered lists + {`^( *)([0-9]+[.)])( \[@[0-9]+\])( .+)$`, ByGroups(Text, Keyword, GenericEmph, UsingSelf("inline")), nil}, + {`^( *)([0-9]+[.)])( .+)$`, ByGroups(Text, Keyword, UsingSelf("inline")), nil}, + // Dynamic Blocks + {`(?i)^( *#\+begin: )([^ ]+)([\w\W]*?\n)([\w\W]*?)(^ *#\+end: *$)`, ByGroups(Comment, CommentSpecial, Comment, UsingSelf("inline"), Comment), nil}, + // Blocks + // - Comment Blocks + {`(?i)^( *#\+begin_comment *\n)([\w\W]*?)(^ *#\+end_comment *$)`, ByGroups(Comment, Comment, Comment), nil}, + // - Src Blocks + { + `(?i)^( *#\+begin_src )([^ \n]+)(.*?\n)([\w\W]*?)(^ *#\+end_src *$)`, + UsingByGroup(2, 4, Comment, CommentSpecial, Comment, Text, Comment), + nil, + }, + // - Export Blocks + { + `(?i)^( *#\+begin_export )(\w+)( *\n)([\w\W]*?)(^ *#\+end_export *$)`, + UsingByGroup(2, 4, Comment, CommentSpecial, Text, Text, Comment), + nil, + }, + // - Org Special, Example, Verse, etc. Blocks + {`(?i)^( *#\+begin_)(\w+)( *\n)([\w\W]*?)(^ *#\+end_\2)( *$)`, ByGroups(Comment, Comment, Text, Text, Comment, Text), nil}, + // Keywords + {`^(#\+\w+)(:.*)$`, ByGroups(CommentSpecial, Comment), nil}, // Other Org keywords like #+title + // Properties and Drawers + {`(?i)^( *:\w+: *\n)([\w\W]*?)(^ *:end: *$)`, ByGroups(Comment, CommentSpecial, Comment), nil}, + // Line break operator + {`^(.*)(\\\\)$`, ByGroups(UsingSelf("inline"), Operator), nil}, + // Deadline/Scheduled + {`(?i)^( *(?:DEADLINE|SCHEDULED): )(<[^<>]+?> *)$`, ByGroups(Comment, CommentSpecial), nil}, // DEADLINE/SCHEDULED: <datestamp> + // DONE state CLOSED + {`(?i)^( *CLOSED: )(\[[^][]+?\] *)$`, ByGroups(Comment, CommentSpecial), nil}, // CLOSED: [datestamp] + // All other lines + Include("inline"), + }, + "inline": { + {`(\s)*(\*[^ \n*][^*]+?[^ \n*]\*)((?=\W|\n|$))`, ByGroups(Text, GenericStrong, Text), nil}, // Bold + {`(\s)*(/[^/]+?/)((?=\W|\n|$))`, ByGroups(Text, GenericEmph, Text), nil}, // Italic + {`(\s)*(=[^\n=]+?=)((?=\W|\n|$))`, ByGroups(Text, NameClass, Text), nil}, // Verbatim + {`(\s)*(~[^\n~]+?~)((?=\W|\n|$))`, ByGroups(Text, NameClass, Text), nil}, // Code + {`(\s)*(\+[^+]+?\+)((?=\W|\n|$))`, ByGroups(Text, GenericDeleted, Text), nil}, // Strikethrough + {`(\s)*(_[^_]+?_)((?=\W|\n|$))`, ByGroups(Text, GenericUnderline, Text), nil}, // Underline + {`(<)([^<>]+?)(>)`, ByGroups(Text, String, Text), nil}, // <datestamp> + {`[{]{3}[^}]+[}]{3}`, NameBuiltin, nil}, // {{{macro(foo,1)}}} + {`([^[])(\[fn:)([^]]+?)(\])([^]])`, ByGroups(Text, NameBuiltinPseudo, LiteralString, NameBuiltinPseudo, Text), nil}, // [fn:1] + // Links + {`(\[\[)([^][]+?)(\]\[)([^][]+)(\]\])`, ByGroups(Text, NameAttribute, Text, NameTag, Text), nil}, // [[link][descr]] + {`(\[\[)([^][]+?)(\]\])`, ByGroups(Text, NameAttribute, Text), nil}, // [[link]] + {`(<<)([^<>]+?)(>>)`, ByGroups(Text, NameAttribute, Text), nil}, // <<targetlink>> + // Tables + {`^( *)(\|[ -].*?[ -]\|)$`, ByGroups(Text, String), nil}, + // Blank lines, newlines + {`\n`, Text, nil}, + // Any other text + {`.`, Text, nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/php.go b/vendor/github.com/alecthomas/chroma/v2/lexers/php.go new file mode 100644 index 0000000..ff82f6e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/php.go @@ -0,0 +1,37 @@ +package lexers + +import ( + "strings" + + . "github.com/alecthomas/chroma/v2" // nolint +) + +// phtml lexer is PHP in HTML. +var _ = Register(DelegatingLexer(HTML, MustNewLexer( + &Config{ + Name: "PHTML", + Aliases: []string{"phtml"}, + Filenames: []string{"*.phtml", "*.php", "*.php[345]", "*.inc"}, + MimeTypes: []string{"application/x-php", "application/x-httpd-php", "application/x-httpd-php3", "application/x-httpd-php4", "application/x-httpd-php5", "text/x-php"}, + DotAll: true, + CaseInsensitive: true, + EnsureNL: true, + Priority: 2, + }, + func() Rules { + return Get("PHP").(*RegexLexer).MustRules(). + Rename("root", "php"). + Merge(Rules{ + "root": { + {`<\?(php)?`, CommentPreproc, Push("php")}, + {`[^<]+`, Other, nil}, + {`<`, Other, nil}, + }, + }) + }, +).SetAnalyser(func(text string) float32 { + if strings.Contains(text, "<?php") { + return 0.5 + } + return 0.0 +}))) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/plaintext.go b/vendor/github.com/alecthomas/chroma/v2/lexers/plaintext.go new file mode 100644 index 0000000..8b32aa4 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/plaintext.go @@ -0,0 +1,16 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +var Plaintext = Register(MustNewLexer( + &Config{ + Name: "plaintext", + Aliases: []string{"text", "plain", "no-highlight"}, + Filenames: []string{"*.txt"}, + MimeTypes: []string{"text/plain"}, + Priority: -1, + }, + PlaintextRules, +)) diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/postgres.go b/vendor/github.com/alecthomas/chroma/v2/lexers/postgres.go new file mode 100644 index 0000000..0ef96ef --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/postgres.go @@ -0,0 +1,77 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Postgresql Sql Dialect lexer. +var PostgreSQL = Register(MustNewLexer( + &Config{ + Name: "PostgreSQL SQL dialect", + Aliases: []string{"postgresql", "postgres"}, + Filenames: []string{}, + MimeTypes: []string{"text/x-postgresql"}, + NotMultiline: true, + CaseInsensitive: true, + }, + postgreSQLRules, +)) + +func postgreSQLRules() Rules { + return Rules{ + "root": { + {`\s+`, Text, nil}, + {`--.*\n?`, CommentSingle, nil}, + {`/\*`, CommentMultiline, Push("multiline-comments")}, + {`(bigint|bigserial|bit|bit\s+varying|bool|boolean|box|bytea|char|character|character\s+varying|cidr|circle|date|decimal|double\s+precision|float4|float8|inet|int|int2|int4|int8|integer|interval|json|jsonb|line|lseg|macaddr|money|numeric|path|pg_lsn|point|polygon|real|serial|serial2|serial4|serial8|smallint|smallserial|text|time|timestamp|timestamptz|timetz|tsquery|tsvector|txid_snapshot|uuid|varbit|varchar|with\s+time\s+zone|without\s+time\s+zone|xml|anyarray|anyelement|anyenum|anynonarray|anyrange|cstring|fdw_handler|internal|language_handler|opaque|record|void)\b`, NameBuiltin, nil}, + { + `(?s)(DO)(\s+)(?:(LANGUAGE)?(\s+)('?)(\w+)?('?)(\s+))?(\$)([^$]*)(\$)(.*?)(\$)(\10)(\$)`, + UsingByGroup(6, 12, + Keyword, Text, Keyword, Text, // DO LANGUAGE + StringSingle, StringSingle, StringSingle, Text, // 'plpgsql' + StringHeredoc, StringHeredoc, StringHeredoc, // $tag$ + StringHeredoc, // (code block) + StringHeredoc, StringHeredoc, StringHeredoc), // $tag$ + nil, + }, + {Words(``, `\b`, `ABORT`, `ABSOLUTE`, `ACCESS`, `ACTION`, `ADD`, `ADMIN`, `AFTER`, `AGGREGATE`, `ALL`, `ALSO`, `ALTER`, `ALWAYS`, `ANALYSE`, `ANALYZE`, `AND`, `ANY`, `ARRAY`, `AS`, `ASC`, `ASSERTION`, `ASSIGNMENT`, `ASYMMETRIC`, `AT`, `ATTRIBUTE`, `AUTHORIZATION`, `BACKWARD`, `BEFORE`, `BEGIN`, `BETWEEN`, `BIGINT`, `BINARY`, `BIT`, `BOOLEAN`, `BOTH`, `BY`, `CACHE`, `CALLED`, `CASCADE`, `CASCADED`, `CASE`, `CAST`, `CATALOG`, `CHAIN`, `CHAR`, `CHARACTER`, `CHARACTERISTICS`, `CHECK`, `CHECKPOINT`, `CLASS`, `CLOSE`, `CLUSTER`, `COALESCE`, `COLLATE`, `COLLATION`, `COLUMN`, `COMMENT`, `COMMENTS`, `COMMIT`, `COMMITTED`, `CONCURRENTLY`, `CONFIGURATION`, `CONNECTION`, `CONSTRAINT`, `CONSTRAINTS`, `CONTENT`, `CONTINUE`, `CONVERSION`, `COPY`, `COST`, `CREATE`, `CROSS`, `CSV`, `CURRENT`, `CURRENT_CATALOG`, `CURRENT_DATE`, `CURRENT_ROLE`, `CURRENT_SCHEMA`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `CURRENT_USER`, `CURSOR`, `CYCLE`, `DATA`, `DATABASE`, `DAY`, `DEALLOCATE`, `DEC`, `DECIMAL`, `DECLARE`, `DEFAULT`, `DEFAULTS`, `DEFERRABLE`, `DEFERRED`, `DEFINER`, `DELETE`, `DELIMITER`, `DELIMITERS`, `DESC`, `DICTIONARY`, `DISABLE`, `DISCARD`, `DISTINCT`, `DO`, `DOCUMENT`, `DOMAIN`, `DOUBLE`, `DROP`, `EACH`, `ELSE`, `ENABLE`, `ENCODING`, `ENCRYPTED`, `END`, `ENUM`, `ESCAPE`, `EVENT`, `EXCEPT`, `EXCLUDE`, `EXCLUDING`, `EXCLUSIVE`, `EXECUTE`, `EXISTS`, `EXPLAIN`, `EXTENSION`, `EXTERNAL`, `EXTRACT`, `FALSE`, `FAMILY`, `FETCH`, `FILTER`, `FIRST`, `FLOAT`, `FOLLOWING`, `FOR`, `FORCE`, `FOREIGN`, `FORWARD`, `FREEZE`, `FROM`, `FULL`, `FUNCTION`, `FUNCTIONS`, `GLOBAL`, `GRANT`, `GRANTED`, `GREATEST`, `GROUP`, `HANDLER`, `HAVING`, `HEADER`, `HOLD`, `HOUR`, `IDENTITY`, `IF`, `ILIKE`, `IMMEDIATE`, `IMMUTABLE`, `IMPLICIT`, `IN`, `INCLUDING`, `INCREMENT`, `INDEX`, `INDEXES`, `INHERIT`, `INHERITS`, `INITIALLY`, `INLINE`, `INNER`, `INOUT`, `INPUT`, `INSENSITIVE`, `INSERT`, `INSTEAD`, `INT`, `INTEGER`, `INTERSECT`, `INTERVAL`, `INTO`, `INVOKER`, `IS`, `ISNULL`, `ISOLATION`, `JOIN`, `KEY`, `LABEL`, `LANGUAGE`, `LARGE`, `LAST`, `LATERAL`, `LC_COLLATE`, `LC_CTYPE`, `LEADING`, `LEAKPROOF`, `LEAST`, `LEFT`, `LEVEL`, `LIKE`, `LIMIT`, `LISTEN`, `LOAD`, `LOCAL`, `LOCALTIME`, `LOCALTIMESTAMP`, `LOCATION`, `LOCK`, `MAPPING`, `MATCH`, `MATERIALIZED`, `MAXVALUE`, `MINUTE`, `MINVALUE`, `MODE`, `MONTH`, `MOVE`, `NAME`, `NAMES`, `NATIONAL`, `NATURAL`, `NCHAR`, `NEXT`, `NO`, `NONE`, `NOT`, `NOTHING`, `NOTIFY`, `NOTNULL`, `NOWAIT`, `NULL`, `NULLIF`, `NULLS`, `NUMERIC`, `OBJECT`, `OF`, `OFF`, `OFFSET`, `OIDS`, `ON`, `ONLY`, `OPERATOR`, `OPTION`, `OPTIONS`, `OR`, `ORDER`, `ORDINALITY`, `OUT`, `OUTER`, `OVER`, `OVERLAPS`, `OVERLAY`, `OWNED`, `OWNER`, `PARSER`, `PARTIAL`, `PARTITION`, `PASSING`, `PASSWORD`, `PLACING`, `PLANS`, `POLICY`, `POSITION`, `PRECEDING`, `PRECISION`, `PREPARE`, `PREPARED`, `PRESERVE`, `PRIMARY`, `PRIOR`, `PRIVILEGES`, `PROCEDURAL`, `PROCEDURE`, `PROGRAM`, `QUOTE`, `RANGE`, `READ`, `REAL`, `REASSIGN`, `RECHECK`, `RECURSIVE`, `REF`, `REFERENCES`, `REFRESH`, `REINDEX`, `RELATIVE`, `RELEASE`, `RENAME`, `REPEATABLE`, `REPLACE`, `REPLICA`, `RESET`, `RESTART`, `RESTRICT`, `RETURNING`, `RETURNS`, `REVOKE`, `RIGHT`, `ROLE`, `ROLLBACK`, `ROW`, `ROWS`, `RULE`, `SAVEPOINT`, `SCHEMA`, `SCROLL`, `SEARCH`, `SECOND`, `SECURITY`, `SELECT`, `SEQUENCE`, `SEQUENCES`, `SERIALIZABLE`, `SERVER`, `SESSION`, `SESSION_USER`, `SET`, `SETOF`, `SHARE`, `SHOW`, `SIMILAR`, `SIMPLE`, `SMALLINT`, `SNAPSHOT`, `SOME`, `STABLE`, `STANDALONE`, `START`, `STATEMENT`, `STATISTICS`, `STDIN`, `STDOUT`, `STORAGE`, `STRICT`, `STRIP`, `SUBSTRING`, `SYMMETRIC`, `SYSID`, `SYSTEM`, `TABLE`, `TABLES`, `TABLESPACE`, `TEMP`, `TEMPLATE`, `TEMPORARY`, `TEXT`, `THEN`, `TIME`, `TIMESTAMP`, `TO`, `TRAILING`, `TRANSACTION`, `TREAT`, `TRIGGER`, `TRIM`, `TRUE`, `TRUNCATE`, `TRUSTED`, `TYPE`, `TYPES`, `UNBOUNDED`, `UNCOMMITTED`, `UNENCRYPTED`, `UNION`, `UNIQUE`, `UNKNOWN`, `UNLISTEN`, `UNLOGGED`, `UNTIL`, `UPDATE`, `USER`, `USING`, `VACUUM`, `VALID`, `VALIDATE`, `VALIDATOR`, `VALUE`, `VALUES`, `VARCHAR`, `VARIADIC`, `VARYING`, `VERBOSE`, `VERSION`, `VIEW`, `VIEWS`, `VOLATILE`, `WHEN`, `WHERE`, `WHITESPACE`, `WINDOW`, `WITH`, `WITHIN`, `WITHOUT`, `WORK`, `WRAPPER`, `WRITE`, `XML`, `XMLATTRIBUTES`, `XMLCONCAT`, `XMLELEMENT`, `XMLEXISTS`, `XMLFOREST`, `XMLPARSE`, `XMLPI`, `XMLROOT`, `XMLSERIALIZE`, `YEAR`, `YES`, `ZONE`), Keyword, nil}, + {"[+*/<>=~!@#%^&|`?-]+", Operator, nil}, + {`::`, Operator, nil}, + {`\$\d+`, NameVariable, nil}, + {`([0-9]*\.[0-9]*|[0-9]+)(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, + {`[0-9]+`, LiteralNumberInteger, nil}, + {`((?:E|U&)?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("string")}, + {`((?:U&)?)(")`, ByGroups(LiteralStringAffix, LiteralStringName), Push("quoted-ident")}, + { + `(?s)(\$)([^$]*)(\$)(.*?)(\$)(\2)(\$)(\s+)(LANGUAGE)?(\s+)('?)(\w+)?('?)`, + UsingByGroup(12, 4, + StringHeredoc, StringHeredoc, StringHeredoc, // $tag$ + StringHeredoc, // (code block) + StringHeredoc, StringHeredoc, StringHeredoc, // $tag$ + Text, Keyword, Text, // <space> LANGUAGE <space> + StringSingle, StringSingle, StringSingle), // 'type' + nil, + }, + {`(?s)(\$)([^$]*)(\$)(.*?)(\$)(\2)(\$)`, LiteralStringHeredoc, nil}, + {`[a-z_]\w*`, Name, nil}, + {`:(['"]?)[a-z]\w*\b\1`, 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)}, + }, + "quoted-ident": { + {`[^"]+`, LiteralStringName, nil}, + {`""`, LiteralStringName, nil}, + {`"`, LiteralStringName, Pop(1)}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/raku.go b/vendor/github.com/alecthomas/chroma/v2/lexers/raku.go new file mode 100644 index 0000000..04aa206 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/raku.go @@ -0,0 +1,1721 @@ +package lexers + +import ( + "regexp" + "strings" + "unicode/utf8" + + "github.com/dlclark/regexp2" + + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Raku lexer. +var Raku Lexer = Register(MustNewLexer( + &Config{ + Name: "Raku", + Aliases: []string{"perl6", "pl6", "raku"}, + Filenames: []string{ + "*.pl", "*.pm", "*.nqp", "*.p6", "*.6pl", "*.p6l", "*.pl6", "*.6pm", + "*.p6m", "*.pm6", "*.t", "*.raku", "*.rakumod", "*.rakutest", "*.rakudoc", + }, + MimeTypes: []string{ + "text/x-perl6", "application/x-perl6", + "text/x-raku", "application/x-raku", + }, + DotAll: true, + }, + rakuRules, +)) + +func rakuRules() Rules { + type RakuToken int + + const ( + rakuQuote RakuToken = iota + rakuNameAttribute + rakuPod + rakuPodFormatter + rakuPodDeclaration + rakuMultilineComment + rakuMatchRegex + rakuSubstitutionRegex + ) + + const ( + colonPairOpeningBrackets = `(?:<<|<|«|\(|\[|\{)` + colonPairClosingBrackets = `(?:>>|>|»|\)|\]|\})` + colonPairPattern = `(?<!:)(?<colon>:)(?<key>\w[\w'-]*)(?<opening_delimiters>` + colonPairOpeningBrackets + `)` + colonPairLookahead = `(?=(:['\w-]+` + + colonPairOpeningBrackets + `.+?` + colonPairClosingBrackets + `)?` + namePattern = `(?:(?!` + colonPairPattern + `)(?:::|[\w':-]))+` + variablePattern = `[$@%&]+[.^:?=!~]?` + namePattern + globalVariablePattern = `[$@%&]+\*` + namePattern + ) + + keywords := []string{ + `BEGIN`, `CATCH`, `CHECK`, `CLOSE`, `CONTROL`, `DOC`, `END`, `ENTER`, `FIRST`, `INIT`, + `KEEP`, `LAST`, `LEAVE`, `NEXT`, `POST`, `PRE`, `QUIT`, `UNDO`, `anon`, `augment`, `but`, + `class`, `constant`, `default`, `does`, `else`, `elsif`, `enum`, `for`, `gather`, `given`, + `grammar`, `has`, `if`, `import`, `is`, `of`, `let`, `loop`, `made`, `make`, `method`, + `module`, `multi`, `my`, `need`, `orwith`, `our`, `proceed`, `proto`, `repeat`, `require`, + `where`, `return`, `return-rw`, `returns`, `->`, `-->`, `role`, `state`, `sub`, `no`, + `submethod`, `subset`, `succeed`, `supersede`, `try`, `unit`, `unless`, `until`, + `use`, `when`, `while`, `with`, `without`, `export`, `native`, `repr`, `required`, `rw`, + `symbol`, `default`, `cached`, `DEPRECATED`, `dynamic`, `hidden-from-backtrace`, `nodal`, + `pure`, `raw`, `start`, `react`, `supply`, `whenever`, `also`, `rule`, `token`, `regex`, + `dynamic-scope`, `built`, `temp`, + } + + keywordsPattern := Words(`(?<!['\w:-])`, `(?!['\w:-])`, keywords...) + + wordOperators := []string{ + `X`, `Z`, `R`, `after`, `and`, `andthen`, `before`, `cmp`, `div`, `eq`, `eqv`, `extra`, `ge`, + `gt`, `le`, `leg`, `lt`, `mod`, `ne`, `or`, `orelse`, `x`, `xor`, `xx`, `gcd`, `lcm`, + `but`, `min`, `max`, `^fff`, `fff^`, `fff`, `^ff`, `ff^`, `ff`, `so`, `not`, `unicmp`, + `TR`, `o`, `(&)`, `(.)`, `(|)`, `(+)`, `(-)`, `(^)`, `coll`, `(elem)`, `(==)`, + `(cont)`, `(<)`, `(<=)`, `(>)`, `(>=)`, `minmax`, `notandthen`, `S`, + } + + wordOperatorsPattern := Words(`(?<=^|\b|\s)`, `(?=$|\b|\s)`, wordOperators...) + + operators := []string{ + `++`, `--`, `-`, `**`, `!`, `+`, `~`, `?`, `+^`, `~^`, `?^`, `^`, `*`, `/`, `%`, `%%`, `+&`, + `+<`, `+>`, `~&`, `~<`, `~>`, `?&`, `+|`, `+^`, `~|`, `~^`, `?`, `?|`, `?^`, `&`, `^`, + `<=>`, `^…^`, `^…`, `…^`, `…`, `...`, `...^`, `^...`, `^...^`, `..`, `..^`, `^..`, `^..^`, + `::=`, `:=`, `!=`, `==`, `<=`, `<`, `>=`, `>`, `~~`, `===`, `&&`, `||`, `|`, `^^`, `//`, + `??`, `!!`, `^fff^`, `^ff^`, `<==`, `==>`, `<<==`, `==>>`, `=>`, `=`, `<<`, `«`, `>>`, `»`, + `,`, `>>.`, `».`, `.&`, `.=`, `.^`, `.?`, `.+`, `.*`, `.`, `∘`, `∩`, `⊍`, `∪`, `⊎`, `∖`, + `⊖`, `≠`, `≤`, `≥`, `=:=`, `=~=`, `≅`, `∈`, `∉`, `≡`, `≢`, `∋`, `∌`, `⊂`, `⊄`, `⊆`, `⊈`, + `⊃`, `⊅`, `⊇`, `⊉`, `:`, `!!!`, `???`, `¯`, `×`, `÷`, `−`, `⁺`, `⁻`, + } + + operatorsPattern := Words(``, ``, operators...) + + builtinTypes := []string{ + `False`, `True`, `Order`, `More`, `Less`, `Same`, `Any`, `Array`, `Associative`, `AST`, + `atomicint`, `Attribute`, `Backtrace`, `Backtrace::Frame`, `Bag`, `Baggy`, `BagHash`, + `Blob`, `Block`, `Bool`, `Buf`, `Callable`, `CallFrame`, `Cancellation`, `Capture`, + `CArray`, `Channel`, `Code`, `compiler`, `Complex`, `ComplexStr`, `CompUnit`, + `CompUnit::PrecompilationRepository`, `CompUnit::Repository`, `Empty`, + `CompUnit::Repository::FileSystem`, `CompUnit::Repository::Installation`, `Cool`, + `CurrentThreadScheduler`, `CX::Warn`, `CX::Take`, `CX::Succeed`, `CX::Return`, `CX::Redo`, + `CX::Proceed`, `CX::Next`, `CX::Last`, `CX::Emit`, `CX::Done`, `Cursor`, `Date`, `Dateish`, + `DateTime`, `Distribution`, `Distribution::Hash`, `Distribution::Locally`, + `Distribution::Path`, `Distribution::Resource`, `Distro`, `Duration`, `Encoding`, + `Encoding::GlobalLexerRegistry`, `Endian`, `Enumeration`, `Exception`, `Failure`, `FatRat`, `Grammar`, + `Hash`, `HyperWhatever`, `Instant`, `Int`, `int`, `int16`, `int32`, `int64`, `int8`, `str`, + `IntStr`, `IO`, `IO::ArgFiles`, `IO::CatHandle`, `IO::Handle`, `IO::Notification`, + `IO::Notification::Change`, `IO::Path`, `IO::Path::Cygwin`, `IO::Path::Parts`, + `IO::Path::QNX`, `IO::Path::Unix`, `IO::Path::Win32`, `IO::Pipe`, `IO::Socket`, + `IO::Socket::Async`, `IO::Socket::Async::ListenSocket`, `IO::Socket::INET`, `IO::Spec`, + `IO::Spec::Cygwin`, `IO::Spec::QNX`, `IO::Spec::Unix`, `IO::Spec::Win32`, `IO::Special`, + `Iterable`, `Iterator`, `Junction`, `Kernel`, `Label`, `List`, `Lock`, `Lock::Async`, + `Lock::ConditionVariable`, `long`, `longlong`, `Macro`, `Map`, `Match`, + `Metamodel::AttributeContainer`, `Metamodel::C3MRO`, `Metamodel::ClassHOW`, + `Metamodel::ConcreteRoleHOW`, `Metamodel::CurriedRoleHOW`, `Metamodel::DefiniteHOW`, + `Metamodel::Documenting`, `Metamodel::EnumHOW`, `Metamodel::Finalization`, + `Metamodel::MethodContainer`, `Metamodel::Mixins`, `Metamodel::MROBasedMethodDispatch`, + `Metamodel::MultipleInheritance`, `Metamodel::Naming`, `Metamodel::Primitives`, + `Metamodel::PrivateMethodContainer`, `Metamodel::RoleContainer`, `Metamodel::RolePunning`, + `Metamodel::Stashing`, `Metamodel::Trusting`, `Metamodel::Versioning`, `Method`, `Mix`, + `MixHash`, `Mixy`, `Mu`, `NFC`, `NFD`, `NFKC`, `NFKD`, `Nil`, `Num`, `num32`, `num64`, + `Numeric`, `NumStr`, `ObjAt`, `Order`, `Pair`, `Parameter`, `Perl`, `Pod::Block`, + `Pod::Block::Code`, `Pod::Block::Comment`, `Pod::Block::Declarator`, `Pod::Block::Named`, + `Pod::Block::Para`, `Pod::Block::Table`, `Pod::Heading`, `Pod::Item`, `Pointer`, + `Positional`, `PositionalBindFailover`, `Proc`, `Proc::Async`, `Promise`, `Proxy`, + `PseudoStash`, `QuantHash`, `RaceSeq`, `Raku`, `Range`, `Rat`, `Rational`, `RatStr`, + `Real`, `Regex`, `Routine`, `Routine::WrapHandle`, `Scalar`, `Scheduler`, `Semaphore`, + `Seq`, `Sequence`, `Set`, `SetHash`, `Setty`, `Signature`, `size_t`, `Slip`, `Stash`, + `Str`, `StrDistance`, `Stringy`, `Sub`, `Submethod`, `Supplier`, `Supplier::Preserving`, + `Supply`, `Systemic`, `Tap`, `Telemetry`, `Telemetry::Instrument::Thread`, + `Telemetry::Instrument::ThreadPool`, `Telemetry::Instrument::Usage`, `Telemetry::Period`, + `Telemetry::Sampler`, `Thread`, `Test`, `ThreadPoolScheduler`, `UInt`, `uint16`, `uint32`, + `uint64`, `uint8`, `Uni`, `utf8`, `ValueObjAt`, `Variable`, `Version`, `VM`, `Whatever`, + `WhateverCode`, `WrapHandle`, `NativeCall`, + // Pragmas + `precompilation`, `experimental`, `worries`, `MONKEY-TYPING`, `MONKEY-SEE-NO-EVAL`, + `MONKEY-GUTS`, `fatal`, `lib`, `isms`, `newline`, `nqp`, `soft`, + `strict`, `trace`, `variables`, + } + + builtinTypesPattern := Words(`(?<!['\w:-])`, `(?::[_UD])?(?!['\w:-])`, builtinTypes...) + + builtinRoutines := []string{ + `ACCEPTS`, `abs`, `abs2rel`, `absolute`, `accept`, `accepts_type`, `accessed`, `acos`, + `acosec`, `acosech`, `acosh`, `acotan`, `acotanh`, `acquire`, `act`, `action`, `actions`, + `add`, `add_attribute`, `add_enum_value`, `add_fallback`, `add_method`, `add_parent`, + `add_private_method`, `add_role`, `add_stash`, `add_trustee`, `addendum`, `adverb`, `after`, + `all`, `allocate`, `allof`, `allowed`, `alternative-names`, `annotations`, `antipair`, + `antipairs`, `any`, `anyof`, `api`, `app_lifetime`, `append`, `arch`, `archetypes`, + `archname`, `args`, `ARGS-TO-CAPTURE`, `arity`, `Array`, `asec`, `asech`, `asin`, `asinh`, + `ASSIGN-KEY`, `ASSIGN-POS`, `assuming`, `ast`, `at`, `atan`, `atan2`, `atanh`, `AT-KEY`, + `atomic-assign`, `atomic-dec-fetch`, `atomic-fetch`, `atomic-fetch-add`, `atomic-fetch-dec`, + `atomic-fetch-inc`, `atomic-fetch-sub`, `atomic-inc-fetch`, `AT-POS`, `attributes`, `auth`, + `await`, `backend`, `backtrace`, `Bag`, `bag`, `Baggy`, `BagHash`, `bail-out`, `base`, + `basename`, `base-repeating`, `base_type`, `batch`, `BIND-KEY`, `BIND-POS`, `bind-stderr`, + `bind-stdin`, `bind-stdout`, `bind-udp`, `bits`, `bless`, `block`, `Bool`, `bool-only`, + `bounds`, `break`, `Bridge`, `broken`, `BUILD`, `TWEAK`, `build-date`, `bytes`, `cache`, + `callframe`, `calling-package`, `CALL-ME`, `callsame`, `callwith`, `can`, `cancel`, + `candidates`, `cando`, `can-ok`, `canonpath`, `caps`, `caption`, `Capture`, `capture`, + `cas`, `catdir`, `categorize`, `categorize-list`, `catfile`, `catpath`, `cause`, `ceiling`, + `cglobal`, `changed`, `Channel`, `channel`, `chars`, `chdir`, `child`, `child-name`, + `child-typename`, `chmod`, `chomp`, `chop`, `chr`, `chrs`, `chunks`, `cis`, `classify`, + `classify-list`, `cleanup`, `clone`, `close`, `closed`, `close-stdin`, `cmp-ok`, `code`, + `codename`, `codes`, `coerce_type`, `coll`, `collate`, `column`, `comb`, `combinations`, + `command`, `comment`, `compiler`, `Complex`, `compose`, `composalizer`, `compose_type`, + `compose_values`, `composer`, `compute_mro`, `condition`, `config`, `configure_destroy`, + `configure_type_checking`, `conj`, `connect`, `constraints`, `construct`, `contains`, + `content`, `contents`, `copy`, `cos`, `cosec`, `cosech`, `cosh`, `cotan`, `cotanh`, `count`, + `count-only`, `cpu-cores`, `cpu-usage`, `CREATE`, `create_type`, `cross`, `cue`, `curdir`, + `curupdir`, `d`, `Date`, `DateTime`, `day`, `daycount`, `day-of-month`, `day-of-week`, + `day-of-year`, `days-in-month`, `dd-mm-yyyy`, `declaration`, `decode`, `decoder`, `deepmap`, + `default`, `defined`, `DEFINITE`, `definite`, `delayed`, `delete`, `delete-by-compiler`, + `DELETE-KEY`, `DELETE-POS`, `denominator`, `desc`, `DESTROY`, `destroyers`, `devnull`, + `diag`, `did-you-mean`, `die`, `dies-ok`, `dir`, `dirname`, `distribution`, `dir-sep`, + `DISTROnames`, `do`, `does`, `does-ok`, `done`, `done-testing`, `duckmap`, `dynamic`, `e`, + `eager`, `earlier`, `elems`, `emit`, `enclosing`, `encode`, `encoder`, `encoding`, `end`, + `endian`, `ends-with`, `enum_from_value`, `enum_value_list`, `enum_values`, `enums`, `EOF`, + `eof`, `EVAL`, `eval-dies-ok`, `EVALFILE`, `eval-lives-ok`, `event`, `exception`, + `excludes-max`, `excludes-min`, `EXISTS-KEY`, `EXISTS-POS`, `exit`, `exitcode`, `exp`, + `expected`, `explicitly-manage`, `expmod`, `export_callback`, `extension`, `f`, `fail`, + `FALLBACK`, `fails-like`, `fc`, `feature`, `file`, `filename`, `files`, `find`, + `find_method`, `find_method_qualified`, `finish`, `first`, `flat`, `first-date-in-month`, + `flatmap`, `flip`, `floor`, `flunk`, `flush`, `flush_cache`, `fmt`, `format`, `formatter`, + `free-memory`, `freeze`, `from`, `from-list`, `from-loop`, `from-posix`, `from-slurpy`, + `full`, `full-barrier`, `GENERATE-USAGE`, `generate_mixin`, `get`, `get_value`, `getc`, + `gist`, `got`, `grab`, `grabpairs`, `grep`, `handle`, `handled`, `handles`, `hardware`, + `has_accessor`, `Hash`, `hash`, `head`, `headers`, `hh-mm-ss`, `hidden`, `hides`, `hostname`, + `hour`, `how`, `hyper`, `id`, `illegal`, `im`, `in`, `in-timezone`, `indent`, `index`, + `indices`, `indir`, `infinite`, `infix`, `postcirumfix`, `cicumfix`, `install`, + `install_method_cache`, `Instant`, `instead`, `Int`, `int-bounds`, `interval`, `in-timezone`, + `invalid-str`, `invert`, `invocant`, `IO`, `IO::Notification.watch-path`, `is_trusted`, + `is_type`, `isa`, `is-absolute`, `isa-ok`, `is-approx`, `is-deeply`, `is-hidden`, + `is-initial-thread`, `is-int`, `is-lazy`, `is-leap-year`, `isNaN`, `isnt`, `is-prime`, + `is-relative`, `is-routine`, `is-setting`, `is-win`, `item`, `iterator`, `join`, `keep`, + `kept`, `KERNELnames`, `key`, `keyof`, `keys`, `kill`, `kv`, `kxxv`, `l`, `lang`, `last`, + `lastcall`, `later`, `lazy`, `lc`, `leading`, `level`, `like`, `line`, `lines`, `link`, + `List`, `list`, `listen`, `live`, `lives-ok`, `load`, `load-repo-id`, `load-unit`, `loaded`, + `loads`, `local`, `lock`, `log`, `log10`, `lookup`, `lsb`, `made`, `MAIN`, `make`, `Map`, + `map`, `match`, `max`, `maxpairs`, `merge`, `message`, `method`, `meta`, `method_table`, + `methods`, `migrate`, `min`, `minmax`, `minpairs`, `minute`, `misplaced`, `Mix`, `mix`, + `MixHash`, `mixin`, `mixin_attribute`, `Mixy`, `mkdir`, `mode`, `modified`, `month`, `move`, + `mro`, `msb`, `multi`, `multiness`, `name`, `named`, `named_names`, `narrow`, + `nativecast`, `native-descriptor`, `nativesizeof`, `need`, `new`, `new_type`, + `new-from-daycount`, `new-from-pairs`, `next`, `nextcallee`, `next-handle`, `nextsame`, + `nextwith`, `next-interesting-index`, `NFC`, `NFD`, `NFKC`, `NFKD`, `nice`, `nl-in`, + `nl-out`, `nodemap`, `nok`, `normalize`, `none`, `norm`, `not`, `note`, `now`, `nude`, + `Num`, `numerator`, `Numeric`, `of`, `offset`, `offset-in-hours`, `offset-in-minutes`, + `ok`, `old`, `on-close`, `one`, `on-switch`, `open`, `opened`, `operation`, `optional`, + `ord`, `ords`, `orig`, `os-error`, `osname`, `out-buffer`, `pack`, `package`, `package-kind`, + `package-name`, `packages`, `Pair`, `pair`, `pairs`, `pairup`, `parameter`, `params`, + `parent`, `parent-name`, `parents`, `parse`, `parse-base`, `parsefile`, `parse-names`, + `parts`, `pass`, `path`, `path-sep`, `payload`, `peer-host`, `peer-port`, `periods`, `perl`, + `permutations`, `phaser`, `pick`, `pickpairs`, `pid`, `placeholder`, `plan`, `plus`, + `polar`, `poll`, `polymod`, `pop`, `pos`, `positional`, `posix`, `postfix`, `postmatch`, + `precomp-ext`, `precomp-target`, `precompiled`, `pred`, `prefix`, `prematch`, `prepend`, + `primary`, `print`, `printf`, `print-nl`, `print-to`, `private`, `private_method_names`, + `private_method_table`, `proc`, `produce`, `Promise`, `promise`, `prompt`, `protect`, + `protect-or-queue-on-recursion`, `publish_method_cache`, `pull-one`, `push`, `push-all`, + `push-at-least`, `push-exactly`, `push-until-lazy`, `put`, `qualifier-type`, `quaternary`, + `quit`, `r`, `race`, `radix`, `raku`, `rand`, `Range`, `range`, `Rat`, `raw`, `re`, `read`, + `read-bits`, `read-int128`, `read-int16`, `read-int32`, `read-int64`, `read-int8`, + `read-num32`, `read-num64`, `read-ubits`, `read-uint128`, `read-uint16`, `read-uint32`, + `read-uint64`, `read-uint8`, `readchars`, `readonly`, `ready`, `Real`, `reallocate`, + `reals`, `reason`, `rebless`, `receive`, `recv`, `redispatcher`, `redo`, `reduce`, + `rel2abs`, `relative`, `release`, `remove`, `rename`, `repeated`, `replacement`, + `replace-with`, `repo`, `repo-id`, `report`, `required`, `reserved`, `resolve`, `restore`, + `result`, `resume`, `rethrow`, `return`, `return-rw`, `returns`, `reverse`, `right`, + `rindex`, `rmdir`, `role`, `roles_to_compose`, `rolish`, `roll`, `rootdir`, `roots`, + `rotate`, `rotor`, `round`, `roundrobin`, `routine-type`, `run`, `RUN-MAIN`, `rw`, `rwx`, + `samecase`, `samemark`, `samewith`, `say`, `schedule-on`, `scheduler`, `scope`, `sec`, + `sech`, `second`, `secondary`, `seek`, `self`, `send`, `Seq`, `Set`, `set`, `serial`, + `set_hidden`, `set_name`, `set_package`, `set_rw`, `set_value`, `set_api`, `set_auth`, + `set_composalizer`, `set_export_callback`, `set_is_mixin`, `set_mixin_attribute`, + `set_package`, `set_ver`, `set_why`, `SetHash`, `Setty`, `set-instruments`, + `setup_finalization`, `setup_mixin_cache`, `shape`, `share`, `shell`, `short-id`, + `short-name`, `shortname`, `shift`, `sibling`, `sigil`, `sign`, `signal`, `signals`, + `signature`, `sin`, `sinh`, `sink`, `sink-all`, `skip`, `skip-at-least`, + `skip-at-least-pull-one`, `skip-one`, `skip-rest`, `sleep`, `sleep-timer`, `sleep-until`, + `Slip`, `slip`, `slurp`, `slurp-rest`, `slurpy`, `snap`, `snapper`, `so`, `socket-host`, + `socket-port`, `sort`, `source`, `source-package`, `spawn`, `SPEC`, `splice`, `split`, + `splitdir`, `splitpath`, `sprintf`, `spurt`, `sqrt`, `squish`, `srand`, `stable`, `start`, + `started`, `starts-with`, `status`, `stderr`, `stdout`, `STORE`, `store-file`, + `store-repo-id`, `store-unit`, `Str`, `Stringy`, `sub_signature`, `subbuf`, `subbuf-rw`, + `subname`, `subparse`, `subst`, `subst-mutate`, `substr`, `substr-eq`, `substr-rw`, + `subtest`, `succ`, `sum`, `suffix`, `summary`, `Supply`, `symlink`, `T`, `t`, `tail`, + `take`, `take-rw`, `tan`, `tanh`, `tap`, `target`, `target-name`, `tc`, `tclc`, `tell`, + `term`, `tertiary`, `then`, `throttle`, `throw`, `throws-like`, `time`, `timezone`, + `tmpdir`, `to`, `today`, `todo`, `toggle`, `to-posix`, `total`, `total-memory`, `trailing`, + `trans`, `tree`, `trim`, `trim-leading`, `trim-trailing`, `truncate`, `truncated-to`, + `trusts`, `try_acquire`, `trying`, `twigil`, `type`, `type_captures`, `type_check`, + `typename`, `uc`, `udp`, `uncaught_handler`, `undefine`, `unimatch`, `unicmp`, `uniname`, + `uninames`, `uninstall`, `uniparse`, `uniprop`, `uniprops`, `unique`, `unival`, `univals`, + `unlike`, `unlink`, `unlock`, `unpack`, `unpolar`, `unset`, `unshift`, `unwrap`, `updir`, + `USAGE`, `usage-name`, `use-ok`, `utc`, `val`, `value`, `values`, `VAR`, `variable`, `ver`, + `verbose-config`, `Version`, `version`, `VMnames`, `volume`, `vow`, `w`, `wait`, `warn`, + `watch`, `watch-path`, `week`, `weekday-of-month`, `week-number`, `week-year`, `WHAT`, + `what`, `when`, `WHERE`, `WHEREFORE`, `WHICH`, `WHO`, `whole-second`, `WHY`, `why`, + `with-lock-hidden-from-recursion-check`, `wordcase`, `words`, `workaround`, `wrap`, + `write`, `write-bits`, `write-int128`, `write-int16`, `write-int32`, `write-int64`, + `write-int8`, `write-num32`, `write-num64`, `write-ubits`, `write-uint128`, `write-uint16`, + `write-uint32`, `write-uint64`, `write-uint8`, `write-to`, `x`, `yada`, `year`, `yield`, + `yyyy-mm-dd`, `z`, `zip`, `zip-latest`, `HOW`, `s`, `DEPRECATED`, `trait_mod`, + } + + builtinRoutinesPattern := Words(`(?<!['\w:-])`, `(?!['\w-])`, builtinRoutines...) + + // A map of opening and closing brackets + brackets := map[rune]rune{ + '\u0028': '\u0029', '\u003c': '\u003e', '\u005b': '\u005d', + '\u007b': '\u007d', '\u00ab': '\u00bb', '\u0f3a': '\u0f3b', + '\u0f3c': '\u0f3d', '\u169b': '\u169c', '\u2018': '\u2019', + '\u201a': '\u2019', '\u201b': '\u2019', '\u201c': '\u201d', + '\u201e': '\u201d', '\u201f': '\u201d', '\u2039': '\u203a', + '\u2045': '\u2046', '\u207d': '\u207e', '\u208d': '\u208e', + '\u2208': '\u220b', '\u2209': '\u220c', '\u220a': '\u220d', + '\u2215': '\u29f5', '\u223c': '\u223d', '\u2243': '\u22cd', + '\u2252': '\u2253', '\u2254': '\u2255', '\u2264': '\u2265', + '\u2266': '\u2267', '\u2268': '\u2269', '\u226a': '\u226b', + '\u226e': '\u226f', '\u2270': '\u2271', '\u2272': '\u2273', + '\u2274': '\u2275', '\u2276': '\u2277', '\u2278': '\u2279', + '\u227a': '\u227b', '\u227c': '\u227d', '\u227e': '\u227f', + '\u2280': '\u2281', '\u2282': '\u2283', '\u2284': '\u2285', + '\u2286': '\u2287', '\u2288': '\u2289', '\u228a': '\u228b', + '\u228f': '\u2290', '\u2291': '\u2292', '\u2298': '\u29b8', + '\u22a2': '\u22a3', '\u22a6': '\u2ade', '\u22a8': '\u2ae4', + '\u22a9': '\u2ae3', '\u22ab': '\u2ae5', '\u22b0': '\u22b1', + '\u22b2': '\u22b3', '\u22b4': '\u22b5', '\u22b6': '\u22b7', + '\u22c9': '\u22ca', '\u22cb': '\u22cc', '\u22d0': '\u22d1', + '\u22d6': '\u22d7', '\u22d8': '\u22d9', '\u22da': '\u22db', + '\u22dc': '\u22dd', '\u22de': '\u22df', '\u22e0': '\u22e1', + '\u22e2': '\u22e3', '\u22e4': '\u22e5', '\u22e6': '\u22e7', + '\u22e8': '\u22e9', '\u22ea': '\u22eb', '\u22ec': '\u22ed', + '\u22f0': '\u22f1', '\u22f2': '\u22fa', '\u22f3': '\u22fb', + '\u22f4': '\u22fc', '\u22f6': '\u22fd', '\u22f7': '\u22fe', + '\u2308': '\u2309', '\u230a': '\u230b', '\u2329': '\u232a', + '\u23b4': '\u23b5', '\u2768': '\u2769', '\u276a': '\u276b', + '\u276c': '\u276d', '\u276e': '\u276f', '\u2770': '\u2771', + '\u2772': '\u2773', '\u2774': '\u2775', '\u27c3': '\u27c4', + '\u27c5': '\u27c6', '\u27d5': '\u27d6', '\u27dd': '\u27de', + '\u27e2': '\u27e3', '\u27e4': '\u27e5', '\u27e6': '\u27e7', + '\u27e8': '\u27e9', '\u27ea': '\u27eb', '\u2983': '\u2984', + '\u2985': '\u2986', '\u2987': '\u2988', '\u2989': '\u298a', + '\u298b': '\u298c', '\u298d': '\u298e', '\u298f': '\u2990', + '\u2991': '\u2992', '\u2993': '\u2994', '\u2995': '\u2996', + '\u2997': '\u2998', '\u29c0': '\u29c1', '\u29c4': '\u29c5', + '\u29cf': '\u29d0', '\u29d1': '\u29d2', '\u29d4': '\u29d5', + '\u29d8': '\u29d9', '\u29da': '\u29db', '\u29f8': '\u29f9', + '\u29fc': '\u29fd', '\u2a2b': '\u2a2c', '\u2a2d': '\u2a2e', + '\u2a34': '\u2a35', '\u2a3c': '\u2a3d', '\u2a64': '\u2a65', + '\u2a79': '\u2a7a', '\u2a7d': '\u2a7e', '\u2a7f': '\u2a80', + '\u2a81': '\u2a82', '\u2a83': '\u2a84', '\u2a8b': '\u2a8c', + '\u2a91': '\u2a92', '\u2a93': '\u2a94', '\u2a95': '\u2a96', + '\u2a97': '\u2a98', '\u2a99': '\u2a9a', '\u2a9b': '\u2a9c', + '\u2aa1': '\u2aa2', '\u2aa6': '\u2aa7', '\u2aa8': '\u2aa9', + '\u2aaa': '\u2aab', '\u2aac': '\u2aad', '\u2aaf': '\u2ab0', + '\u2ab3': '\u2ab4', '\u2abb': '\u2abc', '\u2abd': '\u2abe', + '\u2abf': '\u2ac0', '\u2ac1': '\u2ac2', '\u2ac3': '\u2ac4', + '\u2ac5': '\u2ac6', '\u2acd': '\u2ace', '\u2acf': '\u2ad0', + '\u2ad1': '\u2ad2', '\u2ad3': '\u2ad4', '\u2ad5': '\u2ad6', + '\u2aec': '\u2aed', '\u2af7': '\u2af8', '\u2af9': '\u2afa', + '\u2e02': '\u2e03', '\u2e04': '\u2e05', '\u2e09': '\u2e0a', + '\u2e0c': '\u2e0d', '\u2e1c': '\u2e1d', '\u2e20': '\u2e21', + '\u3008': '\u3009', '\u300a': '\u300b', '\u300c': '\u300d', + '\u300e': '\u300f', '\u3010': '\u3011', '\u3014': '\u3015', + '\u3016': '\u3017', '\u3018': '\u3019', '\u301a': '\u301b', + '\u301d': '\u301e', '\ufd3e': '\ufd3f', '\ufe17': '\ufe18', + '\ufe35': '\ufe36', '\ufe37': '\ufe38', '\ufe39': '\ufe3a', + '\ufe3b': '\ufe3c', '\ufe3d': '\ufe3e', '\ufe3f': '\ufe40', + '\ufe41': '\ufe42', '\ufe43': '\ufe44', '\ufe47': '\ufe48', + '\ufe59': '\ufe5a', '\ufe5b': '\ufe5c', '\ufe5d': '\ufe5e', + '\uff08': '\uff09', '\uff1c': '\uff1e', '\uff3b': '\uff3d', + '\uff5b': '\uff5d', '\uff5f': '\uff60', '\uff62': '\uff63', + } + + bracketsPattern := `[` + regexp.QuoteMeta(joinRuneMap(brackets)) + `]` + + // Finds opening brackets and their closing counterparts (including pod and heredoc) + // and modifies state groups and position accordingly + findBrackets := func(tokenClass RakuToken) MutatorFunc { + return func(state *LexerState) error { + var openingChars []rune + var adverbs []rune + switch tokenClass { + case rakuPod: + openingChars = []rune(strings.Join(state.Groups[1:5], ``)) + default: + adverbs = []rune(state.NamedGroups[`adverbs`]) + openingChars = []rune(state.NamedGroups[`opening_delimiters`]) + } + + openingChar := openingChars[0] + + nChars := len(openingChars) + + var closingChar rune + var closingCharExists bool + var closingChars []rune + + switch tokenClass { + case rakuPod: + closingCharExists = true + default: + closingChar, closingCharExists = brackets[openingChar] + } + + switch tokenClass { + case rakuPodFormatter: + formatter := StringOther + + switch state.NamedGroups[`keyword`] { + case "B": + formatter = GenericStrong + case "I": + formatter = GenericEmph + case "U": + formatter = GenericUnderline + } + + formatterRule := ruleReplacingConfig{ + pattern: `.+?`, + tokenType: formatter, + mutator: nil, + stateName: `pod-formatter`, + rulePosition: bottomRule, + } + + err := replaceRule(formatterRule)(state) + if err != nil { + panic(err) + } + + err = replaceRule(ruleReplacingConfig{ + delimiter: []rune{closingChar}, + tokenType: Punctuation, + stateName: `pod-formatter`, + pushState: true, + numberOfDelimiterChars: nChars, + appendMutator: popRule(formatterRule), + })(state) + if err != nil { + panic(err) + } + + return nil + case rakuMatchRegex: + var delimiter []rune + if closingCharExists { + delimiter = []rune{closingChar} + } else { + delimiter = openingChars + } + + err := replaceRule(ruleReplacingConfig{ + delimiter: delimiter, + tokenType: Punctuation, + stateName: `regex`, + popState: true, + pushState: true, + })(state) + if err != nil { + panic(err) + } + + return nil + case rakuSubstitutionRegex: + delimiter := regexp2.Escape(string(openingChars)) + + err := replaceRule(ruleReplacingConfig{ + pattern: `(` + delimiter + `)` + `((?:\\\\|\\/|.)*?)` + `(` + delimiter + `)`, + tokenType: ByGroups(Punctuation, UsingSelf(`qq`), Punctuation), + rulePosition: topRule, + stateName: `regex`, + popState: true, + pushState: true, + })(state) + if err != nil { + panic(err) + } + + return nil + } + + text := state.Text + + var endPos int + + var nonMirroredOpeningCharPosition int + + if !closingCharExists { + // it's not a mirrored character, which means we + // just need to look for the next occurrence + closingChars = openingChars + nonMirroredOpeningCharPosition = indexAt(text, closingChars, state.Pos) + endPos = nonMirroredOpeningCharPosition + } else { + var podRegex *regexp2.Regexp + if tokenClass == rakuPod { + podRegex = regexp2.MustCompile( + state.NamedGroups[`ws`]+`=end`+`\s+`+regexp2.Escape(state.NamedGroups[`name`]), + 0, + ) + } else { + closingChars = []rune(strings.Repeat(string(closingChar), nChars)) + } + + // we need to look for the corresponding closing character, + // keep nesting in mind + nestingLevel := 1 + + searchPos := state.Pos - nChars + + var nextClosePos int + + for nestingLevel > 0 { + if tokenClass == rakuPod { + match, err := podRegex.FindRunesMatchStartingAt(text, searchPos+nChars) + if err == nil { + closingChars = match.Runes() + nextClosePos = match.Index + } else { + nextClosePos = -1 + } + } else { + nextClosePos = indexAt(text, closingChars, searchPos+nChars) + } + + nextOpenPos := indexAt(text, openingChars, searchPos+nChars) + + switch { + case nextClosePos == -1: + nextClosePos = len(text) + nestingLevel = 0 + case nextOpenPos != -1 && nextOpenPos < nextClosePos: + nestingLevel++ + nChars = len(openingChars) + searchPos = nextOpenPos + default: // next_close_pos < next_open_pos + nestingLevel-- + nChars = len(closingChars) + searchPos = nextClosePos + } + } + + endPos = nextClosePos + } + + if endPos < 0 { + // if we didn't find a closer, just highlight the + // rest of the text in this class + endPos = len(text) + } + + adverbre := regexp.MustCompile(`:to\b|:heredoc\b`) + var heredocTerminator []rune + var endHeredocPos int + if adverbre.MatchString(string(adverbs)) { + if endPos != len(text) { + heredocTerminator = text[state.Pos:endPos] + nChars = len(heredocTerminator) + } else { + endPos = state.Pos + 1 + heredocTerminator = []rune{} + nChars = 0 + } + + if nChars > 0 { + endHeredocPos = indexAt(text[endPos:], heredocTerminator, 0) + if endHeredocPos > -1 { + endPos += endHeredocPos + } else { + endPos = len(text) + } + } + } + + textBetweenBrackets := string(text[state.Pos:endPos]) + switch tokenClass { + case rakuPod, rakuPodDeclaration, rakuNameAttribute: + state.NamedGroups[`value`] = textBetweenBrackets + state.NamedGroups[`closing_delimiters`] = string(closingChars) + case rakuQuote: + if len(heredocTerminator) > 0 { + // Length of heredoc terminator + closing chars + `;` + heredocFristPunctuationLen := nChars + len(openingChars) + 1 + + state.NamedGroups[`opening_delimiters`] = string(openingChars) + + string(text[state.Pos:state.Pos+heredocFristPunctuationLen]) + + state.NamedGroups[`value`] = + string(text[state.Pos+heredocFristPunctuationLen : endPos]) + + if endHeredocPos > -1 { + state.NamedGroups[`closing_delimiters`] = string(heredocTerminator) + } + } else { + state.NamedGroups[`value`] = textBetweenBrackets + if nChars > 0 { + state.NamedGroups[`closing_delimiters`] = string(closingChars) + } + } + default: + state.Groups = []string{state.Groups[0] + string(text[state.Pos:endPos+nChars])} + } + + state.Pos = endPos + nChars + + return nil + } + } + + // Raku rules + // Empty capture groups are placeholders and will be replaced by mutators + // DO NOT REMOVE THEM! + return Rules{ + "root": { + // Placeholder, will be overwritten by mutators, DO NOT REMOVE! + {`\A\z`, nil, nil}, + Include("common"), + {`{`, Punctuation, Push(`root`)}, + {`\(`, Punctuation, Push(`root`)}, + {`[)}]`, Punctuation, Pop(1)}, + {`;`, Punctuation, nil}, + {`\[|\]`, Operator, nil}, + {`.+?`, Text, nil}, + }, + "common": { + {`^#![^\n]*$`, CommentHashbang, nil}, + Include("pod"), + // Multi-line, Embedded comment + { + "#`(?<opening_delimiters>(?<delimiter>" + bracketsPattern + `)\k<delimiter>*)`, + CommentMultiline, + findBrackets(rakuMultilineComment), + }, + {`#[^\n]*$`, CommentSingle, nil}, + // /regex/ + { + `(?<=(?:^|\(|=|:|~~|\[|{|,|=>)\s*)(/)(?!\]|\))((?:\\\\|\\/|.)*?)((?<!(?<!\\)\\)/(?!'|"))`, + ByGroups(Punctuation, UsingSelf("regex"), Punctuation), + nil, + }, + Include("variable"), + // ::?VARIABLE + {`::\?\w+(?::[_UD])?`, NameVariableGlobal, nil}, + // Version + { + `\b(v)(\d+)((?:\.(?:\*|[\d\w]+))*)(\+)?`, + ByGroups(Keyword, NumberInteger, NameEntity, Operator), + nil, + }, + Include("number"), + // Hyperoperator | »*« + {`(>>)(\S+?)(<<)`, ByGroups(Operator, UsingSelf("root"), Operator), nil}, + {`(»)(\S+?)(«)`, ByGroups(Operator, UsingSelf("root"), Operator), nil}, + // Hyperoperator | «*« + {`(<<)(\S+?)(<<)`, ByGroups(Operator, UsingSelf("root"), Operator), nil}, + {`(«)(\S+?)(«)`, ByGroups(Operator, UsingSelf("root"), Operator), nil}, + // Hyperoperator | »*» + {`(>>)(\S+?)(>>)`, ByGroups(Operator, UsingSelf("root"), Operator), nil}, + {`(»)(\S+?)(»)`, ByGroups(Operator, UsingSelf("root"), Operator), nil}, + // <<quoted words>> + {`(?<!(?:\d+|\.(?:Int|Numeric)|[$@%]\*?[\w':-]+\s+|[\])}]\s+)\s*)(<<)(?!(?:(?!>>)[^\n])+?[},;] *\n)(?!(?:(?!>>).)+?>>\S+?>>)`, Punctuation, Push("<<")}, + // «quoted words» + {`(?<!(?:\d+|\.(?:Int|Numeric)|[$@%]\*?[\w':-]+\s+|[\])}]\s+)\s*)(«)(?![^»]+?[},;] *\n)(?![^»]+?»\S+?»)`, Punctuation, Push("«")}, + // [<] + {`(?<=\[\\?)<(?=\])`, Operator, nil}, + // < and > operators | something < onething > something + { + `(?<=[$@%&]?\w[\w':-]* +)(<=?)( *[^ ]+? *)(>=?)(?= *[$@%&]?\w[\w':-]*)`, + ByGroups(Operator, UsingSelf("root"), Operator), + nil, + }, + // <quoted words> + { + `(?<!(?:\d+|\.(?:Int|Numeric)|[$@%]\*?[\w':-]+\s+|[\])}]\s+)\s*)(<)((?:(?![,;)}] *(?:#[^\n]+)?\n)[^<>])+?)(>)(?!\s*(?:\d+|\.(?:Int|Numeric)|[$@%]\*?\w[\w':-]*[^(]|\s+\[))`, + ByGroups(Punctuation, String, Punctuation), + nil, + }, + {`C?X::['\w:-]+`, NameException, nil}, + Include("metaoperator"), + // Pair | key => value + { + `(\w[\w'-]*)(\s*)(=>)`, + ByGroups(String, Text, Operator), + nil, + }, + Include("colon-pair"), + // Token + { + `(?<=(?:^|\s)(?:regex|token|rule)(\s+))` + namePattern + colonPairLookahead + `\s*[({])`, + NameFunction, + Push("token", "name-adverb"), + }, + // Substitution + {`(?<=^|\b|\s)(?<!\.)(ss|S|s|TR|tr)\b(\s*)`, ByGroups(Keyword, Text), Push("substitution")}, + {keywordsPattern, Keyword, nil}, + {builtinTypesPattern, NameBuiltin, nil}, + {builtinRoutinesPattern, NameBuiltin, nil}, + // Class name + { + `(?<=(?:^|\s)(?:class|grammar|role|does|but|is|subset|of)\s+)` + namePattern, + NameClass, + Push("name-adverb"), + }, + // Routine + { + `(?<=(?:^|\s)(?:sub|method|multi sub|multi)\s+)!?` + namePattern + colonPairLookahead + `\s*[({])`, + NameFunction, + Push("name-adverb"), + }, + // Constant + {`(?<=\bconstant\s+)` + namePattern, NameConstant, Push("name-adverb")}, + // Namespace + {`(?<=\b(?:use|module|package)\s+)` + namePattern, NameNamespace, Push("name-adverb")}, + Include("operator"), + Include("single-quote"), + {`(?<!(?<!\\)\\)"`, Punctuation, Push("double-quotes")}, + // m,rx regex + {`(?<=^|\b|\s)(ms|m|rx)\b(\s*)`, ByGroups(Keyword, Text), Push("rx")}, + // Quote constructs + { + `(?<=^|\b|\s)(?<keyword>(?:qq|q|Q))(?<adverbs>(?::?(?:heredoc|to|qq|ww|q|w|s|a|h|f|c|b|to|v|x))*)(?<ws>\s*)(?<opening_delimiters>(?<delimiter>[^0-9a-zA-Z:\s])\k<delimiter>*)`, + EmitterFunc(quote), + findBrackets(rakuQuote), + }, + // Function + { + `\b` + namePattern + colonPairLookahead + `\()`, + NameFunction, + Push("name-adverb"), + }, + // Method + { + `(?<!\.\.[?^*+]?)(?<=(?:\.[?^*+&]?)|self!)` + namePattern + colonPairLookahead + `\b)`, + NameFunction, + Push("name-adverb"), + }, + // Indirect invocant + {namePattern + `(?=\s+\W?['\w:-]+:\W)`, NameFunction, Push("name-adverb")}, + {`(?<=\W)(?:∅|i|e|𝑒|tau|τ|pi|π|Inf|∞)(?=\W)`, NameConstant, nil}, + {`(｢)([^｣]*)(｣)`, ByGroups(Punctuation, String, Punctuation), nil}, + {`(?<=^ *)\b` + namePattern + `(?=:\s*(?:for|while|loop))`, NameLabel, nil}, + // Sigilless variable + { + `(?<=\b(?:my|our|constant|let|temp)\s+)\\` + namePattern, + NameVariable, + Push("name-adverb"), + }, + {namePattern, Name, Push("name-adverb")}, + }, + "rx": { + Include("colon-pair-attribute"), + { + `(?<opening_delimiters>(?<delimiter>[^\w:\s])\k<delimiter>*)`, + ByGroupNames( + map[string]Emitter{ + `opening_delimiters`: Punctuation, + `delimiter`: nil, + }, + ), + findBrackets(rakuMatchRegex), + }, + }, + "substitution": { + Include("colon-pair-attribute"), + // Substitution | s{regex} = value + { + `(?<opening_delimiters>(?<delimiter>` + bracketsPattern + `)\k<delimiter>*)`, + ByGroupNames(map[string]Emitter{ + `opening_delimiters`: Punctuation, + `delimiter`: nil, + }), + findBrackets(rakuMatchRegex), + }, + // Substitution | s/regex/string/ + { + `(?<opening_delimiters>[^\w:\s])`, + Punctuation, + findBrackets(rakuSubstitutionRegex), + }, + }, + "number": { + {`0_?[0-7]+(_[0-7]+)*`, LiteralNumberOct, nil}, + {`0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*`, LiteralNumberHex, nil}, + {`0b[01]+(_[01]+)*`, LiteralNumberBin, nil}, + { + `(?i)(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?`, + LiteralNumberFloat, + nil, + }, + {`(?i)\d+(_\d*)*e[+-]?\d+(_\d*)*`, LiteralNumberFloat, nil}, + {`(?<=\d+)i`, NameConstant, nil}, + {`\d+(_\d+)*`, LiteralNumberInteger, nil}, + }, + "name-adverb": { + Include("colon-pair-attribute-keyvalue"), + Default(Pop(1)), + }, + "colon-pair": { + // :key(value) + {colonPairPattern, colonPair(String), findBrackets(rakuNameAttribute)}, + // :123abc + { + `(:)(\d+)(\w[\w'-]*)`, + ByGroups(Punctuation, UsingSelf("number"), String), + nil, + }, + // :key + {`(:)(!?)(\w[\w'-]*)`, ByGroups(Punctuation, Operator, String), nil}, + {`\s+`, Text, nil}, + }, + "colon-pair-attribute": { + // :key(value) + {colonPairPattern, colonPair(NameAttribute), findBrackets(rakuNameAttribute)}, + // :123abc + { + `(:)(\d+)(\w[\w'-]*)`, + ByGroups(Punctuation, UsingSelf("number"), NameAttribute), + nil, + }, + // :key + {`(:)(!?)(\w[\w'-]*)`, ByGroups(Punctuation, Operator, NameAttribute), nil}, + {`\s+`, Text, nil}, + }, + "colon-pair-attribute-keyvalue": { + // :key(value) + {colonPairPattern, colonPair(NameAttribute), findBrackets(rakuNameAttribute)}, + }, + "escape-qq": { + { + `(?<!(?<!\\)\\)(\\qq)(\[)(.+?)(\])`, + ByGroups(StringEscape, Punctuation, UsingSelf("qq"), Punctuation), + nil, + }, + }, + `escape-char`: { + {`(?<!(?<!\\)\\)(\\[abfrnrt])`, StringEscape, nil}, + }, + `escape-single-quote`: { + {`(?<!(?<!\\)\\)(\\)(['\\])`, ByGroups(StringEscape, StringSingle), nil}, + }, + "escape-c-name": { + { + `(?<!(?<!\\)\\)(\\[c|C])(\[)(.+?)(\])`, + ByGroups(StringEscape, Punctuation, String, Punctuation), + nil, + }, + }, + "escape-hexadecimal": { + { + `(?<!(?<!\\)\\)(\\[x|X])(\[)([0-9a-fA-F]+)(\])`, + ByGroups(StringEscape, Punctuation, NumberHex, Punctuation), + nil, + }, + {`(\\[x|X])([0-9a-fA-F]+)`, ByGroups(StringEscape, NumberHex), nil}, + }, + "regex": { + // Placeholder, will be overwritten by mutators, DO NOT REMOVE! + {`\A\z`, nil, nil}, + Include("regex-escape-class"), + Include(`regex-character-escape`), + // $(code) + { + `([$@])((?<!(?<!\\)\\)\()`, + ByGroups(Keyword, Punctuation), + replaceRule(ruleReplacingConfig{ + delimiter: []rune(`)`), + tokenType: Punctuation, + stateName: `root`, + pushState: true, + }), + }, + // Exclude $/ from variables, because we can't get out of the end of the slash regex: $/; + {`\$(?=/)`, NameEntity, nil}, + // Exclude $ from variables + {`\$(?=\z|\s|[^<(\w*!.])`, NameEntity, nil}, + Include("variable"), + Include("escape-c-name"), + Include("escape-hexadecimal"), + Include("number"), + Include("single-quote"), + // :my variable code ... + { + `(?<!(?<!\\)\\)(:)(my|our|state|constant|temp|let)`, + ByGroups(Operator, KeywordDeclaration), + replaceRule(ruleReplacingConfig{ + delimiter: []rune(`;`), + tokenType: Punctuation, + stateName: `root`, + pushState: true, + }), + }, + // <{code}> + { + `(?<!(?<!\\)\\)(<)([?!.]*)((?<!(?<!\\)\\){)`, + ByGroups(Punctuation, Operator, Punctuation), + replaceRule(ruleReplacingConfig{ + delimiter: []rune(`}>`), + tokenType: Punctuation, + stateName: `root`, + pushState: true, + }), + }, + // {code} + Include(`closure`), + // Properties + {`(:)(\w+)`, ByGroups(Punctuation, NameAttribute), nil}, + // Operator + {`\|\||\||&&|&|\.\.|\*\*|%%|%|:|!|<<|«|>>|»|\+|\*\*|\*|\?|=|~|<~~>`, Operator, nil}, + // Anchors + {`\^\^|\^|\$\$|\$`, NameEntity, nil}, + {`\.`, NameEntity, nil}, + {`#[^\n]*\n`, CommentSingle, nil}, + // Lookaround + { + `(?<!(?<!\\)\\)(<)(\s*)([?!.]+)(\s*)(after|before)`, + ByGroups(Punctuation, Text, Operator, Text, OperatorWord), + replaceRule(ruleReplacingConfig{ + delimiter: []rune(`>`), + tokenType: Punctuation, + stateName: `regex`, + pushState: true, + }), + }, + { + `(?<!(?<!\\)\\)(<)([|!?.]*)(wb|ww|ws|w)(>)`, + ByGroups(Punctuation, Operator, OperatorWord, Punctuation), + nil, + }, + // <$variable> + { + `(?<!(?<!\\)\\)(<)([?!.]*)([$@]\w[\w:-]*)(>)`, + ByGroups(Punctuation, Operator, NameVariable, Punctuation), + nil, + }, + // Capture markers + {`(?<!(?<!\\)\\)<\(|\)>`, Operator, nil}, + { + `(?<!(?<!\\)\\)(<)(\w[\w:-]*)(=\.?)`, + ByGroups(Punctuation, NameVariable, Operator), + Push(`regex-variable`), + }, + { + `(?<!(?<!\\)\\)(<)([|!?.&]*)(\w(?:(?!:\s)[\w':-])*)`, + ByGroups(Punctuation, Operator, NameFunction), + Push(`regex-function`), + }, + {`(?<!(?<!\\)\\)<`, Punctuation, Push("regex-property")}, + {`(?<!(?<!\\)\\)"`, Punctuation, Push("double-quotes")}, + {`(?<!(?<!\\)\\)(?:\]|\))`, Punctuation, Pop(1)}, + {`(?<!(?<!\\)\\)(?:\[|\()`, Punctuation, Push("regex")}, + {`.+?`, StringRegex, nil}, + }, + "regex-class-builtin": { + { + `\b(?:alnum|alpha|blank|cntrl|digit|graph|lower|print|punct|space|upper|xdigit|same|ident)\b`, + NameBuiltin, + nil, + }, + }, + "regex-function": { + // <function> + {`(?<!(?<!\\)\\)>`, Punctuation, Pop(1)}, + // <function(parameter)> + { + `\(`, + Punctuation, + replaceRule(ruleReplacingConfig{ + delimiter: []rune(`)>`), + tokenType: Punctuation, + stateName: `root`, + popState: true, + pushState: true, + }), + }, + // <function value> + { + `\s+`, + StringRegex, + replaceRule(ruleReplacingConfig{ + delimiter: []rune(`>`), + tokenType: Punctuation, + stateName: `regex`, + popState: true, + pushState: true, + }), + }, + // <function: value> + { + `:`, + Punctuation, + replaceRule(ruleReplacingConfig{ + delimiter: []rune(`>`), + tokenType: Punctuation, + stateName: `root`, + popState: true, + pushState: true, + }), + }, + }, + "regex-variable": { + Include(`regex-starting-operators`), + // <var=function( + { + `(&)?(\w(?:(?!:\s)[\w':-])*)(?=\()`, + ByGroups(Operator, NameFunction), + Mutators(Pop(1), Push(`regex-function`)), + }, + // <var=function> + {`(&)?(\w[\w':-]*)(>)`, ByGroups(Operator, NameFunction, Punctuation), Pop(1)}, + // <var= + Default(Pop(1), Push(`regex-property`)), + }, + "regex-property": { + {`(?<!(?<!\\)\\)>`, Punctuation, Pop(1)}, + Include("regex-class-builtin"), + Include("variable"), + Include(`regex-starting-operators`), + Include("colon-pair-attribute"), + {`(?<!(?<!\\)\\)\[`, Punctuation, Push("regex-character-class")}, + {`\+|\-`, Operator, nil}, + {`@[\w':-]+`, NameVariable, nil}, + {`.+?`, StringRegex, nil}, + }, + `regex-starting-operators`: { + {`(?<=<)[|!?.]+`, Operator, nil}, + }, + "regex-escape-class": { + {`(?i)\\n|\\t|\\h|\\v|\\s|\\d|\\w`, StringEscape, nil}, + }, + `regex-character-escape`: { + {`(?<!(?<!\\)\\)(\\)(.)`, ByGroups(StringEscape, StringRegex), nil}, + }, + "regex-character-class": { + {`(?<!(?<!\\)\\)\]`, Punctuation, Pop(1)}, + Include("regex-escape-class"), + Include("escape-c-name"), + Include("escape-hexadecimal"), + Include(`regex-character-escape`), + Include("number"), + {`\.\.`, Operator, nil}, + {`.+?`, StringRegex, nil}, + }, + "metaoperator": { + // Z[=>] + { + `\b([RZX]+)\b(\[)([^\s\]]+?)(\])`, + ByGroups(OperatorWord, Punctuation, UsingSelf("root"), Punctuation), + nil, + }, + // Z=> + {`\b([RZX]+)\b([^\s\]]+)`, ByGroups(OperatorWord, UsingSelf("operator")), nil}, + }, + "operator": { + // Word Operator + {wordOperatorsPattern, OperatorWord, nil}, + // Operator + {operatorsPattern, Operator, nil}, + }, + "pod": { + // Single-line pod declaration + {`(#[|=])\s`, Keyword, Push("pod-single")}, + // Multi-line pod declaration + { + "(?<keyword>#[|=])(?<opening_delimiters>(?<delimiter>" + bracketsPattern + `)\k<delimiter>*)(?<value>)(?<closing_delimiters>)`, + ByGroupNames( + map[string]Emitter{ + `keyword`: Keyword, + `opening_delimiters`: Punctuation, + `delimiter`: nil, + `value`: UsingSelf("pod-declaration"), + `closing_delimiters`: Punctuation, + }), + findBrackets(rakuPodDeclaration), + }, + Include("pod-blocks"), + }, + "pod-blocks": { + // =begin code + { + `(?<=^ *)(?<ws> *)(?<keyword>=begin)(?<ws2> +)(?<name>code)(?<config>[^\n]*)(?<value>.*?)(?<ws3>^\k<ws>)(?<end_keyword>=end)(?<ws4> +)\k<name>`, + EmitterFunc(podCode), + nil, + }, + // =begin + { + `(?<=^ *)(?<ws> *)(?<keyword>=begin)(?<ws2> +)(?!code)(?<name>\w[\w'-]*)(?<config>[^\n]*)(?<value>)(?<closing_delimiters>)`, + ByGroupNames( + map[string]Emitter{ + `ws`: Comment, + `keyword`: Keyword, + `ws2`: StringDoc, + `name`: Keyword, + `config`: EmitterFunc(podConfig), + `value`: UsingSelf("pod-begin"), + `closing_delimiters`: Keyword, + }), + findBrackets(rakuPod), + }, + // =for ... + { + `(?<=^ *)(?<ws> *)(?<keyword>=(?:for|defn))(?<ws2> +)(?<name>\w[\w'-]*)(?<config>[^\n]*\n)`, + ByGroups(Comment, Keyword, StringDoc, Keyword, EmitterFunc(podConfig)), + Push("pod-paragraph"), + }, + // =config + { + `(?<=^ *)(?<ws> *)(?<keyword>=config)(?<ws2> +)(?<name>\w[\w'-]*)(?<config>[^\n]*\n)`, + ByGroups(Comment, Keyword, StringDoc, Keyword, EmitterFunc(podConfig)), + nil, + }, + // =alias + { + `(?<=^ *)(?<ws> *)(?<keyword>=alias)(?<ws2> +)(?<name>\w[\w'-]*)(?<value>[^\n]*\n)`, + ByGroups(Comment, Keyword, StringDoc, Keyword, StringDoc), + nil, + }, + // =encoding + { + `(?<=^ *)(?<ws> *)(?<keyword>=encoding)(?<ws2> +)(?<name>[^\n]+)`, + ByGroups(Comment, Keyword, StringDoc, Name), + nil, + }, + // =para ... + { + `(?<=^ *)(?<ws> *)(?<keyword>=(?:para|table|pod))(?<config>(?<!\n\s*)[^\n]*\n)`, + ByGroups(Comment, Keyword, EmitterFunc(podConfig)), + Push("pod-paragraph"), + }, + // =head1 ... + { + `(?<=^ *)(?<ws> *)(?<keyword>=head\d+)(?<ws2> *)(?<config>#?)`, + ByGroups(Comment, Keyword, GenericHeading, Keyword), + Push("pod-heading"), + }, + // =item ... + { + `(?<=^ *)(?<ws> *)(?<keyword>=(?:item\d*|comment|data|[A-Z]+))(?<ws2> *)(?<config>#?)`, + ByGroups(Comment, Keyword, StringDoc, Keyword), + Push("pod-paragraph"), + }, + { + `(?<=^ *)(?<ws> *)(?<keyword>=finish)(?<config>[^\n]*)`, + ByGroups(Comment, Keyword, EmitterFunc(podConfig)), + Push("pod-finish"), + }, + // ={custom} ... + { + `(?<=^ *)(?<ws> *)(?<name>=\w[\w'-]*)(?<ws2> *)(?<config>#?)`, + ByGroups(Comment, Name, StringDoc, Keyword), + Push("pod-paragraph"), + }, + // = podconfig + { + `(?<=^ *)(?<keyword> *=)(?<ws> *)(?<config>(?::\w[\w'-]*(?:` + colonPairOpeningBrackets + `.+?` + + colonPairClosingBrackets + `) *)*\n)`, + ByGroups(Keyword, StringDoc, EmitterFunc(podConfig)), + nil, + }, + }, + "pod-begin": { + Include("pod-blocks"), + Include("pre-pod-formatter"), + {`.+?`, StringDoc, nil}, + }, + "pod-declaration": { + Include("pre-pod-formatter"), + {`.+?`, StringDoc, nil}, + }, + "pod-paragraph": { + {`\n *\n|\n(?=^ *=)`, StringDoc, Pop(1)}, + Include("pre-pod-formatter"), + {`.+?`, StringDoc, nil}, + }, + "pod-single": { + {`\n`, StringDoc, Pop(1)}, + Include("pre-pod-formatter"), + {`.+?`, StringDoc, nil}, + }, + "pod-heading": { + {`\n *\n|\n(?=^ *=)`, GenericHeading, Pop(1)}, + Include("pre-pod-formatter"), + {`.+?`, GenericHeading, nil}, + }, + "pod-finish": { + {`\z`, nil, Pop(1)}, + Include("pre-pod-formatter"), + {`.+?`, StringDoc, nil}, + }, + "pre-pod-formatter": { + // C<code>, B<bold>, ... + { + `(?<keyword>[CBIUDTKRPAELZVMSXN])(?<opening_delimiters><+|«)`, + ByGroups(Keyword, Punctuation), + findBrackets(rakuPodFormatter), + }, + }, + "pod-formatter": { + // Placeholder rule, will be replaced by mutators. DO NOT REMOVE! + {`>`, Punctuation, Pop(1)}, + Include("pre-pod-formatter"), + // Placeholder rule, will be replaced by mutators. DO NOT REMOVE! + {`.+?`, StringOther, nil}, + }, + "variable": { + {variablePattern, NameVariable, Push("name-adverb")}, + {globalVariablePattern, NameVariableGlobal, Push("name-adverb")}, + {`[$@]<[^>]+>`, NameVariable, nil}, + {`\$[/!¢]`, NameVariable, nil}, + {`[$@%]`, NameVariable, nil}, + }, + "single-quote": { + {`(?<!(?<!\\)\\)'`, Punctuation, Push("single-quote-inner")}, + }, + "single-quote-inner": { + {`(?<!(?<!(?<!\\)\\)\\)'`, Punctuation, Pop(1)}, + Include("escape-single-quote"), + Include("escape-qq"), + {`(?:\\\\|\\[^\\]|[^'\\])+?`, StringSingle, nil}, + }, + "double-quotes": { + {`(?<!(?<!\\)\\)"`, Punctuation, Pop(1)}, + Include("qq"), + }, + "<<": { + {`>>(?!\s*(?:\d+|\.(?:Int|Numeric)|[$@%]\*?[\w':-]+|\s+\[))`, Punctuation, Pop(1)}, + Include("ww"), + }, + "«": { + {`»(?!\s*(?:\d+|\.(?:Int|Numeric)|[$@%]\*?[\w':-]+|\s+\[))`, Punctuation, Pop(1)}, + Include("ww"), + }, + "ww": { + Include("single-quote"), + Include("qq"), + }, + "qq": { + Include("qq-variable"), + Include("closure"), + Include(`escape-char`), + Include("escape-hexadecimal"), + Include("escape-c-name"), + Include("escape-qq"), + {`.+?`, StringDouble, nil}, + }, + "qq-variable": { + { + `(?<!(?<!\\)\\)(?:` + variablePattern + `|` + globalVariablePattern + `)` + colonPairLookahead + `)`, + NameVariable, + Push("qq-variable-extras", "name-adverb"), + }, + }, + "qq-variable-extras": { + // Method + { + `(?<operator>\.)(?<method_name>` + namePattern + `)` + colonPairLookahead + `\()`, + ByGroupNames(map[string]Emitter{ + `operator`: Operator, + `method_name`: NameFunction, + }), + Push(`name-adverb`), + }, + // Function/Signature + { + `\(`, Punctuation, replaceRule( + ruleReplacingConfig{ + delimiter: []rune(`)`), + tokenType: Punctuation, + stateName: `root`, + pushState: true, + }), + }, + Default(Pop(1)), + }, + "Q": { + Include("escape-qq"), + {`.+?`, String, nil}, + }, + "Q-closure": { + Include("escape-qq"), + Include("closure"), + {`.+?`, String, nil}, + }, + "Q-variable": { + Include("escape-qq"), + Include("qq-variable"), + {`.+?`, String, nil}, + }, + "closure": { + {`(?<!(?<!\\)\\){`, Punctuation, replaceRule( + ruleReplacingConfig{ + delimiter: []rune(`}`), + tokenType: Punctuation, + stateName: `root`, + pushState: true, + }), + }, + }, + "token": { + // Token signature + {`\(`, Punctuation, replaceRule( + ruleReplacingConfig{ + delimiter: []rune(`)`), + tokenType: Punctuation, + stateName: `root`, + pushState: true, + }), + }, + {`{`, Punctuation, replaceRule( + ruleReplacingConfig{ + delimiter: []rune(`}`), + tokenType: Punctuation, + stateName: `regex`, + popState: true, + pushState: true, + }), + }, + {`\s*`, Text, nil}, + Default(Pop(1)), + }, + } +} + +// Joins keys of rune map +func joinRuneMap(m map[rune]rune) string { + runes := make([]rune, 0, len(m)) + for k := range m { + runes = append(runes, k) + } + + return string(runes) +} + +// Finds the index of substring in the string starting at position n +func indexAt(str []rune, substr []rune, pos int) int { + strFromPos := str[pos:] + text := string(strFromPos) + + idx := strings.Index(text, string(substr)) + if idx > -1 { + idx = utf8.RuneCountInString(text[:idx]) + + // Search again if the substr is escaped with backslash + if (idx > 1 && strFromPos[idx-1] == '\\' && strFromPos[idx-2] != '\\') || + (idx == 1 && strFromPos[idx-1] == '\\') { + idx = indexAt(str[pos:], substr, idx+1) + + idx = utf8.RuneCountInString(text[:idx]) + + if idx < 0 { + return idx + } + } + idx += pos + } + + return idx +} + +// Tells if an array of string contains a string +func contains(s []string, e string) bool { + for _, value := range s { + if value == e { + return true + } + } + return false +} + +type rulePosition int + +const ( + topRule rulePosition = 0 + bottomRule = -1 +) + +type ruleMakingConfig struct { + delimiter []rune + pattern string + tokenType Emitter + mutator Mutator + numberOfDelimiterChars int +} + +type ruleReplacingConfig struct { + delimiter []rune + pattern string + tokenType Emitter + numberOfDelimiterChars int + mutator Mutator + appendMutator Mutator + rulePosition rulePosition + stateName string + pop bool + popState bool + pushState bool +} + +// Pops rule from state-stack and replaces the rule with the previous rule +func popRule(rule ruleReplacingConfig) MutatorFunc { + return func(state *LexerState) error { + stackName := genStackName(rule.stateName, rule.rulePosition) + + stack, ok := state.Get(stackName).([]ruleReplacingConfig) + + if ok && len(stack) > 0 { + // Pop from stack + stack = stack[:len(stack)-1] + lastRule := stack[len(stack)-1] + lastRule.pushState = false + lastRule.popState = false + lastRule.pop = true + state.Set(stackName, stack) + + // Call replaceRule to use the last rule + err := replaceRule(lastRule)(state) + if err != nil { + panic(err) + } + } + + return nil + } +} + +// Replaces a state's rule based on the rule config and position +func replaceRule(rule ruleReplacingConfig) MutatorFunc { + return func(state *LexerState) error { + stateName := rule.stateName + stackName := genStackName(rule.stateName, rule.rulePosition) + + stack, ok := state.Get(stackName).([]ruleReplacingConfig) + if !ok { + stack = []ruleReplacingConfig{} + } + + // If state-stack is empty fill it with the placeholder rule + if len(stack) == 0 { + stack = []ruleReplacingConfig{ + { + // Placeholder, will be overwritten by mutators, DO NOT REMOVE! + pattern: `\A\z`, + tokenType: nil, + mutator: nil, + stateName: stateName, + rulePosition: rule.rulePosition, + }, + } + state.Set(stackName, stack) + } + + var mutator Mutator + mutators := []Mutator{} + + switch { + case rule.rulePosition == topRule && rule.mutator == nil: + // Default mutator for top rule + mutators = []Mutator{Pop(1), popRule(rule)} + case rule.rulePosition == topRule && rule.mutator != nil: + // Default mutator for top rule, when rule.mutator is set + mutators = []Mutator{rule.mutator, popRule(rule)} + case rule.mutator != nil: + mutators = []Mutator{rule.mutator} + } + + if rule.appendMutator != nil { + mutators = append(mutators, rule.appendMutator) + } + + if len(mutators) > 0 { + mutator = Mutators(mutators...) + } else { + mutator = nil + } + + ruleConfig := ruleMakingConfig{ + pattern: rule.pattern, + delimiter: rule.delimiter, + numberOfDelimiterChars: rule.numberOfDelimiterChars, + tokenType: rule.tokenType, + mutator: mutator, + } + + cRule := makeRule(ruleConfig) + + switch rule.rulePosition { + case topRule: + state.Rules[stateName][0] = cRule + case bottomRule: + state.Rules[stateName][len(state.Rules[stateName])-1] = cRule + } + + // Pop state name from stack if asked. State should be popped first before Pushing + if rule.popState { + err := Pop(1).Mutate(state) + if err != nil { + panic(err) + } + } + + // Push state name to stack if asked + if rule.pushState { + err := Push(stateName).Mutate(state) + if err != nil { + panic(err) + } + } + + if !rule.pop { + state.Set(stackName, append(stack, rule)) + } + + return nil + } +} + +// Generates rule replacing stack using state name and rule position +func genStackName(stateName string, rulePosition rulePosition) (stackName string) { + switch rulePosition { + case topRule: + stackName = stateName + `-top-stack` + case bottomRule: + stackName = stateName + `-bottom-stack` + } + return +} + +// Makes a compiled rule and returns it +func makeRule(config ruleMakingConfig) *CompiledRule { + var rePattern string + + if len(config.delimiter) > 0 { + delimiter := string(config.delimiter) + + if config.numberOfDelimiterChars > 1 { + delimiter = strings.Repeat(delimiter, config.numberOfDelimiterChars) + } + + rePattern = `(?<!(?<!\\)\\)` + regexp2.Escape(delimiter) + } else { + rePattern = config.pattern + } + + regex := regexp2.MustCompile(rePattern, regexp2.None) + + cRule := &CompiledRule{ + Rule: Rule{rePattern, config.tokenType, config.mutator}, + Regexp: regex, + } + + return cRule +} + +// Emitter for colon pairs, changes token state based on key and brackets +func colonPair(tokenClass TokenType) Emitter { + return EmitterFunc(func(groups []string, state *LexerState) Iterator { + iterators := []Iterator{} + tokens := []Token{ + {Punctuation, state.NamedGroups[`colon`]}, + {Punctuation, state.NamedGroups[`opening_delimiters`]}, + {Punctuation, state.NamedGroups[`closing_delimiters`]}, + } + + // Append colon + iterators = append(iterators, Literator(tokens[0])) + + if tokenClass == NameAttribute { + iterators = append(iterators, Literator(Token{NameAttribute, state.NamedGroups[`key`]})) + } else { + var keyTokenState string + keyre := regexp.MustCompile(`^\d+$`) + if keyre.MatchString(state.NamedGroups[`key`]) { + keyTokenState = "common" + } else { + keyTokenState = "Q" + } + + // Use token state to Tokenise key + if keyTokenState != "" { + iterator, err := state.Lexer.Tokenise( + &TokeniseOptions{ + State: keyTokenState, + Nested: true, + }, state.NamedGroups[`key`]) + + if err != nil { + panic(err) + } else { + // Append key + iterators = append(iterators, iterator) + } + } + } + + // Append punctuation + iterators = append(iterators, Literator(tokens[1])) + + var valueTokenState string + + switch state.NamedGroups[`opening_delimiters`] { + case "(", "{", "[": + valueTokenState = "root" + case "<<", "«": + valueTokenState = "ww" + case "<": + valueTokenState = "Q" + } + + // Use token state to Tokenise value + if valueTokenState != "" { + iterator, err := state.Lexer.Tokenise( + &TokeniseOptions{ + State: valueTokenState, + Nested: true, + }, state.NamedGroups[`value`]) + + if err != nil { + panic(err) + } else { + // Append value + iterators = append(iterators, iterator) + } + } + // Append last punctuation + iterators = append(iterators, Literator(tokens[2])) + + return Concaterator(iterators...) + }) +} + +// Emitter for quoting constructs, changes token state based on quote name and adverbs +func quote(groups []string, state *LexerState) Iterator { + keyword := state.NamedGroups[`keyword`] + adverbsStr := state.NamedGroups[`adverbs`] + iterators := []Iterator{} + tokens := []Token{ + {Keyword, keyword}, + {StringAffix, adverbsStr}, + {Text, state.NamedGroups[`ws`]}, + {Punctuation, state.NamedGroups[`opening_delimiters`]}, + {Punctuation, state.NamedGroups[`closing_delimiters`]}, + } + + // Append all tokens before dealing with the main string + iterators = append(iterators, Literator(tokens[:4]...)) + + var tokenStates []string + + // Set tokenStates based on adverbs + adverbs := strings.Split(adverbsStr, ":") + for _, adverb := range adverbs { + switch adverb { + case "c", "closure": + tokenStates = append(tokenStates, "Q-closure") + case "qq": + tokenStates = append(tokenStates, "qq") + case "ww": + tokenStates = append(tokenStates, "ww") + case "s", "scalar", "a", "array", "h", "hash", "f", "function": + tokenStates = append(tokenStates, "Q-variable") + } + } + + var tokenState string + + switch { + case keyword == "qq" || contains(tokenStates, "qq"): + tokenState = "qq" + case adverbsStr == "ww" || contains(tokenStates, "ww"): + tokenState = "ww" + case contains(tokenStates, "Q-closure") && contains(tokenStates, "Q-variable"): + tokenState = "qq" + case contains(tokenStates, "Q-closure"): + tokenState = "Q-closure" + case contains(tokenStates, "Q-variable"): + tokenState = "Q-variable" + default: + tokenState = "Q" + } + + iterator, err := state.Lexer.Tokenise( + &TokeniseOptions{ + State: tokenState, + Nested: true, + }, state.NamedGroups[`value`]) + + if err != nil { + panic(err) + } else { + iterators = append(iterators, iterator) + } + + // Append the last punctuation + iterators = append(iterators, Literator(tokens[4])) + + return Concaterator(iterators...) +} + +// Emitter for pod config, tokenises the properties with "colon-pair-attribute" state +func podConfig(groups []string, state *LexerState) Iterator { + // Tokenise pod config + iterator, err := state.Lexer.Tokenise( + &TokeniseOptions{ + State: "colon-pair-attribute", + Nested: true, + }, groups[0]) + + if err != nil { + panic(err) + } else { + return iterator + } +} + +// Emitter for pod code, tokenises the code based on the lang specified +func podCode(groups []string, state *LexerState) Iterator { + iterators := []Iterator{} + tokens := []Token{ + {Comment, state.NamedGroups[`ws`]}, + {Keyword, state.NamedGroups[`keyword`]}, + {Keyword, state.NamedGroups[`ws2`]}, + {Keyword, state.NamedGroups[`name`]}, + {StringDoc, state.NamedGroups[`value`]}, + {Comment, state.NamedGroups[`ws3`]}, + {Keyword, state.NamedGroups[`end_keyword`]}, + {Keyword, state.NamedGroups[`ws4`]}, + {Keyword, state.NamedGroups[`name`]}, + } + + // Append all tokens before dealing with the pod config + iterators = append(iterators, Literator(tokens[:4]...)) + + // Tokenise pod config + iterators = append(iterators, podConfig([]string{state.NamedGroups[`config`]}, state)) + + langMatch := regexp.MustCompile(`:lang\W+(\w+)`).FindStringSubmatch(state.NamedGroups[`config`]) + var lang string + if len(langMatch) > 1 { + lang = langMatch[1] + } + + // Tokenise code based on lang property + sublexer := Get(lang) + if sublexer != nil { + iterator, err := sublexer.Tokenise(nil, state.NamedGroups[`value`]) + + if err != nil { + panic(err) + } else { + iterators = append(iterators, iterator) + } + } else { + iterators = append(iterators, Literator(tokens[4])) + } + + // Append the rest of the tokens + iterators = append(iterators, Literator(tokens[5:]...)) + + return Concaterator(iterators...) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/rst.go b/vendor/github.com/alecthomas/chroma/v2/lexers/rst.go new file mode 100644 index 0000000..66ec03c --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/rst.go @@ -0,0 +1,89 @@ +package lexers + +import ( + "strings" + + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Restructuredtext lexer. +var Restructuredtext = Register(MustNewLexer( + &Config{ + Name: "reStructuredText", + Aliases: []string{"rst", "rest", "restructuredtext"}, + Filenames: []string{"*.rst", "*.rest"}, + MimeTypes: []string{"text/x-rst", "text/prs.fallenstein.rst"}, + }, + restructuredtextRules, +)) + +func restructuredtextRules() Rules { + return Rules{ + "root": { + {"^(=+|-+|`+|:+|\\.+|\\'+|\"+|~+|\\^+|_+|\\*+|\\++|#+)([ \\t]*\\n)(.+)(\\n)(\\1)(\\n)", ByGroups(GenericHeading, Text, GenericHeading, Text, GenericHeading, Text), nil}, + {"^(\\S.*)(\\n)(={3,}|-{3,}|`{3,}|:{3,}|\\.{3,}|\\'{3,}|\"{3,}|~{3,}|\\^{3,}|_{3,}|\\*{3,}|\\+{3,}|#{3,})(\\n)", ByGroups(GenericHeading, Text, GenericHeading, Text), nil}, + {`^(\s*)([-*+])( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, + {`^(\s*)([0-9#ivxlcmIVXLCM]+\.)( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, + {`^(\s*)(\(?[0-9#ivxlcmIVXLCM]+\))( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, + {`^(\s*)([A-Z]+\.)( .+\n(?:\1 .+\n)+)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, + {`^(\s*)(\(?[A-Za-z]+\))( .+\n(?:\1 .+\n)+)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, + {`^(\s*)(\|)( .+\n(?:\| .+\n)*)`, ByGroups(Text, Operator, UsingSelf("inline")), nil}, + {`^( *\.\.)(\s*)((?:source)?code(?:-block)?)(::)([ \t]*)([^\n]+)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\8.*|)\n)+)`, EmitterFunc(rstCodeBlock), nil}, + {`^( *\.\.)(\s*)([\w:-]+?)(::)(?:([ \t]*)(.*))`, ByGroups(Punctuation, Text, OperatorWord, Punctuation, Text, UsingSelf("inline")), nil}, + {`^( *\.\.)(\s*)(_(?:[^:\\]|\\.)+:)(.*?)$`, ByGroups(Punctuation, Text, NameTag, UsingSelf("inline")), nil}, + {`^( *\.\.)(\s*)(\[.+\])(.*?)$`, ByGroups(Punctuation, Text, NameTag, UsingSelf("inline")), nil}, + {`^( *\.\.)(\s*)(\|.+\|)(\s*)([\w:-]+?)(::)(?:([ \t]*)(.*))`, ByGroups(Punctuation, Text, NameTag, Text, OperatorWord, Punctuation, Text, UsingSelf("inline")), nil}, + {`^ *\.\..*(\n( +.*\n|\n)+)?`, CommentPreproc, nil}, + {`^( *)(:[a-zA-Z-]+:)(\s*)$`, ByGroups(Text, NameClass, Text), nil}, + {`^( *)(:.*?:)([ \t]+)(.*?)$`, ByGroups(Text, NameClass, Text, NameFunction), nil}, + {`^(\S.*(?<!::)\n)((?:(?: +.*)\n)+)`, ByGroups(UsingSelf("inline"), UsingSelf("inline")), nil}, + {`(::)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\3.*|)\n)+)`, ByGroups(LiteralStringEscape, Text, LiteralString, LiteralString, Text, LiteralString), nil}, + Include("inline"), + }, + "inline": { + {`\\.`, Text, nil}, + {"``", LiteralString, Push("literal")}, + {"(`.+?)(<.+?>)(`__?)", ByGroups(LiteralString, LiteralStringInterpol, LiteralString), nil}, + {"`.+?`__?", LiteralString, nil}, + {"(`.+?`)(:[a-zA-Z0-9:-]+?:)?", ByGroups(NameVariable, NameAttribute), nil}, + {"(:[a-zA-Z0-9:-]+?:)(`.+?`)", ByGroups(NameAttribute, NameVariable), nil}, + {`\*\*.+?\*\*`, GenericStrong, nil}, + {`\*.+?\*`, GenericEmph, nil}, + {`\[.*?\]_`, LiteralString, nil}, + {`<.+?>`, NameTag, nil}, + {"[^\\\\\\n\\[*`:]+", Text, nil}, + {`.`, Text, nil}, + }, + "literal": { + {"[^`]+", LiteralString, nil}, + {"``((?=$)|(?=[-/:.,; \\n\\x00\\\u2010\\\u2011\\\u2012\\\u2013\\\u2014\\\u00a0\\'\\\"\\)\\]\\}\\>\\\u2019\\\u201d\\\u00bb\\!\\?]))", LiteralString, Pop(1)}, + {"`", LiteralString, nil}, + }, + } +} + +func rstCodeBlock(groups []string, state *LexerState) Iterator { + iterators := []Iterator{} + tokens := []Token{ + {Punctuation, groups[1]}, + {Text, groups[2]}, + {OperatorWord, groups[3]}, + {Punctuation, groups[4]}, + {Text, groups[5]}, + {Keyword, groups[6]}, + {Text, groups[7]}, + } + code := strings.Join(groups[8:], "") + lexer := Get(groups[6]) + if lexer == nil { + tokens = append(tokens, Token{String, code}) + iterators = append(iterators, Literator(tokens...)) + } else { + sub, err := lexer.Tokenise(nil, code) + if err != nil { + panic(err) + } + iterators = append(iterators, Literator(tokens...), sub) + } + return Concaterator(iterators...) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/smarty.go b/vendor/github.com/alecthomas/chroma/v2/lexers/smarty.go new file mode 100644 index 0000000..38e0245 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/smarty.go @@ -0,0 +1,42 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Smarty lexer. +var Smarty = Register(MustNewLexer( + &Config{ + Name: "Smarty", + Aliases: []string{"smarty"}, + Filenames: []string{"*.tpl"}, + MimeTypes: []string{"application/x-smarty"}, + DotAll: true, + }, + smartyRules, +)) + +func smartyRules() Rules { + return Rules{ + "root": { + {`[^{]+`, Other, nil}, + {`(\{)(\*.*?\*)(\})`, ByGroups(CommentPreproc, Comment, CommentPreproc), nil}, + {`(\{php\})(.*?)(\{/php\})`, ByGroups(CommentPreproc, Using("PHP"), CommentPreproc), nil}, + {`(\{)(/?[a-zA-Z_]\w*)(\s*)`, ByGroups(CommentPreproc, NameFunction, Text), Push("smarty")}, + {`\{`, CommentPreproc, Push("smarty")}, + }, + "smarty": { + {`\s+`, Text, nil}, + {`\{`, CommentPreproc, Push()}, + {`\}`, CommentPreproc, Pop(1)}, + {`#[a-zA-Z_]\w*#`, NameVariable, nil}, + {`\$[a-zA-Z_]\w*(\.\w+)*`, NameVariable, nil}, + {`[~!%^&*()+=|\[\]:;,.<>/?@-]`, Operator, nil}, + {`(true|false|null)\b`, KeywordConstant, nil}, + {`[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, + {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, + {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, + {`[a-zA-Z_]\w*`, NameAttribute, nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/svelte.go b/vendor/github.com/alecthomas/chroma/v2/lexers/svelte.go new file mode 100644 index 0000000..39211c4 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/svelte.go @@ -0,0 +1,70 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Svelte lexer. +var Svelte = Register(DelegatingLexer(HTML, MustNewLexer( + &Config{ + Name: "Svelte", + Aliases: []string{"svelte"}, + Filenames: []string{"*.svelte"}, + MimeTypes: []string{"application/x-svelte"}, + DotAll: true, + }, + svelteRules, +))) + +func svelteRules() Rules { + return Rules{ + "root": { + // Let HTML handle the comments, including comments containing script and style tags + {`<!--`, Other, Push("comment")}, + { + // Highlight script and style tags based on lang attribute + // and allow attributes besides lang + `(<\s*(?:script|style).*?lang\s*=\s*['"])` + + `(.+?)(['"].*?>)` + + `(.+?)` + + `(<\s*/\s*(?:script|style)\s*>)`, + UsingByGroup(2, 4, Other, Other, Other, Other, Other), + nil, + }, + { + // Make sure `{` is not inside script or style tags + `(?<!<\s*(?:script|style)(?:(?!(?:script|style)\s*>).)*?)` + + `{` + + `(?!(?:(?!<\s*(?:script|style)).)*?(?:script|style)\s*>)`, + Punctuation, + Push("templates"), + }, + // on:submit|preventDefault + {`(?<=\s+on:\w+(?:\|\w+)*)\|(?=\w+)`, Operator, nil}, + {`.+?`, Other, nil}, + }, + "comment": { + {`-->`, Other, Pop(1)}, + {`.+?`, Other, nil}, + }, + "templates": { + {`}`, Punctuation, Pop(1)}, + // Let TypeScript handle strings and the curly braces inside them + {`(?<!(?<!\\)\\)(['"` + "`])" + `.*?(?<!(?<!\\)\\)\1`, Using("TypeScript"), nil}, + // If there is another opening curly brace push to templates again + {"{", Punctuation, Push("templates")}, + {`@(debug|html)\b`, Keyword, nil}, + { + `(#await)(\s+)(\w+)(\s+)(then|catch)(\s+)(\w+)`, + ByGroups(Keyword, Text, Using("TypeScript"), Text, + Keyword, Text, Using("TypeScript"), + ), + nil, + }, + {`(#|/)(await|each|if|key)\b`, Keyword, nil}, + {`(:else)(\s+)(if)?\b`, ByGroups(Keyword, Text, Keyword), nil}, + {`:(catch|then)\b`, Keyword, nil}, + {`[^{}]+`, Using("TypeScript"), nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/typoscript.go b/vendor/github.com/alecthomas/chroma/v2/lexers/typoscript.go new file mode 100644 index 0000000..102d995 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/typoscript.go @@ -0,0 +1,85 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Typoscript lexer. +var Typoscript = Register(MustNewLexer( + &Config{ + Name: "TypoScript", + Aliases: []string{"typoscript"}, + Filenames: []string{"*.ts"}, + MimeTypes: []string{"text/x-typoscript"}, + DotAll: true, + Priority: 0.1, + }, + typoscriptRules, +)) + +func typoscriptRules() Rules { + return Rules{ + "root": { + Include("comment"), + Include("constant"), + Include("html"), + Include("label"), + Include("whitespace"), + Include("keywords"), + Include("punctuation"), + Include("operator"), + Include("structure"), + Include("literal"), + Include("other"), + }, + "keywords": { + {`(\[)(?i)(browser|compatVersion|dayofmonth|dayofweek|dayofyear|device|ELSE|END|GLOBAL|globalString|globalVar|hostname|hour|IP|language|loginUser|loginuser|minute|month|page|PIDinRootline|PIDupinRootline|system|treeLevel|useragent|userFunc|usergroup|version)([^\]]*)(\])`, ByGroups(LiteralStringSymbol, NameConstant, Text, LiteralStringSymbol), nil}, + {`(?=[\w\-])(HTMLparser|HTMLparser_tags|addParams|cache|encapsLines|filelink|if|imageLinkWrap|imgResource|makelinks|numRows|numberFormat|parseFunc|replacement|round|select|split|stdWrap|strPad|tableStyle|tags|textStyle|typolink)(?![\w\-])`, NameFunction, nil}, + {`(?:(=?\s*<?\s+|^\s*))(cObj|field|config|content|constants|FEData|file|frameset|includeLibs|lib|page|plugin|register|resources|sitemap|sitetitle|styles|temp|tt_[^:.\s]*|types|xmlnews|INCLUDE_TYPOSCRIPT|_CSS_DEFAULT_STYLE|_DEFAULT_PI_VARS|_LOCAL_LANG)(?![\w\-])`, ByGroups(Operator, NameBuiltin), nil}, + {`(?=[\w\-])(CASE|CLEARGIF|COA|COA_INT|COBJ_ARRAY|COLUMNS|CONTENT|CTABLE|EDITPANEL|FILE|FILES|FLUIDTEMPLATE|FORM|HMENU|HRULER|HTML|IMAGE|IMGTEXT|IMG_RESOURCE|LOAD_REGISTER|MEDIA|MULTIMEDIA|OTABLE|PAGE|QTOBJECT|RECORDS|RESTORE_REGISTER|SEARCHRESULT|SVG|SWFOBJECT|TEMPLATE|TEXT|USER|USER_INT)(?![\w\-])`, NameClass, nil}, + {`(?=[\w\-])(ACTIFSUBRO|ACTIFSUB|ACTRO|ACT|CURIFSUBRO|CURIFSUB|CURRO|CUR|IFSUBRO|IFSUB|NO|SPC|USERDEF1RO|USERDEF1|USERDEF2RO|USERDEF2|USRRO|USR)`, NameClass, nil}, + {`(?=[\w\-])(GMENU_FOLDOUT|GMENU_LAYERS|GMENU|IMGMENUITEM|IMGMENU|JSMENUITEM|JSMENU|TMENUITEM|TMENU_LAYERS|TMENU)`, NameClass, nil}, + {`(?=[\w\-])(PHP_SCRIPT(_EXT|_INT)?)`, NameClass, nil}, + {`(?=[\w\-])(userFunc)(?![\w\-])`, NameFunction, nil}, + }, + "whitespace": { + {`\s+`, Text, nil}, + }, + "html": { + {`<\S[^\n>]*>`, Using("TypoScriptHTMLData"), nil}, + {`&[^;\n]*;`, LiteralString, nil}, + {`(_CSS_DEFAULT_STYLE)(\s*)(\()(?s)(.*(?=\n\)))`, ByGroups(NameClass, Text, LiteralStringSymbol, Using("TypoScriptCSSData")), nil}, + }, + "literal": { + {`0x[0-9A-Fa-f]+t?`, LiteralNumberHex, nil}, + {`[0-9]+`, LiteralNumberInteger, nil}, + {`(###\w+###)`, NameConstant, nil}, + }, + "label": { + {`(EXT|FILE|LLL):[^}\n"]*`, LiteralString, nil}, + {`(?![^\w\-])([\w\-]+(?:/[\w\-]+)+/?)(\S*\n)`, ByGroups(LiteralString, LiteralString), nil}, + }, + "punctuation": { + {`[,.]`, Punctuation, nil}, + }, + "operator": { + {`[<>,:=.*%+|]`, Operator, nil}, + }, + "structure": { + {`[{}()\[\]\\]`, LiteralStringSymbol, nil}, + }, + "constant": { + {`(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})`, ByGroups(LiteralStringSymbol, Operator, NameConstant, NameConstant, LiteralStringSymbol), nil}, + {`(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})`, ByGroups(LiteralStringSymbol, NameConstant, Operator, NameConstant, LiteralStringSymbol), nil}, + {`(#[a-fA-F0-9]{6}\b|#[a-fA-F0-9]{3}\b)`, LiteralStringChar, nil}, + }, + "comment": { + {`(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)`, Comment, nil}, + {`/\*(?:(?!\*/).)*\*/`, Comment, nil}, + {`(\s*#\s*\n)`, Comment, nil}, + }, + "other": { + {`[\w"\-!/&;]+`, Text, nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/v.go b/vendor/github.com/alecthomas/chroma/v2/lexers/v.go new file mode 100644 index 0000000..11561b3 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/v.go @@ -0,0 +1,173 @@ +package lexers + +import ( + "strings" + + . "github.com/alecthomas/chroma/v2" // nolint +) + +// V lexer. +var V = Register(MustNewLexer( + &Config{ + Name: "V", + Aliases: []string{"v", "vlang"}, + Filenames: []string{"*.v", "*.vv", "v.mod"}, + MimeTypes: []string{"text/x-v"}, + EnsureNL: true, + }, + vRules, +).SetAnalyser(func(text string) float32 { + if strings.Contains(text, "import ") && strings.Contains(text, "module ") { + return 0.2 + } + if strings.Contains(text, "module ") { + return 0.1 + } + return 0.0 +})) + +const ( + namePattern = `[^\W\d]\w*` + typeNamePattern = `[A-Z]\w*` + multiLineCommentPattern = `/\*(?:.|\n)*?\*/` +) + +func vRules() Rules { + return Rules{ + "root": { + {`\n`, Text, nil}, + {`\s+`, Text, nil}, + {`\\\n`, Text, nil}, + {`(?<=module\s+\w[^\n]*\s+)(//[^\n]+\n)+(?=\n)`, StringDoc, nil}, + {`(// *)(\w+)([^\n]+\n)(?=(?://[^\n]*\n)* *(?:pub +)?(?:fn|struct|union|type|interface|enum|const) +\2\b)`, ByGroups(StringDoc, GenericEmph, StringDoc), Push(`string-doc`)}, + {`//[^\n]*\n`, CommentSingle, nil}, + {`/\*(?:(?:` + multiLineCommentPattern + `)*|.|\n)*\*/`, CommentMultiline, nil}, + {`\b(import|module)\b`, KeywordNamespace, nil}, + {`\b(fn|struct|union|map|chan|type|interface|enum|const|mut|shared|pub|__global)\b`, KeywordDeclaration, nil}, + {`\?`, KeywordDeclaration, nil}, + {`(?<=\)\s*)!`, KeywordDeclaration, nil}, + {`[ \t]*#include[^\n]+`, Using(`c`), nil}, + {`[ \t]*#\w[^\n]*`, CommentPreproc, nil}, + {`(sql)(\s+)(\w+)(\s+)({)([^}]*?)(})`, ByGroups(Keyword, Text, Name, Text, Punctuation, Using(`sql`), Punctuation), nil}, + {`\$(?=\w)`, Operator, nil}, + {`(?<=\$)(?:embed_file|pkgconfig|tmpl|env|compile_error|compile_warn)`, NameBuiltin, nil}, + {`(asm)(\s+)(\w+)(\s*)({)([^}]*?)(})`, ByGroups(Keyword, Text, KeywordType, Text, Punctuation, Using(`nasm`), Punctuation), nil}, + {`\b_(?:un)?likely_(?=\()`, NameFunctionMagic, nil}, + {`(?<=\$if.+?(?:&&|\|\|)?)(` + Words(``, ``, `windows`, `linux`, `macos`, `mac`, `darwin`, `ios`, `android`, `mach`, `dragonfly`, `gnu`, `hpux`, `haiku`, `qnx`, `solaris`, `gcc`, `tinyc`, `clang`, `mingw`, `msvc`, `cplusplus`, `amd64`, `arm64`, `x64`, `x32`, `little_endian`, `big_endian`, `debug`, `prod`, `test`, `js`, `glibc`, `prealloc`, `no_bounds_checking`, `freestanding`, `no_segfault_handler`, `no_backtrace`, `no_main`) + `)+`, NameBuiltin, nil}, + {`@` + Words(``, `\b`, `FN`, `METHOD`, `MOD`, `STRUCT`, `FILE`, `LINE`, `COLUMN`, `VEXE`, `VEXEROOT`, `VHASH`, `VMOD_FILE`, `VMODROOT`), NameVariableMagic, nil}, + {Words(`\b(?<!@)`, `\b`, `break`, `select`, `match`, `defer`, `go`, `goto`, `else`, `if`, `continue`, `for`, `return`, `assert`, `or`, `as`, `atomic`, `isreftype`, `is`, `in`, `lock`, `rlock`, `sizeof`, `typeof`, `unsafe`, `volatile`, `static`, `__offsetof`), Keyword, nil}, + {`\b(?<!@)(none|true|false|si_s_code|si_g32_code|si_g64_code)\b`, KeywordConstant, nil}, + {Words(`\b(?<!@)`, `(?=\()`, `u8`, `u16`, `u32`, `u64`, `u128`, `int`, `i8`, `i16`, `i64`, `i128`, `f32`, `f64`, `rune`, `string`, `bool`, `usize`, `isize`, `any`, `error`, `print`, `println`, `dump`, `panic`, `eprint`, `eprintln`, `copy`, `close`, `len`, `map`, `filter`, `cap`, `delete`, `delete_many`, `delete_last`, `c_error_number_str`, `compare_strings`, `cstring_to_vstring`, `error_with_code`, `exit`, `f32_abs`, `f32_max`, `f32_min`, `f64_max`, `flush_stderr`, `flush_stdout`, `free`, `gc_check_leaks`, `get_str_intp_u32_format`, `get_str_intp_u64_format`, `isnil`, `malloc`, `malloc_noscan`, `memdup`, `memdup_noscan`, `panic_error_number`, `panic_lasterr`, `panic_optional_not_set`, `panic_result_not_set`, `print_backtrace`, `proc_pidpath`, `ptr_str`, `realloc_data`, `str_intp`, `str_intp_g32`, `str_intp_g64`, `str_intp_rune`, `str_intp_sq`, `str_intp_sub`, `string_from_wide`, `string_from_wide2`, `tos`, `tos2`, `tos3`, `tos4`, `tos5`, `tos_clone`, `utf32_decode_to_buffer`, `utf32_to_str`, `utf32_to_str_no_malloc`, `utf8_char_len`, `utf8_getchar`, `utf8_str_visible_length`, `v_realloc`, `vcalloc`, `vcalloc_noscan`, `vmemcmp`, `vmemcpy`, `vmemmove`, `vmemset`, `vstrlen`, `vstrlen_char`, `winapi_lasterr_str`, `reduce`, `string`, `join`, `free`, `join_lines`, `sort_by_len`, `sort_ignore_case`, `str`, `byterune`, `bytestr`, `clone`, `hex`, `utf8_to_utf32`, `vbytes`, `vstring`, `vstring_literal`, `vstring_literal_with_len`, `vstring_with_len`, `try_pop`, `try_push`, `strg`, `strsci`, `strlong`, `eq_epsilon`, `hex_full`, `hex2`, `msg`, `code`, `repeat`, `bytes`, `length_in_bytes`, `ascii_str`, `is_alnum`, `is_bin_digit`, `is_capital`, `is_digit`, `is_hex_digit`, `is_letter`, `is_oct_digit`, `is_space`, `str_escaped`, `repeat_to_depth`, `insert`, `prepend`, `trim`, `drop`, `first`, `last`, `pop`, `clone_to_depth`, `push_many`, `reverse_in_place`, `reverse`, `any`, `all`, `sort`, `sort_with_compare`, `contains`, `index`, `grow_cap`, `grow_len`, `pointers`, `move`, `keys`, `after`, `after_char`, `all_after`, `all_after_last`, `all_before`, `all_before_last`, `before`, `capitalize`, `compare`, `contains_any`, `contains_any_substr`, `count`, `ends_with`, `fields`, `find_between`, `hash`, `index_after`, `index_any`, `index_u8`, `is_lower`, `is_title`, `is_upper`, `last_index`, `last_index_u8`, `len_utf8`, `limit`, `match_glob`, `parse_int`, `parse_uint`, `replace`, `replace_each`, `replace_once`, `runes`, `split`, `split_any`, `split_into_lines`, `split_nth`, `starts_with`, `starts_with_capital`, `strip_margin`, `strip_margin_custom`, `substr`, `substr_ni`, `substr_with_check`, `title`, `to_lower`, `to_upper`, `to_wide`, `trim_left`, `trim_right`, `trim_space`, `trim_string_left`, `trim_string_right`, `utf32_code`), NameBuiltin, nil}, + {Words(`\b(?<!@)`, `\b`, `ArrayFlags`, `AttributeKind`, `ChanState`, `StrIntpType`, `array`, `Error`, `FieldData`, `FunctionData`, `map`, `MethodArgs`, `SortedMap`, `string`, `StrIntpCgenData`, `StrIntpData`, `StrIntpMem`, `StructAttribute`, `VAssertMetaInfo`), NameBuiltin, nil}, + {Words(`\b(?<!@)`, `\b`, `u8`, `u16`, `u32`, `u64`, `u128`, `int`, `i8`, `i16`, `i64`, `i128`, `f32`, `f64`, `rune`, `string`, `bool`, `usize`, `isize`, `any`, `error`, `voidptr`), KeywordType, nil}, + {`\bit\b`, NameVariableMagic, nil}, + {`(?<!fn\s+)(?<=\w+\s+|^)\[(?=:if +)?(?=\w+)`, Punctuation, Push(`attribute`)}, + {`(<<=|>>=|>>>=|>>>|<<|>>|<=|>=|\^=|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\||<-|\+\+|--|==|!=|:=|\.\.\.|\.\.|[+\-*/%&|^~=#@!])`, Operator, nil}, + {`[\d_]+(\.\d+e[+\-]?\d+|\.\d+|e[+\-]?\d+)`, LiteralNumberFloat, nil}, + {`\.\d+(e[+\-]?\d+)?`, LiteralNumberFloat, nil}, + {`0o[0-7_]+`, LiteralNumberOct, nil}, + {`0x[0-9a-fA-F_]+`, LiteralNumberHex, nil}, + {`0b[01_]+`, LiteralNumberBin, nil}, + {`(0|[1-9][0-9_]*)`, LiteralNumberInteger, nil}, + {"`", StringChar, Push(`char`)}, + Include(`strings`), + {`@?` + typeNamePattern, NameClass, nil}, + {`(?<=` + namePattern + `)(<)(` + typeNamePattern + `)(>)`, ByGroups(Punctuation, NameClass, Punctuation), nil}, + {`@?` + namePattern + `(?=\()`, NameFunction, nil}, + {`(?<=fn\s+)@?` + namePattern + `(?=\s*\()`, NameFunction, nil}, + {`(?<=(?:continue|break|goto)\s+)\w+`, NameLabel, nil}, + {`\b` + namePattern + `(?=:(?:$|\s+for))`, NameLabel, nil}, + {`[<>()\[\]{}.,;:]`, Punctuation, nil}, + {`@?` + namePattern, NameVariable, nil}, + }, + "strings": { + {`(c)?(")`, ByGroups(StringAffix, StringDouble), Push(`string-double`)}, + {`(c)?(')`, ByGroups(StringAffix, StringSingle), Push(`string-single`)}, + {`(r)("[^"]+")`, ByGroups(StringAffix, String), nil}, + {`(r)('[^']+')`, ByGroups(StringAffix, String), nil}, + }, + "string-double": { + {`"`, StringDouble, Pop(1)}, + Include(`char-escape`), + {`(\$)((?!\\){)`, ByGroups(Operator, Punctuation), Push(`string-curly-interpolation`)}, + {`\$`, Operator, Push(`string-interpolation`)}, + {`[^"]+?`, StringDouble, nil}, + }, + "string-single": { + {`'`, StringSingle, Pop(1)}, + Include(`char-escape`), + {`(\$)((?!\\){)`, ByGroups(Operator, Punctuation), Push(`string-curly-interpolation`)}, + {`\$`, Operator, Push(`string-interpolation`)}, + {`[^']+?`, StringSingle, nil}, + }, + "char": { + {"`", StringChar, Pop(1)}, + Include(`char-escape`), + {`[^\\]`, StringChar, nil}, + }, + "char-escape": { + {"\\\\[`'\"\\\\abfnrtv$]|\\\\x[0-9a-fA-F]{2}|\\\\[0-7]{1,3}|\\\\u[0-9a-fA-F]{4}|\\\\U[0-9a-fA-F]{8}", StringEscape, nil}, + }, + "string-doc": { + {`(// *)(#+ [^\n]+)(\n)`, ByGroups(StringDoc, GenericHeading, Text), nil}, + {`// *([=_*~-])\1{2,}\n`, StringDelimiter, nil}, + {`//[^\n]*\n`, StringDoc, nil}, + Default(Pop(1)), + }, + "string-interpolation": { + {`(\.)?(@)?(?:(` + namePattern + `)(\()([^)]*)(\))|(` + namePattern + `))`, ByGroups(Punctuation, Operator, NameFunction, Punctuation, UsingSelf(`root`), Punctuation, NameVariable), nil}, + Default(Pop(1)), + }, + "string-curly-interpolation": { + {`}`, Punctuation, Pop(1)}, + Include(`strings`), + {`(:)( *?)([ 0'#+-])?(?:(\.)?([0-9]+))?([fFgeEGxXobsd])?`, ByGroups(Punctuation, Text, Operator, Punctuation, Number, StringAffix), nil}, + {`[^}"':]+`, UsingSelf(`root`), nil}, + }, + "attribute": { + {`\]`, Punctuation, Pop(1)}, + {`'`, Punctuation, Push(`string-single`)}, + {`"`, Punctuation, Push(`string-double`)}, + {`[;:]`, Punctuation, nil}, + {`(?<=\[)if\b`, Keyword, nil}, + {`\s+`, Text, nil}, + {`(?<=: *)\w+`, String, nil}, + {namePattern, NameAttribute, nil}, + }, + } +} + +// V shell lexer. +var VSH = Register(MustNewLexer( + &Config{ + Name: "V shell", + Aliases: []string{"vsh", "vshell"}, + Filenames: []string{"*.vsh"}, + MimeTypes: []string{"text/x-vsh"}, + EnsureNL: true, + }, + vshRules, +).SetAnalyser(func(text string) float32 { + firstLine := strings.Split(text, "\n")[0] + if strings.Contains(firstLine, "#!/usr/bin/env") && strings.Contains(firstLine, "v run") { + return 1.0 + } + if strings.Contains(firstLine, "#!/") && strings.Contains(firstLine, "/v run") { + return 1.0 + } + return 0.0 +})) + +func vshRules() Rules { + vshRules := vRules() + vshRoot := []Rule{ + {`^#![^\n]*\n`, CommentHashbang, nil}, + {Words(`\b`, `\b`, `args`, `max_path_len`, `wd_at_startup`, `sys_write`, `sys_open`, `sys_close`, `sys_mkdir`, `sys_creat`, `path_separator`, `path_delimiter`, `s_ifmt`, `s_ifdir`, `s_iflnk`, `s_isuid`, `s_isgid`, `s_isvtx`, `s_irusr`, `s_iwusr`, `s_ixusr`, `s_irgrp`, `s_iwgrp`, `s_ixgrp`, `s_iroth`, `s_iwoth`, `s_ixoth`), NameConstant, nil}, + {Words(`\b`, `\b`, `ProcessState`, `SeekMode`, `Signal`, `Command`, `ExecutableNotFoundError`, `File`, `FileNotOpenedError`, `Process`, `Result`, `SizeOfTypeIs0Error`, `Uname`), NameBuiltin, nil}, + {Words(`\b`, `(?=\()`, `abs_path`, `args_after`, `args_before`, `base`, `cache_dir`, `chdir`, `chmod`, `chown`, `config_dir`, `cp`, `cp_all`, `create`, `debugger_present`, `dir`, `environ`, `executable`, `execute`, `execute_or_exit`, `execute_or_panic`, `execve`, `execvp`, `existing_path`, `exists`, `exists_in_system_path`, `expand_tilde_to_home`, `fd_close`, `fd_read`, `fd_slurp`, `fd_write`, `file_ext`, `file_last_mod_unix`, `file_name`, `file_size`, `fileno`, `find_abs_path_of_executable`, `flush`, `fork`, `get_error_msg`, `get_line`, `get_lines`, `get_lines_joined`, `get_raw_line`, `get_raw_lines_joined`, `get_raw_stdin`, `getegid`, `getenv`, `getenv_opt`, `geteuid`, `getgid`, `getpid`, `getppid`, `getuid`, `getwd`, `glob`, `home_dir`, `hostname`, `inode`, `input`, `input_opt`, `is_abs_path`, `is_atty`, `is_dir`, `is_dir_empty`, `is_executable`, `is_file`, `is_link`, `is_readable`, `is_writable`, `is_writable_folder`, `join_path`, `join_path_single`, `last_error`, `link`, `log`, `loginname`, `ls`, `mkdir`, `mkdir_all`, `mv`, `mv_by_cp`, `new_process`, `norm_path`, `open`, `open_append`, `open_file`, `open_uri`, `posix_get_error_msg`, `posix_set_permission_bit`, `quoted_path`, `read_bytes`, `read_file`, `read_file_array`, `read_lines`, `real_path`, `resource_abs_path`, `rm`, `rmdir`, `rmdir_all`, `setenv`, `sigint_to_signal_name`, `signal_opt`, `stderr`, `stdin`, `stdout`, `symlink`, `system`, `temp_dir`, `truncate`, `uname`, `unsetenv`, `user_os`, `utime`, `vfopen`, `vmodules_dir`, `vmodules_paths`, `wait`, `walk`, `walk_ext`, `walk_with_context`, `write_file`, `write_file_array`, `bitmask`, `close`, `read_line`, `start`, `msg`, `read`, `read_bytes_at`, `read_bytes_into`, `read_bytes_into_newline`, `read_from`, `read_into_ptr`, `read_raw`, `read_raw_at`, `read_struct`, `read_struct_at`, `seek`, `tell`, `write`, `write_raw`, `write_raw_at`, `write_string`, `write_struct`, `write_struct_at`, `write_to`, `writeln`, `is_alive`, `run`, `set_args`, `set_environment`, `set_redirect_stdio`, `signal_continue`, `signal_kill`, `signal_pgkill`, `signal_stop`, `stderr_read`, `stderr_slurp`, `stdin_write`, `stdout_read`, `stdout_slurp`), NameBuiltin, nil}, + } + + vshRules[`root`] = append(vshRoot, vshRules[`root`]...) + + return vshRules +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/vim.go b/vendor/github.com/alecthomas/chroma/v2/lexers/vim.go new file mode 100644 index 0000000..b0059ea --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/vim.go @@ -0,0 +1,39 @@ +package lexers + +import ( + . "github.com/alecthomas/chroma/v2" // nolint +) + +// Viml lexer. +var Viml = Register(MustNewLexer( + &Config{ + Name: "VimL", + Aliases: []string{"vim"}, + Filenames: []string{"*.vim", ".vimrc", ".exrc", ".gvimrc", "_vimrc", "_exrc", "_gvimrc", "vimrc", "gvimrc"}, + MimeTypes: []string{"text/x-vim"}, + }, + vimlRules, +)) + +func vimlRules() Rules { + return Rules{ + "root": { + {`^([ \t:]*)(py(?:t(?:h(?:o(?:n)?)?)?)?)([ \t]*)(<<)([ \t]*)(.*)((?:\n|.)*)(\6)`, ByGroups(UsingSelf("root"), Keyword, Text, Operator, Text, Text, Using("Python"), Text), nil}, + {`^([ \t:]*)(py(?:t(?:h(?:o(?:n)?)?)?)?)([ \t])(.*)`, ByGroups(UsingSelf("root"), Keyword, Text, Using("Python")), nil}, + {`^\s*".*`, Comment, nil}, + {`[ \t]+`, Text, nil}, + {`/(\\\\|\\/|[^\n/])*/`, LiteralStringRegex, nil}, + {`"(\\\\|\\"|[^\n"])*"`, LiteralStringDouble, nil}, + {`'(''|[^\n'])*'`, LiteralStringSingle, nil}, + {`(?<=\s)"[^\-:.%#=*].*`, Comment, nil}, + {`-?\d+`, LiteralNumber, nil}, + {`#[0-9a-f]{6}`, LiteralNumberHex, nil}, + {`^:`, Punctuation, nil}, + {`[()<>+=!|,~-]`, Punctuation, nil}, + {`\b(let|if|else|endif|elseif|fun|function|endfunction)\b`, Keyword, nil}, + {`\b(NONE|bold|italic|underline|dark|light)\b`, NameBuiltin, nil}, + {`\b\w+\b`, NameOther, nil}, + {`.`, Text, nil}, + }, + } +} diff --git a/vendor/github.com/alecthomas/chroma/v2/lexers/zed.go b/vendor/github.com/alecthomas/chroma/v2/lexers/zed.go new file mode 100644 index 0000000..aadc80f --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/lexers/zed.go @@ -0,0 +1,24 @@ +package lexers + +import ( + "strings" +) + +// Zed lexer. +func init() { // nolint: gochecknoinits + Get("Zed").SetAnalyser(func(text string) float32 { + if strings.Contains(text, "definition ") && strings.Contains(text, "relation ") && strings.Contains(text, "permission ") { + return 0.9 + } + if strings.Contains(text, "definition ") { + return 0.5 + } + if strings.Contains(text, "relation ") { + return 0.5 + } + if strings.Contains(text, "permission ") { + return 0.25 + } + return 0.0 + }) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/mutators.go b/vendor/github.com/alecthomas/chroma/v2/mutators.go new file mode 100644 index 0000000..ae648aa --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/mutators.go @@ -0,0 +1,201 @@ +package chroma + +import ( + "encoding/xml" + "fmt" + "strings" +) + +// A Mutator modifies the behaviour of the lexer. +type Mutator interface { + // Mutate the lexer state machine as it is processing. + Mutate(state *LexerState) error +} + +// SerialisableMutator is a Mutator that can be serialised and deserialised. +type SerialisableMutator interface { + Mutator + MutatorKind() string +} + +// A LexerMutator is an additional interface that a Mutator can implement +// to modify the lexer when it is compiled. +type LexerMutator interface { + // MutateLexer can be implemented to mutate the lexer itself. + // + // Rules are the lexer rules, state is the state key for the rule the mutator is associated with. + MutateLexer(rules CompiledRules, state string, rule int) error +} + +// A MutatorFunc is a Mutator that mutates the lexer state machine as it is processing. +type MutatorFunc func(state *LexerState) error + +func (m MutatorFunc) Mutate(state *LexerState) error { return m(state) } // nolint + +type multiMutator struct { + Mutators []Mutator `xml:"mutator"` +} + +func (m *multiMutator) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + for { + token, err := d.Token() + if err != nil { + return err + } + switch token := token.(type) { + case xml.StartElement: + mutator, err := unmarshalMutator(d, token) + if err != nil { + return err + } + m.Mutators = append(m.Mutators, mutator) + + case xml.EndElement: + return nil + } + } +} + +func (m *multiMutator) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + name := xml.Name{Local: "mutators"} + if err := e.EncodeToken(xml.StartElement{Name: name}); err != nil { + return err + } + for _, m := range m.Mutators { + if err := marshalMutator(e, m); err != nil { + return err + } + } + return e.EncodeToken(xml.EndElement{Name: name}) +} + +func (m *multiMutator) MutatorKind() string { return "multiple" } + +func (m *multiMutator) Mutate(state *LexerState) error { + for _, modifier := range m.Mutators { + if err := modifier.Mutate(state); err != nil { + return err + } + } + return nil +} + +// Mutators applies a set of Mutators in order. +func Mutators(modifiers ...Mutator) Mutator { + return &multiMutator{modifiers} +} + +type includeMutator struct { + State string `xml:"state,attr"` +} + +// Include the given state. +func Include(state string) Rule { + return Rule{Mutator: &includeMutator{state}} +} + +func (i *includeMutator) MutatorKind() string { return "include" } + +func (i *includeMutator) Mutate(s *LexerState) error { + return fmt.Errorf("should never reach here Include(%q)", i.State) +} + +func (i *includeMutator) MutateLexer(rules CompiledRules, state string, rule int) error { + includedRules, ok := rules[i.State] + if !ok { + return fmt.Errorf("invalid include state %q", i.State) + } + rules[state] = append(rules[state][:rule], append(includedRules, rules[state][rule+1:]...)...) + return nil +} + +type combinedMutator struct { + States []string `xml:"state,attr"` +} + +func (c *combinedMutator) MutatorKind() string { return "combined" } + +// Combined creates a new anonymous state from the given states, and pushes that state. +func Combined(states ...string) Mutator { + return &combinedMutator{states} +} + +func (c *combinedMutator) Mutate(s *LexerState) error { + return fmt.Errorf("should never reach here Combined(%v)", c.States) +} + +func (c *combinedMutator) MutateLexer(rules CompiledRules, state string, rule int) error { + name := "__combined_" + strings.Join(c.States, "__") + if _, ok := rules[name]; !ok { + combined := []*CompiledRule{} + for _, state := range c.States { + rules, ok := rules[state] + if !ok { + return fmt.Errorf("invalid combine state %q", state) + } + combined = append(combined, rules...) + } + rules[name] = combined + } + rules[state][rule].Mutator = Push(name) + return nil +} + +type pushMutator struct { + States []string `xml:"state,attr"` +} + +func (p *pushMutator) MutatorKind() string { return "push" } + +func (p *pushMutator) Mutate(s *LexerState) error { + if len(p.States) == 0 { + s.Stack = append(s.Stack, s.State) + } else { + for _, state := range p.States { + if state == "#pop" { + s.Stack = s.Stack[:len(s.Stack)-1] + } else { + s.Stack = append(s.Stack, state) + } + } + } + return nil +} + +// Push states onto the stack. +func Push(states ...string) Mutator { + return &pushMutator{states} +} + +type popMutator struct { + Depth int `xml:"depth,attr"` +} + +func (p *popMutator) MutatorKind() string { return "pop" } + +func (p *popMutator) Mutate(state *LexerState) error { + if len(state.Stack) == 0 { + return fmt.Errorf("nothing to pop") + } + state.Stack = state.Stack[:len(state.Stack)-p.Depth] + return nil +} + +// Pop state from the stack when rule matches. +func Pop(n int) Mutator { + return &popMutator{n} +} + +// Default returns a Rule that applies a set of Mutators. +func Default(mutators ...Mutator) Rule { + return Rule{Mutator: Mutators(mutators...)} +} + +// Stringify returns the raw string for a set of tokens. +func Stringify(tokens ...Token) string { + out := []string{} + for _, t := range tokens { + out = append(out, t.Value) + } + return strings.Join(out, "") +} diff --git a/vendor/github.com/alecthomas/chroma/v2/pygments-lexers.txt b/vendor/github.com/alecthomas/chroma/v2/pygments-lexers.txt new file mode 100644 index 0000000..bf4d9de --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/pygments-lexers.txt @@ -0,0 +1,322 @@ +Generated with: + + g 'class.*RegexLexer' | pawk --strict -F: '"pygments.lexers.%s.%s" % (f[0].split(".")[0], f[2].split()[1].split("(")[0])' > lexers.txt + +kotlin: + invalid unicode escape sequences + FIXED: Have to disable wide Unicode characters in unistring.py + +pygments.lexers.ambient.AmbientTalkLexer +pygments.lexers.ampl.AmplLexer +pygments.lexers.actionscript.ActionScriptLexer +pygments.lexers.actionscript.ActionScript3Lexer +pygments.lexers.actionscript.MxmlLexer +pygments.lexers.algebra.GAPLexer +pygments.lexers.algebra.MathematicaLexer +pygments.lexers.algebra.MuPADLexer +pygments.lexers.algebra.BCLexer +pygments.lexers.apl.APLLexer +pygments.lexers.bibtex.BibTeXLexer +pygments.lexers.bibtex.BSTLexer +pygments.lexers.basic.BlitzMaxLexer +pygments.lexers.basic.BlitzBasicLexer +pygments.lexers.basic.MonkeyLexer +pygments.lexers.basic.CbmBasicV2Lexer +pygments.lexers.basic.QBasicLexer +pygments.lexers.automation.AutohotkeyLexer +pygments.lexers.automation.AutoItLexer +pygments.lexers.archetype.AtomsLexer +pygments.lexers.c_like.ClayLexer +pygments.lexers.c_like.ValaLexer +pygments.lexers.asm.GasLexer +pygments.lexers.asm.ObjdumpLexer +pygments.lexers.asm.HsailLexer +pygments.lexers.asm.LlvmLexer +pygments.lexers.asm.NasmLexer +pygments.lexers.asm.TasmLexer +pygments.lexers.asm.Ca65Lexer +pygments.lexers.business.CobolLexer +pygments.lexers.business.ABAPLexer +pygments.lexers.business.OpenEdgeLexer +pygments.lexers.business.GoodDataCLLexer +pygments.lexers.business.MaqlLexer +pygments.lexers.capnproto.CapnProtoLexer +pygments.lexers.chapel.ChapelLexer +pygments.lexers.clean.CleanLexer +pygments.lexers.c_cpp.CFamilyLexer +pygments.lexers.console.VCTreeStatusLexer +pygments.lexers.console.PyPyLogLexer +pygments.lexers.csound.CsoundLexer +pygments.lexers.csound.CsoundDocumentLexer +pygments.lexers.csound.CsoundDocumentLexer +pygments.lexers.crystal.CrystalLexer +pygments.lexers.dalvik.SmaliLexer +pygments.lexers.css.CssLexer +pygments.lexers.css.SassLexer +pygments.lexers.css.ScssLexer +pygments.lexers.configs.IniLexer +pygments.lexers.configs.RegeditLexer +pygments.lexers.configs.PropertiesLexer +pygments.lexers.configs.KconfigLexer +pygments.lexers.configs.Cfengine3Lexer +pygments.lexers.configs.ApacheConfLexer +pygments.lexers.configs.SquidConfLexer +pygments.lexers.configs.NginxConfLexer +pygments.lexers.configs.LighttpdConfLexer +pygments.lexers.configs.DockerLexer +pygments.lexers.configs.TerraformLexer +pygments.lexers.configs.TermcapLexer +pygments.lexers.configs.TerminfoLexer +pygments.lexers.configs.PkgConfigLexer +pygments.lexers.configs.PacmanConfLexer +pygments.lexers.data.YamlLexer +pygments.lexers.data.JsonLexer +pygments.lexers.diff.DiffLexer +pygments.lexers.diff.DarcsPatchLexer +pygments.lexers.diff.WDiffLexer +pygments.lexers.dotnet.CSharpLexer +pygments.lexers.dotnet.NemerleLexer +pygments.lexers.dotnet.BooLexer +pygments.lexers.dotnet.VbNetLexer +pygments.lexers.dotnet.GenericAspxLexer +pygments.lexers.dotnet.FSharpLexer +pygments.lexers.dylan.DylanLexer +pygments.lexers.dylan.DylanLidLexer +pygments.lexers.ecl.ECLLexer +pygments.lexers.eiffel.EiffelLexer +pygments.lexers.dsls.ProtoBufLexer +pygments.lexers.dsls.ThriftLexer +pygments.lexers.dsls.BroLexer +pygments.lexers.dsls.PuppetLexer +pygments.lexers.dsls.RslLexer +pygments.lexers.dsls.MscgenLexer +pygments.lexers.dsls.VGLLexer +pygments.lexers.dsls.AlloyLexer +pygments.lexers.dsls.PanLexer +pygments.lexers.dsls.CrmshLexer +pygments.lexers.dsls.FlatlineLexer +pygments.lexers.dsls.SnowballLexer +pygments.lexers.elm.ElmLexer +pygments.lexers.erlang.ErlangLexer +pygments.lexers.erlang.ElixirLexer +pygments.lexers.ezhil.EzhilLexer +pygments.lexers.esoteric.BrainfuckLexer +pygments.lexers.esoteric.BefungeLexer +pygments.lexers.esoteric.CAmkESLexer +pygments.lexers.esoteric.CapDLLexer +pygments.lexers.esoteric.RedcodeLexer +pygments.lexers.esoteric.AheuiLexer +pygments.lexers.factor.FactorLexer +pygments.lexers.fantom.FantomLexer +pygments.lexers.felix.FelixLexer +pygments.lexers.forth.ForthLexer +pygments.lexers.fortran.FortranLexer +pygments.lexers.fortran.FortranFixedLexer +pygments.lexers.go.GoLexer +pygments.lexers.foxpro.FoxProLexer +pygments.lexers.graph.CypherLexer +pygments.lexers.grammar_notation.BnfLexer +pygments.lexers.grammar_notation.AbnfLexer +pygments.lexers.grammar_notation.JsgfLexer +pygments.lexers.graphics.GLShaderLexer +pygments.lexers.graphics.PostScriptLexer +pygments.lexers.graphics.AsymptoteLexer +pygments.lexers.graphics.GnuplotLexer +pygments.lexers.graphics.PovrayLexer +pygments.lexers.hexdump.HexdumpLexer +pygments.lexers.haskell.HaskellLexer +pygments.lexers.haskell.IdrisLexer +pygments.lexers.haskell.AgdaLexer +pygments.lexers.haskell.CryptolLexer +pygments.lexers.haskell.KokaLexer +pygments.lexers.haxe.HaxeLexer +pygments.lexers.haxe.HxmlLexer +pygments.lexers.hdl.VerilogLexer +pygments.lexers.hdl.SystemVerilogLexer +pygments.lexers.hdl.VhdlLexer +pygments.lexers.idl.IDLLexer +pygments.lexers.inferno.LimboLexer +pygments.lexers.igor.IgorLexer +pygments.lexers.html.HtmlLexer +pygments.lexers.html.DtdLexer +pygments.lexers.html.XmlLexer +pygments.lexers.html.HamlLexer +pygments.lexers.html.ScamlLexer +pygments.lexers.html.PugLexer +pygments.lexers.installers.NSISLexer +pygments.lexers.installers.RPMSpecLexer +pygments.lexers.installers.SourcesListLexer +pygments.lexers.installers.DebianControlLexer +pygments.lexers.iolang.IoLexer +pygments.lexers.julia.JuliaLexer +pygments.lexers.int_fiction.Inform6Lexer +pygments.lexers.int_fiction.Inform7Lexer +pygments.lexers.int_fiction.Tads3Lexer +pygments.lexers.make.BaseMakefileLexer +pygments.lexers.make.CMakeLexer +pygments.lexers.javascript.JavascriptLexer +pygments.lexers.javascript.KalLexer +pygments.lexers.javascript.LiveScriptLexer +pygments.lexers.javascript.DartLexer +pygments.lexers.javascript.TypeScriptLexer +pygments.lexers.javascript.LassoLexer +pygments.lexers.javascript.ObjectiveJLexer +pygments.lexers.javascript.CoffeeScriptLexer +pygments.lexers.javascript.MaskLexer +pygments.lexers.javascript.EarlGreyLexer +pygments.lexers.javascript.JuttleLexer +pygments.lexers.jvm.JavaLexer +pygments.lexers.jvm.ScalaLexer +pygments.lexers.jvm.GosuLexer +pygments.lexers.jvm.GroovyLexer +pygments.lexers.jvm.IokeLexer +pygments.lexers.jvm.ClojureLexer +pygments.lexers.jvm.TeaLangLexer +pygments.lexers.jvm.CeylonLexer +pygments.lexers.jvm.KotlinLexer +pygments.lexers.jvm.XtendLexer +pygments.lexers.jvm.PigLexer +pygments.lexers.jvm.GoloLexer +pygments.lexers.jvm.JasminLexer +pygments.lexers.markup.BBCodeLexer +pygments.lexers.markup.MoinWikiLexer +pygments.lexers.markup.RstLexer +pygments.lexers.markup.TexLexer +pygments.lexers.markup.GroffLexer +pygments.lexers.markup.MozPreprocHashLexer +pygments.lexers.markup.MarkdownLexer +pygments.lexers.ml.SMLLexer +pygments.lexers.ml.OcamlLexer +pygments.lexers.ml.OpaLexer +pygments.lexers.modeling.ModelicaLexer +pygments.lexers.modeling.BugsLexer +pygments.lexers.modeling.JagsLexer +pygments.lexers.modeling.StanLexer +pygments.lexers.matlab.MatlabLexer +pygments.lexers.matlab.OctaveLexer +pygments.lexers.matlab.ScilabLexer +pygments.lexers.monte.MonteLexer +pygments.lexers.lisp.SchemeLexer +pygments.lexers.lisp.CommonLispLexer +pygments.lexers.lisp.HyLexer +pygments.lexers.lisp.RacketLexer +pygments.lexers.lisp.NewLispLexer +pygments.lexers.lisp.EmacsLispLexer +pygments.lexers.lisp.ShenLexer +pygments.lexers.lisp.XtlangLexer +pygments.lexers.modula2.Modula2Lexer +pygments.lexers.ncl.NCLLexer +pygments.lexers.nim.NimLexer +pygments.lexers.nit.NitLexer +pygments.lexers.nix.NixLexer +pygments.lexers.oberon.ComponentPascalLexer +pygments.lexers.ooc.OocLexer +pygments.lexers.objective.SwiftLexer +pygments.lexers.parasail.ParaSailLexer +pygments.lexers.pawn.SourcePawnLexer +pygments.lexers.pawn.PawnLexer +pygments.lexers.pascal.AdaLexer +pygments.lexers.parsers.RagelLexer +pygments.lexers.parsers.RagelEmbeddedLexer +pygments.lexers.parsers.AntlrLexer +pygments.lexers.parsers.TreetopBaseLexer +pygments.lexers.parsers.EbnfLexer +pygments.lexers.php.ZephirLexer +pygments.lexers.php.PhpLexer +pygments.lexers.perl.PerlLexer +pygments.lexers.perl.Perl6Lexer +pygments.lexers.praat.PraatLexer +pygments.lexers.prolog.PrologLexer +pygments.lexers.prolog.LogtalkLexer +pygments.lexers.qvt.QVToLexer +pygments.lexers.rdf.SparqlLexer +pygments.lexers.rdf.TurtleLexer +pygments.lexers.python.PythonLexer +pygments.lexers.python.Python3Lexer +pygments.lexers.python.PythonTracebackLexer +pygments.lexers.python.Python3TracebackLexer +pygments.lexers.python.CythonLexer +pygments.lexers.python.DgLexer +pygments.lexers.rebol.RebolLexer +pygments.lexers.rebol.RedLexer +pygments.lexers.resource.ResourceLexer +pygments.lexers.rnc.RNCCompactLexer +pygments.lexers.roboconf.RoboconfGraphLexer +pygments.lexers.roboconf.RoboconfInstancesLexer +pygments.lexers.rust.RustLexer +pygments.lexers.ruby.RubyLexer +pygments.lexers.ruby.FancyLexer +pygments.lexers.sas.SASLexer +pygments.lexers.smalltalk.SmalltalkLexer +pygments.lexers.smalltalk.NewspeakLexer +pygments.lexers.smv.NuSMVLexer +pygments.lexers.shell.BashLexer +pygments.lexers.shell.BatchLexer +pygments.lexers.shell.TcshLexer +pygments.lexers.shell.PowerShellLexer +pygments.lexers.shell.FishShellLexer +pygments.lexers.snobol.SnobolLexer +pygments.lexers.scripting.LuaLexer +pygments.lexers.scripting.ChaiscriptLexer +pygments.lexers.scripting.LSLLexer +pygments.lexers.scripting.AppleScriptLexer +pygments.lexers.scripting.RexxLexer +pygments.lexers.scripting.MOOCodeLexer +pygments.lexers.scripting.HybrisLexer +pygments.lexers.scripting.EasytrieveLexer +pygments.lexers.scripting.JclLexer +pygments.lexers.supercollider.SuperColliderLexer +pygments.lexers.stata.StataLexer +pygments.lexers.tcl.TclLexer +pygments.lexers.sql.PostgresLexer +pygments.lexers.sql.PlPgsqlLexer +pygments.lexers.sql.PsqlRegexLexer +pygments.lexers.sql.SqlLexer +pygments.lexers.sql.TransactSqlLexer +pygments.lexers.sql.MySqlLexer +pygments.lexers.sql.RqlLexer +pygments.lexers.testing.GherkinLexer +pygments.lexers.testing.TAPLexer +pygments.lexers.textedit.AwkLexer +pygments.lexers.textedit.VimLexer +pygments.lexers.textfmts.IrcLogsLexer +pygments.lexers.textfmts.GettextLexer +pygments.lexers.textfmts.HttpLexer +pygments.lexers.textfmts.TodotxtLexer +pygments.lexers.trafficscript.RtsLexer +pygments.lexers.theorem.CoqLexer +pygments.lexers.theorem.IsabelleLexer +pygments.lexers.theorem.LeanLexer +pygments.lexers.templates.SmartyLexer +pygments.lexers.templates.VelocityLexer +pygments.lexers.templates.DjangoLexer +pygments.lexers.templates.MyghtyLexer +pygments.lexers.templates.MasonLexer +pygments.lexers.templates.MakoLexer +pygments.lexers.templates.CheetahLexer +pygments.lexers.templates.GenshiTextLexer +pygments.lexers.templates.GenshiMarkupLexer +pygments.lexers.templates.JspRootLexer +pygments.lexers.templates.EvoqueLexer +pygments.lexers.templates.ColdfusionLexer +pygments.lexers.templates.ColdfusionMarkupLexer +pygments.lexers.templates.TeaTemplateRootLexer +pygments.lexers.templates.HandlebarsLexer +pygments.lexers.templates.LiquidLexer +pygments.lexers.templates.TwigLexer +pygments.lexers.templates.Angular2Lexer +pygments.lexers.urbi.UrbiscriptLexer +pygments.lexers.typoscript.TypoScriptCssDataLexer +pygments.lexers.typoscript.TypoScriptHtmlDataLexer +pygments.lexers.typoscript.TypoScriptLexer +pygments.lexers.varnish.VCLLexer +pygments.lexers.verification.BoogieLexer +pygments.lexers.verification.SilverLexer +pygments.lexers.x10.X10Lexer +pygments.lexers.whiley.WhileyLexer +pygments.lexers.xorg.XorgLexer +pygments.lexers.webmisc.DuelLexer +pygments.lexers.webmisc.XQueryLexer +pygments.lexers.webmisc.QmlLexer +pygments.lexers.webmisc.CirruLexer +pygments.lexers.webmisc.SlimLexer diff --git a/vendor/github.com/alecthomas/chroma/v2/regexp.go b/vendor/github.com/alecthomas/chroma/v2/regexp.go new file mode 100644 index 0000000..1794662 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/regexp.go @@ -0,0 +1,480 @@ +package chroma + +import ( + "fmt" + "os" + "path/filepath" + "regexp" + "sort" + "strings" + "sync" + "time" + "unicode/utf8" + + "github.com/dlclark/regexp2" +) + +// A Rule is the fundamental matching unit of the Regex lexer state machine. +type Rule struct { + Pattern string + Type Emitter + Mutator Mutator +} + +// Words creates a regex that matches any of the given literal words. +func Words(prefix, suffix string, words ...string) string { + sort.Slice(words, func(i, j int) bool { + return len(words[j]) < len(words[i]) + }) + for i, word := range words { + words[i] = regexp.QuoteMeta(word) + } + return prefix + `(` + strings.Join(words, `|`) + `)` + suffix +} + +// Tokenise text using lexer, returning tokens as a slice. +func Tokenise(lexer Lexer, options *TokeniseOptions, text string) ([]Token, error) { + var out []Token + it, err := lexer.Tokenise(options, text) + if err != nil { + return nil, err + } + for t := it(); t != EOF; t = it() { + out = append(out, t) + } + return out, nil +} + +// Rules maps from state to a sequence of Rules. +type Rules map[string][]Rule + +// Rename clones rules then a rule. +func (r Rules) Rename(oldRule, newRule string) Rules { + r = r.Clone() + r[newRule] = r[oldRule] + delete(r, oldRule) + return r +} + +// Clone returns a clone of the Rules. +func (r Rules) Clone() Rules { + out := map[string][]Rule{} + for key, rules := range r { + out[key] = make([]Rule, len(rules)) + copy(out[key], 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 with deferred rules generation or panics. +func MustNewLexer(config *Config, rulesFunc func() Rules) *RegexLexer { + lexer, err := NewLexer(config, rulesFunc) + if err != nil { + panic(err) + } + return lexer +} + +// NewLexer creates a new regex-based Lexer. +// +// "rules" is a state machine transition map. Each key is a state. Values are sets of rules +// that match input, optionally modify lexer state, and output tokens. +func NewLexer(config *Config, rulesFunc func() Rules) (*RegexLexer, error) { + if config == nil { + config = &Config{} + } + for _, glob := range append(config.Filenames, config.AliasFilenames...) { + _, err := filepath.Match(glob, "") + if err != nil { + return nil, fmt.Errorf("%s: %q is not a valid glob: %w", config.Name, glob, err) + } + } + r := &RegexLexer{ + config: config, + fetchRulesFunc: func() (Rules, error) { return rulesFunc(), nil }, + } + // One-off code to generate XML lexers in the Chroma source tree. + // var nameCleanRe = regexp.MustCompile(`[^-+A-Za-z0-9_]`) + // name := strings.ToLower(nameCleanRe.ReplaceAllString(config.Name, "_")) + // data, err := Marshal(r) + // if err != nil { + // if errors.Is(err, ErrNotSerialisable) { + // fmt.Fprintf(os.Stderr, "warning: %q: %s\n", name, err) + // return r, nil + // } + // return nil, err + // } + // _, file, _, ok := runtime.Caller(2) + // if !ok { + // panic("??") + // } + // fmt.Println(file) + // if strings.Contains(file, "/lexers/") { + // dir := filepath.Join(filepath.Dir(file), "embedded") + // err = os.MkdirAll(dir, 0700) + // if err != nil { + // return nil, err + // } + // filename := filepath.Join(dir, name) + ".xml" + // fmt.Println(filename) + // err = ioutil.WriteFile(filename, data, 0600) + // if err != nil { + // return nil, err + // } + // } + return r, nil +} + +// Trace enables debug tracing. +func (r *RegexLexer) Trace(trace bool) *RegexLexer { + r.trace = trace + return r +} + +// A CompiledRule is a Rule with a pre-compiled regex. +// +// Note that regular expressions are lazily compiled on first use of the lexer. +type CompiledRule struct { + Rule + Regexp *regexp2.Regexp + flags string +} + +// CompiledRules is a map of rule name to sequence of compiled rules in that rule. +type CompiledRules map[string][]*CompiledRule + +// LexerState contains the state for a single lex. +type LexerState struct { + Lexer *RegexLexer + Registry *LexerRegistry + Text []rune + Pos int + Rules CompiledRules + Stack []string + State string + Rule int + // Group matches. + Groups []string + // Named Group matches. + NamedGroups map[string]string + // Custum context for mutators. + MutatorContext map[interface{}]interface{} + iteratorStack []Iterator + options *TokeniseOptions + newlineAdded bool +} + +// Set mutator context. +func (l *LexerState) Set(key interface{}, value interface{}) { + l.MutatorContext[key] = value +} + +// Get mutator context. +func (l *LexerState) Get(key interface{}) interface{} { + return l.MutatorContext[key] +} + +// Iterator returns the next Token from the lexer. +func (l *LexerState) Iterator() Token { // nolint: gocognit + end := len(l.Text) + if l.newlineAdded { + end-- + } + for l.Pos < end && len(l.Stack) > 0 { + // Exhaust the iterator stack, if any. + for len(l.iteratorStack) > 0 { + n := len(l.iteratorStack) - 1 + t := l.iteratorStack[n]() + if t == EOF { + l.iteratorStack = l.iteratorStack[:n] + continue + } + return t + } + + l.State = l.Stack[len(l.Stack)-1] + if l.Lexer.trace { + fmt.Fprintf(os.Stderr, "%s: pos=%d, text=%q\n", l.State, l.Pos, string(l.Text[l.Pos:])) + } + selectedRule, ok := l.Rules[l.State] + if !ok { + panic("unknown state " + l.State) + } + ruleIndex, rule, groups, namedGroups := matchRules(l.Text, l.Pos, selectedRule) + // No match. + if groups == nil { + // From Pygments :\ + // + // If the RegexLexer encounters a newline that is flagged as an error token, the stack is + // emptied and the lexer continues scanning in the 'root' state. This can help producing + // error-tolerant highlighting for erroneous input, e.g. when a single-line string is not + // closed. + if l.Text[l.Pos] == '\n' && l.State != l.options.State { + l.Stack = []string{l.options.State} + continue + } + l.Pos++ + return Token{Error, string(l.Text[l.Pos-1 : l.Pos])} + } + l.Rule = ruleIndex + l.Groups = groups + l.NamedGroups = namedGroups + l.Pos += utf8.RuneCountInString(groups[0]) + if rule.Mutator != nil { + if err := rule.Mutator.Mutate(l); err != nil { + panic(err) + } + } + if rule.Type != nil { + l.iteratorStack = append(l.iteratorStack, rule.Type.Emit(l.Groups, l)) + } + } + // Exhaust the IteratorStack, if any. + // Duplicate code, but eh. + for len(l.iteratorStack) > 0 { + n := len(l.iteratorStack) - 1 + t := l.iteratorStack[n]() + if t == EOF { + l.iteratorStack = l.iteratorStack[:n] + continue + } + return t + } + + // If we get to here and we still have text, return it as an error. + if l.Pos != len(l.Text) && len(l.Stack) == 0 { + value := string(l.Text[l.Pos:]) + l.Pos = len(l.Text) + return Token{Type: Error, Value: value} + } + return EOF +} + +// RegexLexer is the default lexer implementation used in Chroma. +type RegexLexer struct { + registry *LexerRegistry // The LexerRegistry this Lexer is associated with, if any. + config *Config + analyser func(text string) float32 + trace bool + + mu sync.Mutex + compiled bool + rawRules Rules + rules map[string][]*CompiledRule + fetchRulesFunc func() (Rules, error) + compileOnce sync.Once +} + +func (r *RegexLexer) String() string { + return r.config.Name +} + +// Rules in the Lexer. +func (r *RegexLexer) Rules() (Rules, error) { + if err := r.needRules(); err != nil { + return nil, err + } + return r.rawRules, nil +} + +// SetRegistry the lexer will use to lookup other lexers if necessary. +func (r *RegexLexer) SetRegistry(registry *LexerRegistry) Lexer { + r.registry = registry + return r +} + +// SetAnalyser sets the analyser function used to perform content inspection. +func (r *RegexLexer) SetAnalyser(analyser func(text string) float32) Lexer { + r.analyser = analyser + return r +} + +func (r *RegexLexer) AnalyseText(text string) float32 { // nolint + if r.analyser != nil { + return r.analyser(text) + } + return 0.0 +} + +// SetConfig replaces the Config for this Lexer. +func (r *RegexLexer) SetConfig(config *Config) *RegexLexer { + r.config = config + return r +} + +func (r *RegexLexer) Config() *Config { // nolint + return r.config +} + +// Regex compilation is deferred until the lexer is used. This is to avoid significant init() time costs. +func (r *RegexLexer) maybeCompile() (err error) { + r.mu.Lock() + defer r.mu.Unlock() + if r.compiled { + return nil + } + for state, rules := range r.rules { + for i, rule := range rules { + if rule.Regexp == nil { + pattern := "(?:" + rule.Pattern + ")" + if rule.flags != "" { + pattern = "(?" + rule.flags + ")" + pattern + } + pattern = `\G` + pattern + rule.Regexp, err = regexp2.Compile(pattern, regexp2.RE2) + if err != nil { + return fmt.Errorf("failed to compile rule %s.%d: %s", state, i, err) + } + rule.Regexp.MatchTimeout = time.Millisecond * 250 + } + } + } +restart: + seen := map[LexerMutator]bool{} + for state := range r.rules { + for i := 0; i < len(r.rules[state]); i++ { + rule := r.rules[state][i] + if compile, ok := rule.Mutator.(LexerMutator); ok { + if seen[compile] { + return fmt.Errorf("saw mutator %T twice; this should not happen", compile) + } + seen[compile] = true + if err := compile.MutateLexer(r.rules, state, i); err != nil { + return err + } + // Process the rules again in case the mutator added/removed rules. + // + // This sounds bad, but shouldn't be significant in practice. + goto restart + } + } + } + r.compiled = true + return nil +} + +func (r *RegexLexer) fetchRules() error { + rules, err := r.fetchRulesFunc() + if err != nil { + return fmt.Errorf("%s: failed to compile rules: %w", r.config.Name, err) + } + if _, ok := rules["root"]; !ok { + return fmt.Errorf("no \"root\" state") + } + compiledRules := map[string][]*CompiledRule{} + for state, rules := range rules { + compiledRules[state] = nil + for _, rule := range rules { + flags := "" + if !r.config.NotMultiline { + flags += "m" + } + if r.config.CaseInsensitive { + flags += "i" + } + if r.config.DotAll { + flags += "s" + } + compiledRules[state] = append(compiledRules[state], &CompiledRule{Rule: rule, flags: flags}) + } + } + + r.rawRules = rules + r.rules = compiledRules + return nil +} + +func (r *RegexLexer) needRules() error { + var err error + if r.fetchRulesFunc != nil { + r.compileOnce.Do(func() { + err = r.fetchRules() + }) + } + if err := r.maybeCompile(); err != nil { + return err + } + return err +} + +func (r *RegexLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error) { // nolint + err := r.needRules() + if err != nil { + return nil, err + } + if options == nil { + options = defaultOptions + } + if options.EnsureLF { + text = ensureLF(text) + } + newlineAdded := false + if !options.Nested && r.config.EnsureNL && !strings.HasSuffix(text, "\n") { + text += "\n" + newlineAdded = true + } + state := &LexerState{ + Registry: r.registry, + newlineAdded: newlineAdded, + options: options, + Lexer: r, + Text: []rune(text), + Stack: []string{options.State}, + Rules: r.rules, + MutatorContext: map[interface{}]interface{}{}, + } + return state.Iterator, nil +} + +// MustRules is like Rules() but will panic on error. +func (r *RegexLexer) MustRules() Rules { + rules, err := r.Rules() + if err != nil { + panic(err) + } + return rules +} + +func matchRules(text []rune, pos int, rules []*CompiledRule) (int, *CompiledRule, []string, map[string]string) { + for i, rule := range rules { + match, err := rule.Regexp.FindRunesMatchStartingAt(text, pos) + if match != nil && err == nil && match.Index == pos { + groups := []string{} + namedGroups := make(map[string]string) + for _, g := range match.Groups() { + namedGroups[g.Name] = g.String() + groups = append(groups, g.String()) + } + return i, rule, groups, namedGroups + } + } + return 0, &CompiledRule{}, nil, nil +} + +// replace \r and \r\n with \n +// same as strings.ReplaceAll but more efficient +func ensureLF(text string) string { + buf := make([]byte, len(text)) + var j int + for i := 0; i < len(text); i++ { + c := text[i] + if c == '\r' { + if i < len(text)-1 && text[i+1] == '\n' { + continue + } + c = '\n' + } + buf[j] = c + j++ + } + return string(buf[:j]) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/registry.go b/vendor/github.com/alecthomas/chroma/v2/registry.go new file mode 100644 index 0000000..b047dfc --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/registry.go @@ -0,0 +1,187 @@ +package chroma + +import ( + "path/filepath" + "sort" + "strings" +) + +var ( + ignoredSuffixes = [...]string{ + // Editor backups + "~", ".bak", ".old", ".orig", + // Debian and derivatives apt/dpkg/ucf backups + ".dpkg-dist", ".dpkg-old", ".ucf-dist", ".ucf-new", ".ucf-old", + // Red Hat and derivatives rpm backups + ".rpmnew", ".rpmorig", ".rpmsave", + // Build system input/template files + ".in", + } +) + +// LexerRegistry is a registry of Lexers. +type LexerRegistry struct { + Lexers Lexers + byName map[string]Lexer + byAlias map[string]Lexer +} + +// NewLexerRegistry creates a new LexerRegistry of Lexers. +func NewLexerRegistry() *LexerRegistry { + return &LexerRegistry{ + byName: map[string]Lexer{}, + byAlias: map[string]Lexer{}, + } +} + +// Names of all lexers, optionally including aliases. +func (l *LexerRegistry) Names(withAliases bool) []string { + out := []string{} + for _, lexer := range l.Lexers { + config := lexer.Config() + out = append(out, config.Name) + if withAliases { + out = append(out, config.Aliases...) + } + } + sort.Strings(out) + return out +} + +// Get a Lexer by name, alias or file extension. +func (l *LexerRegistry) Get(name string) Lexer { + if lexer := l.byName[name]; lexer != nil { + return lexer + } + if lexer := l.byAlias[name]; lexer != nil { + return lexer + } + if lexer := l.byName[strings.ToLower(name)]; lexer != nil { + return lexer + } + if lexer := l.byAlias[strings.ToLower(name)]; lexer != nil { + return lexer + } + + candidates := PrioritisedLexers{} + // Try file extension. + if lexer := l.Match("filename." + name); lexer != nil { + candidates = append(candidates, lexer) + } + // Try exact filename. + if lexer := l.Match(name); lexer != nil { + candidates = append(candidates, lexer) + } + if len(candidates) == 0 { + return nil + } + sort.Sort(candidates) + return candidates[0] +} + +// MatchMimeType attempts to find a lexer for the given MIME type. +func (l *LexerRegistry) MatchMimeType(mimeType string) Lexer { + matched := PrioritisedLexers{} + for _, l := range l.Lexers { + for _, lmt := range l.Config().MimeTypes { + if mimeType == lmt { + matched = append(matched, l) + } + } + } + if len(matched) != 0 { + sort.Sort(matched) + return matched[0] + } + return nil +} + +// Match returns the first lexer matching filename. +func (l *LexerRegistry) Match(filename string) Lexer { + filename = filepath.Base(filename) + matched := PrioritisedLexers{} + // First, try primary filename matches. + for _, lexer := range l.Lexers { + config := lexer.Config() + for _, glob := range config.Filenames { + ok, err := filepath.Match(glob, filename) + if err != nil { // nolint + panic(err) + } else if ok { + matched = append(matched, lexer) + } else { + for _, suf := range &ignoredSuffixes { + ok, err := filepath.Match(glob+suf, filename) + if err != nil { + panic(err) + } else if ok { + matched = append(matched, lexer) + break + } + } + } + } + } + if len(matched) > 0 { + sort.Sort(matched) + return matched[0] + } + matched = nil + // Next, try filename aliases. + for _, lexer := range l.Lexers { + config := lexer.Config() + for _, glob := range config.AliasFilenames { + ok, err := filepath.Match(glob, filename) + if err != nil { // nolint + panic(err) + } else if ok { + matched = append(matched, lexer) + } else { + for _, suf := range &ignoredSuffixes { + ok, err := filepath.Match(glob+suf, filename) + if err != nil { + panic(err) + } else if ok { + matched = append(matched, lexer) + break + } + } + } + } + } + if len(matched) > 0 { + sort.Sort(matched) + return matched[0] + } + return nil +} + +// Analyse text content and return the "best" lexer.. +func (l *LexerRegistry) Analyse(text string) Lexer { + var picked Lexer + highest := float32(0.0) + for _, lexer := range l.Lexers { + if analyser, ok := lexer.(Analyser); ok { + weight := analyser.AnalyseText(text) + if weight > highest { + picked = lexer + highest = weight + } + } + } + return picked +} + +// Register a Lexer with the LexerRegistry. +func (l *LexerRegistry) Register(lexer Lexer) Lexer { + lexer.SetRegistry(l) + config := lexer.Config() + l.byName[config.Name] = lexer + l.byName[strings.ToLower(config.Name)] = lexer + for _, alias := range config.Aliases { + l.byAlias[alias] = lexer + l.byAlias[strings.ToLower(alias)] = lexer + } + l.Lexers = append(l.Lexers, lexer) + return lexer +} diff --git a/vendor/github.com/alecthomas/chroma/v2/remap.go b/vendor/github.com/alecthomas/chroma/v2/remap.go new file mode 100644 index 0000000..440761b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/remap.go @@ -0,0 +1,94 @@ +package chroma + +type remappingLexer struct { + lexer Lexer + mapper func(Token) []Token +} + +// RemappingLexer remaps a token to a set of, potentially empty, tokens. +func RemappingLexer(lexer Lexer, mapper func(Token) []Token) Lexer { + return &remappingLexer{lexer, mapper} +} + +func (r *remappingLexer) AnalyseText(text string) float32 { + return r.lexer.AnalyseText(text) +} + +func (r *remappingLexer) SetAnalyser(analyser func(text string) float32) Lexer { + r.lexer.SetAnalyser(analyser) + return r +} + +func (r *remappingLexer) SetRegistry(registry *LexerRegistry) Lexer { + r.lexer.SetRegistry(registry) + return r +} + +func (r *remappingLexer) Config() *Config { + return r.lexer.Config() +} + +func (r *remappingLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error) { + it, err := r.lexer.Tokenise(options, text) + if err != nil { + return nil, err + } + var buffer []Token + return func() Token { + for { + if len(buffer) > 0 { + t := buffer[0] + buffer = buffer[1:] + return t + } + t := it() + if t == EOF { + return t + } + buffer = r.mapper(t) + } + }, nil +} + +// TypeMapping defines type maps for the TypeRemappingLexer. +type TypeMapping []struct { + From, To TokenType + Words []string +} + +// TypeRemappingLexer remaps types of tokens coming from a parent Lexer. +// +// eg. Map "defvaralias" tokens of type NameVariable to NameFunction: +// +// mapping := TypeMapping{ +// {NameVariable, NameFunction, []string{"defvaralias"}, +// } +// lexer = TypeRemappingLexer(lexer, mapping) +func TypeRemappingLexer(lexer Lexer, mapping TypeMapping) Lexer { + // Lookup table for fast remapping. + lut := map[TokenType]map[string]TokenType{} + for _, rt := range mapping { + km, ok := lut[rt.From] + if !ok { + km = map[string]TokenType{} + lut[rt.From] = km + } + if len(rt.Words) == 0 { + km[""] = rt.To + } else { + for _, k := range rt.Words { + km[k] = rt.To + } + } + } + return RemappingLexer(lexer, func(t Token) []Token { + if k, ok := lut[t.Type]; ok { + if tt, ok := k[t.Value]; ok { + t.Type = tt + } else if tt, ok := k[""]; ok { + t.Type = tt + } + } + return []Token{t} + }) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/serialise.go b/vendor/github.com/alecthomas/chroma/v2/serialise.go new file mode 100644 index 0000000..0369639 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/serialise.go @@ -0,0 +1,433 @@ +package chroma + +import ( + "compress/gzip" + "encoding/xml" + "errors" + "fmt" + "io" + "io/fs" + "path/filepath" + "reflect" + "regexp" + "strings" +) + +// Serialisation of Chroma rules to XML. The format is: +// +// <rules> +// <state name="$STATE"> +// <rule [pattern="$PATTERN"]> +// [<$EMITTER ...>] +// [<$MUTATOR ...>] +// </rule> +// </state> +// </rules> +// +// eg. Include("String") would become: +// +// <rule> +// <include state="String" /> +// </rule> +// +// [null, null, {"kind": "include", "state": "String"}] +// +// eg. Rule{`\d+`, Text, nil} would become: +// +// <rule pattern="\\d+"> +// <token type="Text"/> +// </rule> +// +// eg. Rule{`"`, String, Push("String")} +// +// <rule pattern="\""> +// <token type="String" /> +// <push state="String" /> +// </rule> +// +// eg. Rule{`(\w+)(\n)`, ByGroups(Keyword, Whitespace), nil}, +// +// <rule pattern="(\\w+)(\\n)"> +// <bygroups token="Keyword" token="Whitespace" /> +// <push state="String" /> +// </rule> +var ( + // ErrNotSerialisable is returned if a lexer contains Rules that cannot be serialised. + ErrNotSerialisable = fmt.Errorf("not serialisable") + emitterTemplates = func() map[string]SerialisableEmitter { + out := map[string]SerialisableEmitter{} + for _, emitter := range []SerialisableEmitter{ + &byGroupsEmitter{}, + &usingSelfEmitter{}, + TokenType(0), + &usingEmitter{}, + &usingByGroup{}, + } { + out[emitter.EmitterKind()] = emitter + } + return out + }() + mutatorTemplates = func() map[string]SerialisableMutator { + out := map[string]SerialisableMutator{} + for _, mutator := range []SerialisableMutator{ + &includeMutator{}, + &combinedMutator{}, + &multiMutator{}, + &pushMutator{}, + &popMutator{}, + } { + out[mutator.MutatorKind()] = mutator + } + return out + }() +) + +// fastUnmarshalConfig unmarshals only the Config from a serialised lexer. +func fastUnmarshalConfig(from fs.FS, path string) (*Config, error) { + r, err := from.Open(path) + if err != nil { + return nil, err + } + defer r.Close() + dec := xml.NewDecoder(r) + for { + token, err := dec.Token() + if err != nil { + if errors.Is(err, io.EOF) { + return nil, fmt.Errorf("could not find <config> element") + } + return nil, err + } + switch se := token.(type) { + case xml.StartElement: + if se.Name.Local != "config" { + break + } + + var config Config + err = dec.DecodeElement(&config, &se) + if err != nil { + panic(err) + } + return &config, nil + } + } +} + +// MustNewXMLLexer constructs a new RegexLexer from an XML file or panics. +func MustNewXMLLexer(from fs.FS, path string) *RegexLexer { + lex, err := NewXMLLexer(from, path) + if err != nil { + panic(err) + } + return lex +} + +// NewXMLLexer creates a new RegexLexer from a serialised RegexLexer. +func NewXMLLexer(from fs.FS, path string) (*RegexLexer, error) { + config, err := fastUnmarshalConfig(from, path) + if err != nil { + return nil, err + } + for _, glob := range append(config.Filenames, config.AliasFilenames...) { + _, err := filepath.Match(glob, "") + if err != nil { + return nil, fmt.Errorf("%s: %q is not a valid glob: %w", config.Name, glob, err) + } + } + return &RegexLexer{ + config: config, + fetchRulesFunc: func() (Rules, error) { + var lexer struct { + Config + Rules Rules `xml:"rules"` + } + // Try to open .xml fallback to .xml.gz + fr, err := from.Open(path) + if err != nil { + if errors.Is(err, fs.ErrNotExist) { + path += ".gz" + fr, err = from.Open(path) + if err != nil { + return nil, err + } + } else { + return nil, err + } + } + defer fr.Close() + var r io.Reader = fr + if strings.HasSuffix(path, ".gz") { + r, err = gzip.NewReader(r) + if err != nil { + return nil, fmt.Errorf("%s: %w", path, err) + } + } + err = xml.NewDecoder(r).Decode(&lexer) + if err != nil { + return nil, fmt.Errorf("%s: %w", path, err) + } + return lexer.Rules, nil + }, + }, nil +} + +// Marshal a RegexLexer to XML. +func Marshal(l *RegexLexer) ([]byte, error) { + type lexer struct { + Config Config `xml:"config"` + Rules Rules `xml:"rules"` + } + + rules, err := l.Rules() + if err != nil { + return nil, err + } + root := &lexer{ + Config: *l.Config(), + Rules: rules, + } + data, err := xml.MarshalIndent(root, "", " ") + if err != nil { + return nil, err + } + re := regexp.MustCompile(`></[a-zA-Z]+>`) + data = re.ReplaceAll(data, []byte(`/>`)) + return data, nil +} + +// Unmarshal a RegexLexer from XML. +func Unmarshal(data []byte) (*RegexLexer, error) { + type lexer struct { + Config Config `xml:"config"` + Rules Rules `xml:"rules"` + } + root := &lexer{} + err := xml.Unmarshal(data, root) + if err != nil { + return nil, fmt.Errorf("invalid Lexer XML: %w", err) + } + lex, err := NewLexer(&root.Config, func() Rules { return root.Rules }) + if err != nil { + return nil, err + } + return lex, nil +} + +func marshalMutator(e *xml.Encoder, mutator Mutator) error { + if mutator == nil { + return nil + } + smutator, ok := mutator.(SerialisableMutator) + if !ok { + return fmt.Errorf("unsupported mutator: %w", ErrNotSerialisable) + } + return e.EncodeElement(mutator, xml.StartElement{Name: xml.Name{Local: smutator.MutatorKind()}}) +} + +func unmarshalMutator(d *xml.Decoder, start xml.StartElement) (Mutator, error) { + kind := start.Name.Local + mutator, ok := mutatorTemplates[kind] + if !ok { + return nil, fmt.Errorf("unknown mutator %q: %w", kind, ErrNotSerialisable) + } + value, target := newFromTemplate(mutator) + if err := d.DecodeElement(target, &start); err != nil { + return nil, err + } + return value().(SerialisableMutator), nil +} + +func marshalEmitter(e *xml.Encoder, emitter Emitter) error { + if emitter == nil { + return nil + } + semitter, ok := emitter.(SerialisableEmitter) + if !ok { + return fmt.Errorf("unsupported emitter %T: %w", emitter, ErrNotSerialisable) + } + return e.EncodeElement(emitter, xml.StartElement{ + Name: xml.Name{Local: semitter.EmitterKind()}, + }) +} + +func unmarshalEmitter(d *xml.Decoder, start xml.StartElement) (Emitter, error) { + kind := start.Name.Local + mutator, ok := emitterTemplates[kind] + if !ok { + return nil, fmt.Errorf("unknown emitter %q: %w", kind, ErrNotSerialisable) + } + value, target := newFromTemplate(mutator) + if err := d.DecodeElement(target, &start); err != nil { + return nil, err + } + return value().(SerialisableEmitter), nil +} + +func (r Rule) MarshalXML(e *xml.Encoder, _ xml.StartElement) error { + start := xml.StartElement{ + Name: xml.Name{Local: "rule"}, + } + if r.Pattern != "" { + start.Attr = append(start.Attr, xml.Attr{ + Name: xml.Name{Local: "pattern"}, + Value: r.Pattern, + }) + } + if err := e.EncodeToken(start); err != nil { + return err + } + if err := marshalEmitter(e, r.Type); err != nil { + return err + } + if err := marshalMutator(e, r.Mutator); err != nil { + return err + } + return e.EncodeToken(xml.EndElement{Name: start.Name}) +} + +func (r *Rule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + for _, attr := range start.Attr { + if attr.Name.Local == "pattern" { + r.Pattern = attr.Value + break + } + } + for { + token, err := d.Token() + if err != nil { + return err + } + switch token := token.(type) { + case xml.StartElement: + mutator, err := unmarshalMutator(d, token) + if err != nil && !errors.Is(err, ErrNotSerialisable) { + return err + } else if err == nil { + if r.Mutator != nil { + return fmt.Errorf("duplicate mutator") + } + r.Mutator = mutator + continue + } + emitter, err := unmarshalEmitter(d, token) + if err != nil && !errors.Is(err, ErrNotSerialisable) { // nolint: gocritic + return err + } else if err == nil { + if r.Type != nil { + return fmt.Errorf("duplicate emitter") + } + r.Type = emitter + continue + } else { + return err + } + + case xml.EndElement: + return nil + } + } +} + +type xmlRuleState struct { + Name string `xml:"name,attr"` + Rules []Rule `xml:"rule"` +} + +type xmlRules struct { + States []xmlRuleState `xml:"state"` +} + +func (r Rules) MarshalXML(e *xml.Encoder, _ xml.StartElement) error { + xr := xmlRules{} + for state, rules := range r { + xr.States = append(xr.States, xmlRuleState{ + Name: state, + Rules: rules, + }) + } + return e.EncodeElement(xr, xml.StartElement{Name: xml.Name{Local: "rules"}}) +} + +func (r *Rules) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + xr := xmlRules{} + if err := d.DecodeElement(&xr, &start); err != nil { + return err + } + if *r == nil { + *r = Rules{} + } + for _, state := range xr.States { + (*r)[state.Name] = state.Rules + } + return nil +} + +type xmlTokenType struct { + Type string `xml:"type,attr"` +} + +func (t *TokenType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + el := xmlTokenType{} + if err := d.DecodeElement(&el, &start); err != nil { + return err + } + for tt, text := range _TokenType_map { + if text == el.Type { + *t = tt + return nil + } + } + return fmt.Errorf("unknown TokenType %q", el.Type) +} + +func (t TokenType) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + start.Attr = append(start.Attr, xml.Attr{Name: xml.Name{Local: "type"}, Value: t.String()}) + if err := e.EncodeToken(start); err != nil { + return err + } + return e.EncodeToken(xml.EndElement{Name: start.Name}) +} + +// This hijinks is a bit unfortunate but without it we can't deserialise into TokenType. +func newFromTemplate(template interface{}) (value func() interface{}, target interface{}) { + t := reflect.TypeOf(template) + if t.Kind() == reflect.Ptr { + v := reflect.New(t.Elem()) + return v.Interface, v.Interface() + } + v := reflect.New(t) + return func() interface{} { return v.Elem().Interface() }, v.Interface() +} + +func (b *Emitters) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + for { + token, err := d.Token() + if err != nil { + return err + } + switch token := token.(type) { + case xml.StartElement: + emitter, err := unmarshalEmitter(d, token) + if err != nil { + return err + } + *b = append(*b, emitter) + + case xml.EndElement: + return nil + } + } +} + +func (b Emitters) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + if err := e.EncodeToken(start); err != nil { + return err + } + for _, m := range b { + if err := marshalEmitter(e, m); err != nil { + return err + } + } + return e.EncodeToken(xml.EndElement{Name: start.Name}) +} diff --git a/vendor/github.com/alecthomas/chroma/v2/style.go b/vendor/github.com/alecthomas/chroma/v2/style.go new file mode 100644 index 0000000..1319fc4 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/style.go @@ -0,0 +1,344 @@ +package chroma + +import ( + "fmt" + "strings" +) + +// Trilean value for StyleEntry value inheritance. +type Trilean uint8 + +// Trilean states. +const ( + Pass Trilean = iota + Yes + No +) + +func (t Trilean) String() string { + switch t { + case Yes: + return "Yes" + case No: + return "No" + default: + return "Pass" + } +} + +// Prefix returns s with "no" as a prefix if Trilean is no. +func (t Trilean) Prefix(s string) string { + if t == Yes { + return s + } else if t == No { + return "no" + s + } + return "" +} + +// A StyleEntry in the Style map. +type StyleEntry struct { + // Hex colours. + Colour Colour + Background Colour + Border Colour + + Bold Trilean + Italic Trilean + Underline Trilean + NoInherit bool +} + +func (s StyleEntry) String() string { + out := []string{} + if s.Bold != Pass { + out = append(out, s.Bold.Prefix("bold")) + } + if s.Italic != Pass { + out = append(out, s.Italic.Prefix("italic")) + } + if s.Underline != Pass { + out = append(out, s.Underline.Prefix("underline")) + } + if s.NoInherit { + out = append(out, "noinherit") + } + if s.Colour.IsSet() { + out = append(out, s.Colour.String()) + } + if s.Background.IsSet() { + out = append(out, "bg:"+s.Background.String()) + } + if s.Border.IsSet() { + out = append(out, "border:"+s.Border.String()) + } + return strings.Join(out, " ") +} + +// Sub subtracts e from s where elements match. +func (s StyleEntry) Sub(e StyleEntry) StyleEntry { + out := StyleEntry{} + if e.Colour != s.Colour { + out.Colour = s.Colour + } + if e.Background != s.Background { + out.Background = s.Background + } + if e.Bold != s.Bold { + out.Bold = s.Bold + } + if e.Italic != s.Italic { + out.Italic = s.Italic + } + if e.Underline != s.Underline { + out.Underline = s.Underline + } + if e.Border != s.Border { + out.Border = s.Border + } + return out +} + +// Inherit styles from ancestors. +// +// Ancestors should be provided from oldest to newest. +func (s StyleEntry) Inherit(ancestors ...StyleEntry) StyleEntry { + out := s + for i := len(ancestors) - 1; i >= 0; i-- { + if out.NoInherit { + return out + } + ancestor := ancestors[i] + if !out.Colour.IsSet() { + out.Colour = ancestor.Colour + } + if !out.Background.IsSet() { + out.Background = ancestor.Background + } + if !out.Border.IsSet() { + out.Border = ancestor.Border + } + if out.Bold == Pass { + out.Bold = ancestor.Bold + } + if out.Italic == Pass { + out.Italic = ancestor.Italic + } + if out.Underline == Pass { + out.Underline = ancestor.Underline + } + } + return out +} + +func (s StyleEntry) IsZero() bool { + return s.Colour == 0 && s.Background == 0 && s.Border == 0 && s.Bold == Pass && s.Italic == Pass && + s.Underline == Pass && !s.NoInherit +} + +// A StyleBuilder is a mutable structure for building styles. +// +// Once built, a Style is immutable. +type StyleBuilder struct { + entries map[TokenType]string + name string + parent *Style +} + +func NewStyleBuilder(name string) *StyleBuilder { + return &StyleBuilder{name: name, entries: map[TokenType]string{}} +} + +func (s *StyleBuilder) AddAll(entries StyleEntries) *StyleBuilder { + for ttype, entry := range entries { + s.entries[ttype] = entry + } + return s +} + +func (s *StyleBuilder) Get(ttype TokenType) StyleEntry { + // This is less than ideal, but it's the price for having to check errors on each Add(). + entry, _ := ParseStyleEntry(s.entries[ttype]) + return entry.Inherit(s.parent.Get(ttype)) +} + +// Add an entry to the Style map. +// +// See http://pygments.org/docs/styles/#style-rules for details. +func (s *StyleBuilder) Add(ttype TokenType, entry string) *StyleBuilder { // nolint: gocyclo + s.entries[ttype] = entry + return s +} + +func (s *StyleBuilder) AddEntry(ttype TokenType, entry StyleEntry) *StyleBuilder { + s.entries[ttype] = entry.String() + return s +} + +func (s *StyleBuilder) Build() (*Style, error) { + style := &Style{ + Name: s.name, + entries: map[TokenType]StyleEntry{}, + parent: s.parent, + } + for ttype, descriptor := range s.entries { + entry, err := ParseStyleEntry(descriptor) + if err != nil { + return nil, fmt.Errorf("invalid entry for %s: %s", ttype, err) + } + style.entries[ttype] = entry + } + return style, nil +} + +// StyleEntries mapping TokenType to colour definition. +type StyleEntries map[TokenType]string + +// NewStyle creates a new style definition. +func NewStyle(name string, entries StyleEntries) (*Style, error) { + return NewStyleBuilder(name).AddAll(entries).Build() +} + +// MustNewStyle creates a new style or panics. +func MustNewStyle(name string, entries StyleEntries) *Style { + style, err := NewStyle(name, entries) + if err != nil { + panic(err) + } + return style +} + +// A Style definition. +// +// See http://pygments.org/docs/styles/ for details. Semantics are intended to be identical. +type Style struct { + Name string + entries map[TokenType]StyleEntry + parent *Style +} + +// Types that are styled. +func (s *Style) Types() []TokenType { + dedupe := map[TokenType]bool{} + for tt := range s.entries { + dedupe[tt] = true + } + if s.parent != nil { + for _, tt := range s.parent.Types() { + dedupe[tt] = true + } + } + out := make([]TokenType, 0, len(dedupe)) + for tt := range dedupe { + out = append(out, tt) + } + return out +} + +// Builder creates a mutable builder from this Style. +// +// The builder can then be safely modified. This is a cheap operation. +func (s *Style) Builder() *StyleBuilder { + return &StyleBuilder{ + name: s.Name, + entries: map[TokenType]string{}, + parent: s, + } +} + +// Has checks if an exact style entry match exists for a token type. +// +// This is distinct from Get() which will merge parent tokens. +func (s *Style) Has(ttype TokenType) bool { + return !s.get(ttype).IsZero() || s.synthesisable(ttype) +} + +// Get a style entry. Will try sub-category or category if an exact match is not found, and +// finally return the Background. +func (s *Style) Get(ttype TokenType) StyleEntry { + return s.get(ttype).Inherit( + s.get(Background), + s.get(Text), + s.get(ttype.Category()), + s.get(ttype.SubCategory())) +} + +func (s *Style) get(ttype TokenType) StyleEntry { + out := s.entries[ttype] + if out.IsZero() && s.parent != nil { + return s.parent.get(ttype) + } + if out.IsZero() && s.synthesisable(ttype) { + out = s.synthesise(ttype) + } + return out +} + +func (s *Style) synthesise(ttype TokenType) StyleEntry { + bg := s.get(Background) + text := StyleEntry{Colour: bg.Colour} + text.Colour = text.Colour.BrightenOrDarken(0.5) + + switch ttype { + // If we don't have a line highlight colour, make one that is 10% brighter/darker than the background. + case LineHighlight: + return StyleEntry{Background: bg.Background.BrightenOrDarken(0.1)} + + // If we don't have line numbers, use the text colour but 20% brighter/darker + case LineNumbers, LineNumbersTable: + return text + + default: + return StyleEntry{} + } +} + +func (s *Style) synthesisable(ttype TokenType) bool { + return ttype == LineHighlight || ttype == LineNumbers || ttype == LineNumbersTable +} + +// ParseStyleEntry parses a Pygments style entry. +func ParseStyleEntry(entry string) (StyleEntry, error) { // nolint: gocyclo + out := StyleEntry{} + parts := strings.Fields(entry) + for _, part := range parts { + switch { + case part == "italic": + out.Italic = Yes + case part == "noitalic": + out.Italic = No + case part == "bold": + out.Bold = Yes + case part == "nobold": + out.Bold = No + case part == "underline": + out.Underline = Yes + case part == "nounderline": + out.Underline = No + case part == "inherit": + out.NoInherit = false + case part == "noinherit": + out.NoInherit = true + case part == "bg:": + out.Background = 0 + case strings.HasPrefix(part, "bg:#"): + out.Background = ParseColour(part[3:]) + if !out.Background.IsSet() { + return StyleEntry{}, fmt.Errorf("invalid background colour %q", part) + } + case strings.HasPrefix(part, "border:#"): + out.Border = ParseColour(part[7:]) + if !out.Border.IsSet() { + return StyleEntry{}, fmt.Errorf("invalid border colour %q", part) + } + case strings.HasPrefix(part, "#"): + out.Colour = ParseColour(part) + if !out.Colour.IsSet() { + return StyleEntry{}, fmt.Errorf("invalid colour %q", part) + } + default: + return StyleEntry{}, fmt.Errorf("unknown style element %q", part) + } + } + return out, nil +} diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/abap.go b/vendor/github.com/alecthomas/chroma/v2/styles/abap.go new file mode 100644 index 0000000..2807dc7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/abap.go @@ -0,0 +1,18 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Abap style. +var Abap = Register(chroma.MustNewStyle("abap", chroma.StyleEntries{ + chroma.Comment: "italic #888", + chroma.CommentSpecial: "#888", + chroma.Keyword: "#00f", + chroma.OperatorWord: "#00f", + chroma.Name: "#000", + chroma.LiteralNumber: "#3af", + chroma.LiteralString: "#5a2", + chroma.Error: "#F00", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/algol.go b/vendor/github.com/alecthomas/chroma/v2/styles/algol.go new file mode 100644 index 0000000..b38715e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/algol.go @@ -0,0 +1,25 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Algol style. +var Algol = Register(chroma.MustNewStyle("algol", chroma.StyleEntries{ + chroma.Comment: "italic #888", + chroma.CommentPreproc: "bold noitalic #888", + chroma.CommentSpecial: "bold noitalic #888", + chroma.Keyword: "underline bold", + chroma.KeywordDeclaration: "italic", + chroma.NameBuiltin: "bold italic", + chroma.NameBuiltinPseudo: "bold italic", + chroma.NameNamespace: "bold italic #666", + chroma.NameClass: "bold italic #666", + chroma.NameFunction: "bold italic #666", + chroma.NameVariable: "bold italic #666", + chroma.NameConstant: "bold italic #666", + chroma.OperatorWord: "bold", + chroma.LiteralString: "italic #666", + chroma.Error: "border:#FF0000", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/algol_nu.go b/vendor/github.com/alecthomas/chroma/v2/styles/algol_nu.go new file mode 100644 index 0000000..487086d --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/algol_nu.go @@ -0,0 +1,25 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// AlgolNu style. +var AlgolNu = Register(chroma.MustNewStyle("algol_nu", chroma.StyleEntries{ + chroma.Comment: "italic #888", + chroma.CommentPreproc: "bold noitalic #888", + chroma.CommentSpecial: "bold noitalic #888", + chroma.Keyword: "bold", + chroma.KeywordDeclaration: "italic", + chroma.NameBuiltin: "bold italic", + chroma.NameBuiltinPseudo: "bold italic", + chroma.NameNamespace: "bold italic #666", + chroma.NameClass: "bold italic #666", + chroma.NameFunction: "bold italic #666", + chroma.NameVariable: "bold italic #666", + chroma.NameConstant: "bold italic #666", + chroma.OperatorWord: "bold", + chroma.LiteralString: "italic #666", + chroma.Error: "border:#FF0000", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/api.go b/vendor/github.com/alecthomas/chroma/v2/styles/api.go new file mode 100644 index 0000000..8c0dbe0 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/api.go @@ -0,0 +1,37 @@ +package styles + +import ( + "sort" + + "github.com/alecthomas/chroma/v2" +) + +// Registry of Styles. +var Registry = map[string]*chroma.Style{} + +// Fallback style. Reassign to change the default fallback style. +var Fallback = SwapOff + +// Register a chroma.Style. +func Register(style *chroma.Style) *chroma.Style { + Registry[style.Name] = style + return style +} + +// Names of all available styles. +func Names() []string { + out := []string{} + for name := range Registry { + out = append(out, name) + } + sort.Strings(out) + return out +} + +// Get named style, or Fallback. +func Get(name string) *chroma.Style { + if style, ok := Registry[name]; ok { + return style + } + return Fallback +} diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/arduino.go b/vendor/github.com/alecthomas/chroma/v2/styles/arduino.go new file mode 100644 index 0000000..3099b7e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/arduino.go @@ -0,0 +1,25 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Arduino style. +var Arduino = Register(chroma.MustNewStyle("arduino", chroma.StyleEntries{ + chroma.Error: "#a61717", + chroma.Comment: "#95a5a6", + chroma.CommentPreproc: "#728E00", + chroma.Keyword: "#728E00", + chroma.KeywordConstant: "#00979D", + chroma.KeywordPseudo: "#00979D", + chroma.KeywordReserved: "#00979D", + chroma.KeywordType: "#00979D", + chroma.Operator: "#728E00", + chroma.Name: "#434f54", + chroma.NameBuiltin: "#728E00", + chroma.NameFunction: "#D35400", + chroma.NameOther: "#728E00", + chroma.LiteralNumber: "#8A7B52", + chroma.LiteralString: "#7F8C8D", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/autumn.go b/vendor/github.com/alecthomas/chroma/v2/styles/autumn.go new file mode 100644 index 0000000..df22500 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/autumn.go @@ -0,0 +1,43 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Autumn style. +var Autumn = Register(chroma.MustNewStyle("autumn", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "italic #aaaaaa", + chroma.CommentPreproc: "noitalic #4c8317", + chroma.CommentSpecial: "italic #0000aa", + chroma.Keyword: "#0000aa", + chroma.KeywordType: "#00aaaa", + chroma.OperatorWord: "#0000aa", + chroma.NameBuiltin: "#00aaaa", + chroma.NameFunction: "#00aa00", + chroma.NameClass: "underline #00aa00", + chroma.NameNamespace: "underline #00aaaa", + chroma.NameVariable: "#aa0000", + chroma.NameConstant: "#aa0000", + chroma.NameEntity: "bold #800", + chroma.NameAttribute: "#1e90ff", + chroma.NameTag: "bold #1e90ff", + chroma.NameDecorator: "#888888", + chroma.LiteralString: "#aa5500", + chroma.LiteralStringSymbol: "#0000aa", + chroma.LiteralStringRegex: "#009999", + chroma.LiteralNumber: "#009999", + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#aa0000", + chroma.GenericInserted: "#00aa00", + chroma.GenericError: "#aa0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "#555555", + chroma.GenericOutput: "#888888", + chroma.GenericTraceback: "#aa0000", + chroma.GenericUnderline: "underline", + chroma.Error: "#F00 bg:#FAA", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/average.go b/vendor/github.com/alecthomas/chroma/v2/styles/average.go new file mode 100644 index 0000000..b1276e2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/average.go @@ -0,0 +1,81 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Average style. +var Average = Register(chroma.MustNewStyle("average", chroma.StyleEntries{ + chroma.Comment: "#757575", + chroma.CommentHashbang: "#757575", + chroma.CommentMultiline: "#757575", + chroma.CommentPreproc: "#757575", + chroma.CommentSingle: "#757575", + chroma.CommentSpecial: "#757575", + chroma.Generic: "#757575", + chroma.GenericDeleted: "#ec0000", + chroma.GenericEmph: "#757575 underline", + chroma.GenericError: "#ec0000", + chroma.GenericHeading: "#757575 bold", + chroma.GenericInserted: "#757575 bold", + chroma.GenericOutput: "#757575", + chroma.GenericPrompt: "#757575", + chroma.GenericStrong: "#757575 italic", + chroma.GenericSubheading: "#757575 bold", + chroma.GenericTraceback: "#757575", + chroma.GenericUnderline: "underline", + chroma.Error: "#ec0000", + chroma.Keyword: "#ec0000", + chroma.KeywordConstant: "#ec0000", + chroma.KeywordDeclaration: "#ec0000", + chroma.KeywordNamespace: "#ec0000", + chroma.KeywordPseudo: "#ec0000", + chroma.KeywordReserved: "#ec0000", + chroma.KeywordType: "#5f5fff", + chroma.Literal: "#757575", + chroma.LiteralDate: "#757575", + chroma.Name: "#757575", + chroma.NameAttribute: "#5f5fff", + chroma.NameBuiltin: "#ec0000", + chroma.NameBuiltinPseudo: "#757575", + chroma.NameClass: "#5f5fff", + chroma.NameConstant: "#008900", + chroma.NameDecorator: "#008900", + chroma.NameEntity: "#757575", + chroma.NameException: "#757575", + chroma.NameFunction: "#5f5fff", + chroma.NameLabel: "#ec0000", + chroma.NameNamespace: "#757575", + chroma.NameOther: "#757575", + chroma.NameTag: "#ec0000", + chroma.NameVariable: "#ec0000", + chroma.NameVariableClass: "#ec0000", + chroma.NameVariableGlobal: "#ec0000", + chroma.NameVariableInstance: "#ec0000", + chroma.LiteralNumber: "#008900", + chroma.LiteralNumberBin: "#008900", + chroma.LiteralNumberFloat: "#008900", + chroma.LiteralNumberHex: "#008900", + chroma.LiteralNumberInteger: "#008900", + chroma.LiteralNumberIntegerLong: "#008900", + chroma.LiteralNumberOct: "#008900", + chroma.Operator: "#ec0000", + chroma.OperatorWord: "#ec0000", + chroma.Other: "#757575", + chroma.Punctuation: "#757575", + chroma.LiteralString: "#008900", + chroma.LiteralStringBacktick: "#008900", + chroma.LiteralStringChar: "#008900", + chroma.LiteralStringDoc: "#008900", + chroma.LiteralStringDouble: "#008900", + chroma.LiteralStringEscape: "#008900", + chroma.LiteralStringHeredoc: "#008900", + chroma.LiteralStringInterpol: "#008900", + chroma.LiteralStringOther: "#008900", + chroma.LiteralStringRegex: "#008900", + chroma.LiteralStringSingle: "#008900", + chroma.LiteralStringSymbol: "#008900", + chroma.Text: "#757575", + chroma.TextWhitespace: "#757575", + chroma.Background: " bg:#000000", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/base16-snazzy.go b/vendor/github.com/alecthomas/chroma/v2/styles/base16-snazzy.go new file mode 100644 index 0000000..731dba8 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/base16-snazzy.go @@ -0,0 +1,81 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Base16Snazzy style +var Base16Snazzy = Register(chroma.MustNewStyle("base16-snazzy", chroma.StyleEntries{ + chroma.Comment: "#78787e", + chroma.CommentHashbang: "#78787e", + chroma.CommentMultiline: "#78787e", + chroma.CommentPreproc: "#78787e", + chroma.CommentSingle: "#78787e", + chroma.CommentSpecial: "#78787e", + chroma.Generic: "#e2e4e5", + chroma.GenericDeleted: "#ff5c57", + chroma.GenericEmph: "#e2e4e5 underline", + chroma.GenericError: "#ff5c57", + chroma.GenericHeading: "#e2e4e5 bold", + chroma.GenericInserted: "#e2e4e5 bold", + chroma.GenericOutput: "#43454f", + chroma.GenericPrompt: "#e2e4e5", + chroma.GenericStrong: "#e2e4e5 italic", + chroma.GenericSubheading: "#e2e4e5 bold", + chroma.GenericTraceback: "#e2e4e5", + chroma.GenericUnderline: "underline", + chroma.Error: "#ff5c57", + chroma.Keyword: "#ff6ac1", + chroma.KeywordConstant: "#ff6ac1", + chroma.KeywordDeclaration: "#ff5c57", + chroma.KeywordNamespace: "#ff6ac1", + chroma.KeywordPseudo: "#ff6ac1", + chroma.KeywordReserved: "#ff6ac1", + chroma.KeywordType: "#9aedfe", + chroma.Literal: "#e2e4e5", + chroma.LiteralDate: "#e2e4e5", + chroma.Name: "#e2e4e5", + chroma.NameAttribute: "#57c7ff", + chroma.NameBuiltin: "#ff5c57", + chroma.NameBuiltinPseudo: "#e2e4e5", + chroma.NameClass: "#f3f99d", + chroma.NameConstant: "#ff9f43", + chroma.NameDecorator: "#ff9f43", + chroma.NameEntity: "#e2e4e5", + chroma.NameException: "#e2e4e5", + chroma.NameFunction: "#57c7ff", + chroma.NameLabel: "#ff5c57", + chroma.NameNamespace: "#e2e4e5", + chroma.NameOther: "#e2e4e5", + chroma.NameTag: "#ff6ac1", + chroma.NameVariable: "#ff5c57", + chroma.NameVariableClass: "#ff5c57", + chroma.NameVariableGlobal: "#ff5c57", + chroma.NameVariableInstance: "#ff5c57", + chroma.LiteralNumber: "#ff9f43", + chroma.LiteralNumberBin: "#ff9f43", + chroma.LiteralNumberFloat: "#ff9f43", + chroma.LiteralNumberHex: "#ff9f43", + chroma.LiteralNumberInteger: "#ff9f43", + chroma.LiteralNumberIntegerLong: "#ff9f43", + chroma.LiteralNumberOct: "#ff9f43", + chroma.Operator: "#ff6ac1", + chroma.OperatorWord: "#ff6ac1", + chroma.Other: "#e2e4e5", + chroma.Punctuation: "#e2e4e5", + chroma.LiteralString: "#5af78e", + chroma.LiteralStringBacktick: "#5af78e", + chroma.LiteralStringChar: "#5af78e", + chroma.LiteralStringDoc: "#5af78e", + chroma.LiteralStringDouble: "#5af78e", + chroma.LiteralStringEscape: "#5af78e", + chroma.LiteralStringHeredoc: "#5af78e", + chroma.LiteralStringInterpol: "#5af78e", + chroma.LiteralStringOther: "#5af78e", + chroma.LiteralStringRegex: "#5af78e", + chroma.LiteralStringSingle: "#5af78e", + chroma.LiteralStringSymbol: "#5af78e", + chroma.Text: "#e2e4e5", + chroma.TextWhitespace: "#e2e4e5", + chroma.Background: " bg:#282a36", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/borland.go b/vendor/github.com/alecthomas/chroma/v2/styles/borland.go new file mode 100644 index 0000000..4d192b1 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/borland.go @@ -0,0 +1,33 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Borland style. +var Borland = Register(chroma.MustNewStyle("borland", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "italic #008800", + chroma.CommentPreproc: "noitalic #008080", + chroma.CommentSpecial: "noitalic bold", + chroma.LiteralString: "#0000FF", + chroma.LiteralStringChar: "#800080", + chroma.LiteralNumber: "#0000FF", + chroma.Keyword: "bold #000080", + chroma.OperatorWord: "bold", + chroma.NameTag: "bold #000080", + chroma.NameAttribute: "#FF0000", + chroma.GenericHeading: "#999999", + chroma.GenericSubheading: "#aaaaaa", + chroma.GenericDeleted: "bg:#ffdddd #000000", + chroma.GenericInserted: "bg:#ddffdd #000000", + chroma.GenericError: "#aa0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "#555555", + chroma.GenericOutput: "#888888", + chroma.GenericTraceback: "#aa0000", + chroma.GenericUnderline: "underline", + chroma.Error: "bg:#e3d2d2 #a61717", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/bw.go b/vendor/github.com/alecthomas/chroma/v2/styles/bw.go new file mode 100644 index 0000000..2f41f20 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/bw.go @@ -0,0 +1,30 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// BlackWhite style. +var BlackWhite = Register(chroma.MustNewStyle("bw", chroma.StyleEntries{ + chroma.Comment: "italic", + chroma.CommentPreproc: "noitalic", + chroma.Keyword: "bold", + chroma.KeywordPseudo: "nobold", + chroma.KeywordType: "nobold", + chroma.OperatorWord: "bold", + chroma.NameClass: "bold", + chroma.NameNamespace: "bold", + chroma.NameException: "bold", + chroma.NameEntity: "bold", + chroma.NameTag: "bold", + chroma.LiteralString: "italic", + chroma.LiteralStringInterpol: "bold", + chroma.LiteralStringEscape: "bold", + chroma.GenericHeading: "bold", + chroma.GenericSubheading: "bold", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold", + chroma.Error: "border:#FF0000", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/colorful.go b/vendor/github.com/alecthomas/chroma/v2/styles/colorful.go new file mode 100644 index 0000000..69f0373 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/colorful.go @@ -0,0 +1,59 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Colorful style. +var Colorful = Register(chroma.MustNewStyle("colorful", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "#888", + chroma.CommentPreproc: "#579", + chroma.CommentSpecial: "bold #cc0000", + chroma.Keyword: "bold #080", + chroma.KeywordPseudo: "#038", + chroma.KeywordType: "#339", + chroma.Operator: "#333", + chroma.OperatorWord: "bold #000", + chroma.NameBuiltin: "#007020", + chroma.NameFunction: "bold #06B", + chroma.NameClass: "bold #B06", + chroma.NameNamespace: "bold #0e84b5", + chroma.NameException: "bold #F00", + chroma.NameVariable: "#963", + chroma.NameVariableInstance: "#33B", + chroma.NameVariableClass: "#369", + chroma.NameVariableGlobal: "bold #d70", + chroma.NameConstant: "bold #036", + chroma.NameLabel: "bold #970", + chroma.NameEntity: "bold #800", + chroma.NameAttribute: "#00C", + chroma.NameTag: "#070", + chroma.NameDecorator: "bold #555", + chroma.LiteralString: "bg:#fff0f0", + chroma.LiteralStringChar: "#04D bg:", + chroma.LiteralStringDoc: "#D42 bg:", + chroma.LiteralStringInterpol: "bg:#eee", + chroma.LiteralStringEscape: "bold #666", + chroma.LiteralStringRegex: "bg:#fff0ff #000", + chroma.LiteralStringSymbol: "#A60 bg:", + chroma.LiteralStringOther: "#D20", + chroma.LiteralNumber: "bold #60E", + chroma.LiteralNumberInteger: "bold #00D", + chroma.LiteralNumberFloat: "bold #60E", + chroma.LiteralNumberHex: "bold #058", + chroma.LiteralNumberOct: "bold #40E", + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#A00000", + chroma.GenericInserted: "#00A000", + chroma.GenericError: "#FF0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold #c65d09", + chroma.GenericOutput: "#888", + chroma.GenericTraceback: "#04D", + chroma.GenericUnderline: "underline", + chroma.Error: "#F00 bg:#FAA", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/doom-one.go b/vendor/github.com/alecthomas/chroma/v2/styles/doom-one.go new file mode 100644 index 0000000..8bca8aa --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/doom-one.go @@ -0,0 +1,58 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Doom One style. Inspired by Atom One and Doom Emacs's Atom One theme +var DoomOne = Register(chroma.MustNewStyle("doom-one", chroma.StyleEntries{ + chroma.Text: "#b0c4de", + chroma.Error: "#b0c4de", + chroma.Comment: "italic #8a93a5", + chroma.CommentHashbang: "bold", + chroma.Keyword: "#c678dd", + chroma.KeywordType: "#ef8383", + chroma.KeywordConstant: "bold #b756ff", + chroma.Operator: "#c7bf54", + chroma.OperatorWord: "bold #b756ff", + chroma.Punctuation: "#b0c4de", + chroma.Name: "#c1abea", + chroma.NameAttribute: "#b3d23c", + chroma.NameBuiltin: "#ef8383", + chroma.NameClass: "#76a9f9", + chroma.NameConstant: "bold #b756ff", + chroma.NameDecorator: "#e5c07b", + chroma.NameEntity: "#bda26f", + chroma.NameException: "bold #fd7474", + chroma.NameFunction: "#00b1f7", + chroma.NameProperty: "#cebc3a", + chroma.NameLabel: "#f5a40d", + chroma.NameNamespace: "#76a9f9", + chroma.NameTag: "#e06c75", + chroma.NameVariable: "#DCAEEA", + chroma.NameVariableGlobal: "bold #DCAEEA", + chroma.NameVariableInstance: "#e06c75", + chroma.Literal: "#98c379", + chroma.Number: "#d19a66", + chroma.String: "#98c379", + chroma.StringDoc: "#7e97c3", + chroma.StringDouble: "#63c381", + chroma.StringEscape: "bold #d26464", + chroma.StringHeredoc: "#98c379", + chroma.StringInterpol: "#98c379", + chroma.StringOther: "#70b33f", + chroma.StringRegex: "#56b6c2", + chroma.StringSingle: "#98c379", + chroma.StringSymbol: "#56b6c2", + chroma.Generic: "#b0c4de", + chroma.GenericEmph: "italic", + chroma.GenericHeading: "bold #a2cbff", + chroma.GenericInserted: "#a6e22e", + chroma.GenericOutput: "#a6e22e", + chroma.GenericUnderline: "underline", + chroma.GenericPrompt: "#a6e22e", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "#a2cbff", + chroma.GenericTraceback: "#a2cbff", + chroma.Background: "#b0c4de bg:#282c34", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/doom-one2.go b/vendor/github.com/alecthomas/chroma/v2/styles/doom-one2.go new file mode 100644 index 0000000..080f6d7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/doom-one2.go @@ -0,0 +1,71 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Doom One 2 style. Inspired by Atom One and Doom Emacs's Atom One theme +var DoomOne2 = Register(chroma.MustNewStyle("doom-one2", chroma.StyleEntries{ + chroma.Text: "#b0c4de", + chroma.Error: "#b0c4de", + chroma.Comment: "italic #8a93a5", + chroma.CommentHashbang: "bold", + chroma.Keyword: "#76a9f9", + chroma.KeywordConstant: "#e5c07b", + chroma.KeywordType: "#e5c07b", + chroma.Operator: "#54b1c7", + chroma.OperatorWord: "bold #b756ff", + chroma.Punctuation: "#abb2bf", + chroma.Name: "#aa89ea", + chroma.NameAttribute: "#cebc3a", + chroma.NameBuiltin: "#e5c07b", + chroma.NameClass: "#ca72ff", + chroma.NameConstant: "bold", + chroma.NameDecorator: "#e5c07b", + chroma.NameEntity: "#bda26f", + chroma.NameException: "bold #fd7474", + chroma.NameFunction: "#00b1f7", + chroma.NameProperty: "#cebc3a", + chroma.NameLabel: "#f5a40d", + chroma.NameNamespace: "#ca72ff", + chroma.NameTag: "#76a9f9", + chroma.NameVariable: "#DCAEEA", + chroma.NameVariableClass: "#DCAEEA", + chroma.NameVariableGlobal: "bold #DCAEEA", + chroma.NameVariableInstance: "#e06c75", + chroma.NameVariableMagic: "#DCAEEA", + chroma.Literal: "#98c379", + chroma.LiteralDate: "#98c379", + chroma.Number: "#d19a66", + chroma.NumberBin: "#d19a66", + chroma.NumberFloat: "#d19a66", + chroma.NumberHex: "#d19a66", + chroma.NumberInteger: "#d19a66", + chroma.NumberIntegerLong: "#d19a66", + chroma.NumberOct: "#d19a66", + chroma.String: "#98c379", + chroma.StringAffix: "#98c379", + chroma.StringBacktick: "#98c379", + chroma.StringDelimiter: "#98c379", + chroma.StringDoc: "#7e97c3", + chroma.StringDouble: "#63c381", + chroma.StringEscape: "bold #d26464", + chroma.StringHeredoc: "#98c379", + chroma.StringInterpol: "#98c379", + chroma.StringOther: "#70b33f", + chroma.StringRegex: "#56b6c2", + chroma.StringSingle: "#98c379", + chroma.StringSymbol: "#56b6c2", + chroma.Generic: "#b0c4de", + chroma.GenericDeleted: "#b0c4de", + chroma.GenericEmph: "italic", + chroma.GenericHeading: "bold #a2cbff", + chroma.GenericInserted: "#a6e22e", + chroma.GenericOutput: "#a6e22e", + chroma.GenericUnderline: "underline", + chroma.GenericPrompt: "#a6e22e", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "#a2cbff", + chroma.GenericTraceback: "#a2cbff", + chroma.Background: "#b0c4de bg:#282c34", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/dracula.go b/vendor/github.com/alecthomas/chroma/v2/styles/dracula.go new file mode 100644 index 0000000..67fdfca --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/dracula.go @@ -0,0 +1,81 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Dracula Style +var Dracula = Register(chroma.MustNewStyle("dracula", chroma.StyleEntries{ + chroma.Comment: "#6272a4", + chroma.CommentHashbang: "#6272a4", + chroma.CommentMultiline: "#6272a4", + chroma.CommentPreproc: "#ff79c6", + chroma.CommentSingle: "#6272a4", + chroma.CommentSpecial: "#6272a4", + chroma.Generic: "#f8f8f2", + chroma.GenericDeleted: "#ff5555", + chroma.GenericEmph: "#f8f8f2 underline", + chroma.GenericError: "#f8f8f2", + chroma.GenericHeading: "#f8f8f2 bold", + chroma.GenericInserted: "#50fa7b bold", + chroma.GenericOutput: "#44475a", + chroma.GenericPrompt: "#f8f8f2", + chroma.GenericStrong: "#f8f8f2", + chroma.GenericSubheading: "#f8f8f2 bold", + chroma.GenericTraceback: "#f8f8f2", + chroma.GenericUnderline: "underline", + chroma.Error: "#f8f8f2", + chroma.Keyword: "#ff79c6", + chroma.KeywordConstant: "#ff79c6", + chroma.KeywordDeclaration: "#8be9fd italic", + chroma.KeywordNamespace: "#ff79c6", + chroma.KeywordPseudo: "#ff79c6", + chroma.KeywordReserved: "#ff79c6", + chroma.KeywordType: "#8be9fd", + chroma.Literal: "#f8f8f2", + chroma.LiteralDate: "#f8f8f2", + chroma.Name: "#f8f8f2", + chroma.NameAttribute: "#50fa7b", + chroma.NameBuiltin: "#8be9fd italic", + chroma.NameBuiltinPseudo: "#f8f8f2", + chroma.NameClass: "#50fa7b", + chroma.NameConstant: "#f8f8f2", + chroma.NameDecorator: "#f8f8f2", + chroma.NameEntity: "#f8f8f2", + chroma.NameException: "#f8f8f2", + chroma.NameFunction: "#50fa7b", + chroma.NameLabel: "#8be9fd italic", + chroma.NameNamespace: "#f8f8f2", + chroma.NameOther: "#f8f8f2", + chroma.NameTag: "#ff79c6", + chroma.NameVariable: "#8be9fd italic", + chroma.NameVariableClass: "#8be9fd italic", + chroma.NameVariableGlobal: "#8be9fd italic", + chroma.NameVariableInstance: "#8be9fd italic", + chroma.LiteralNumber: "#bd93f9", + chroma.LiteralNumberBin: "#bd93f9", + chroma.LiteralNumberFloat: "#bd93f9", + chroma.LiteralNumberHex: "#bd93f9", + chroma.LiteralNumberInteger: "#bd93f9", + chroma.LiteralNumberIntegerLong: "#bd93f9", + chroma.LiteralNumberOct: "#bd93f9", + chroma.Operator: "#ff79c6", + chroma.OperatorWord: "#ff79c6", + chroma.Other: "#f8f8f2", + chroma.Punctuation: "#f8f8f2", + chroma.LiteralString: "#f1fa8c", + chroma.LiteralStringBacktick: "#f1fa8c", + chroma.LiteralStringChar: "#f1fa8c", + chroma.LiteralStringDoc: "#f1fa8c", + chroma.LiteralStringDouble: "#f1fa8c", + chroma.LiteralStringEscape: "#f1fa8c", + chroma.LiteralStringHeredoc: "#f1fa8c", + chroma.LiteralStringInterpol: "#f1fa8c", + chroma.LiteralStringOther: "#f1fa8c", + chroma.LiteralStringRegex: "#f1fa8c", + chroma.LiteralStringSingle: "#f1fa8c", + chroma.LiteralStringSymbol: "#f1fa8c", + chroma.Text: "#f8f8f2", + chroma.TextWhitespace: "#f8f8f2", + chroma.Background: " bg:#282a36", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/emacs.go b/vendor/github.com/alecthomas/chroma/v2/styles/emacs.go new file mode 100644 index 0000000..461f197 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/emacs.go @@ -0,0 +1,51 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Emacs style. +var Emacs = Register(chroma.MustNewStyle("emacs", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "italic #008800", + chroma.CommentPreproc: "noitalic", + chroma.CommentSpecial: "noitalic bold", + chroma.Keyword: "bold #AA22FF", + chroma.KeywordPseudo: "nobold", + chroma.KeywordType: "bold #00BB00", + chroma.Operator: "#666666", + chroma.OperatorWord: "bold #AA22FF", + chroma.NameBuiltin: "#AA22FF", + chroma.NameFunction: "#00A000", + chroma.NameClass: "#0000FF", + chroma.NameNamespace: "bold #0000FF", + chroma.NameException: "bold #D2413A", + chroma.NameVariable: "#B8860B", + chroma.NameConstant: "#880000", + chroma.NameLabel: "#A0A000", + chroma.NameEntity: "bold #999999", + chroma.NameAttribute: "#BB4444", + chroma.NameTag: "bold #008000", + chroma.NameDecorator: "#AA22FF", + chroma.LiteralString: "#BB4444", + chroma.LiteralStringDoc: "italic", + chroma.LiteralStringInterpol: "bold #BB6688", + chroma.LiteralStringEscape: "bold #BB6622", + chroma.LiteralStringRegex: "#BB6688", + chroma.LiteralStringSymbol: "#B8860B", + chroma.LiteralStringOther: "#008000", + chroma.LiteralNumber: "#666666", + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#A00000", + chroma.GenericInserted: "#00A000", + chroma.GenericError: "#FF0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold #000080", + chroma.GenericOutput: "#888", + chroma.GenericTraceback: "#04D", + chroma.GenericUnderline: "underline", + chroma.Error: "border:#FF0000", + chroma.Background: " bg:#f8f8f8", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/friendly.go b/vendor/github.com/alecthomas/chroma/v2/styles/friendly.go new file mode 100644 index 0000000..572d017 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/friendly.go @@ -0,0 +1,51 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Friendly style. +var Friendly = Register(chroma.MustNewStyle("friendly", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "italic #60a0b0", + chroma.CommentPreproc: "noitalic #007020", + chroma.CommentSpecial: "noitalic bg:#fff0f0", + chroma.Keyword: "bold #007020", + chroma.KeywordPseudo: "nobold", + chroma.KeywordType: "nobold #902000", + chroma.Operator: "#666666", + chroma.OperatorWord: "bold #007020", + chroma.NameBuiltin: "#007020", + chroma.NameFunction: "#06287e", + chroma.NameClass: "bold #0e84b5", + chroma.NameNamespace: "bold #0e84b5", + chroma.NameException: "#007020", + chroma.NameVariable: "#bb60d5", + chroma.NameConstant: "#60add5", + chroma.NameLabel: "bold #002070", + chroma.NameEntity: "bold #d55537", + chroma.NameAttribute: "#4070a0", + chroma.NameTag: "bold #062873", + chroma.NameDecorator: "bold #555555", + chroma.LiteralString: "#4070a0", + chroma.LiteralStringDoc: "italic", + chroma.LiteralStringInterpol: "#70a0d0", + chroma.LiteralStringEscape: "bold #4070a0", + chroma.LiteralStringRegex: "#235388", + chroma.LiteralStringSymbol: "#517918", + chroma.LiteralStringOther: "#c65d09", + chroma.LiteralNumber: "#40a070", + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#A00000", + chroma.GenericInserted: "#00A000", + chroma.GenericError: "#FF0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold #c65d09", + chroma.GenericOutput: "#888", + chroma.GenericTraceback: "#04D", + chroma.GenericUnderline: "underline", + chroma.Error: "border:#FF0000", + chroma.Background: " bg:#f0f0f0", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/fruity.go b/vendor/github.com/alecthomas/chroma/v2/styles/fruity.go new file mode 100644 index 0000000..6ed99b7 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/fruity.go @@ -0,0 +1,26 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Fruity style. +var Fruity = Register(chroma.MustNewStyle("fruity", chroma.StyleEntries{ + chroma.TextWhitespace: "#888888", + chroma.Background: "#ffffff bg:#111111", + chroma.GenericOutput: "#444444 bg:#222222", + chroma.Keyword: "#fb660a bold", + chroma.KeywordPseudo: "nobold", + chroma.LiteralNumber: "#0086f7 bold", + chroma.NameTag: "#fb660a bold", + chroma.NameVariable: "#fb660a", + chroma.Comment: "#008800 bg:#0f140f italic", + chroma.NameAttribute: "#ff0086 bold", + chroma.LiteralString: "#0086d2", + chroma.NameFunction: "#ff0086 bold", + chroma.GenericHeading: "#ffffff bold", + chroma.KeywordType: "#cdcaa9 bold", + chroma.GenericSubheading: "#ffffff bold", + chroma.NameConstant: "#0086d2", + chroma.CommentPreproc: "#ff0007 bold", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/github.go b/vendor/github.com/alecthomas/chroma/v2/styles/github.go new file mode 100644 index 0000000..b1ef17f --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/github.go @@ -0,0 +1,51 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// GitHub style. +var GitHub = Register(chroma.MustNewStyle("github", chroma.StyleEntries{ + chroma.CommentMultiline: "italic #999988", + chroma.CommentPreproc: "bold #999999", + chroma.CommentSingle: "italic #999988", + chroma.CommentSpecial: "bold italic #999999", + chroma.Comment: "italic #999988", + chroma.Error: "bg:#e3d2d2 #a61717", + chroma.GenericDeleted: "bg:#ffdddd #000000", + chroma.GenericEmph: "italic #000000", + chroma.GenericError: "#aa0000", + chroma.GenericHeading: "#999999", + chroma.GenericInserted: "bg:#ddffdd #000000", + chroma.GenericOutput: "#888888", + chroma.GenericPrompt: "#555555", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "#aaaaaa", + chroma.GenericTraceback: "#aa0000", + chroma.GenericUnderline: "underline", + chroma.KeywordType: "bold #445588", + chroma.Keyword: "bold #000000", + chroma.LiteralNumber: "#009999", + chroma.LiteralStringRegex: "#009926", + chroma.LiteralStringSymbol: "#990073", + chroma.LiteralString: "#d14", + chroma.NameAttribute: "#008080", + chroma.NameBuiltinPseudo: "#999999", + chroma.NameBuiltin: "#0086B3", + chroma.NameClass: "bold #445588", + chroma.NameConstant: "#008080", + chroma.NameDecorator: "bold #3c5d5d", + chroma.NameEntity: "#800080", + chroma.NameException: "bold #990000", + chroma.NameFunction: "bold #990000", + chroma.NameLabel: "bold #990000", + chroma.NameNamespace: "#555555", + chroma.NameTag: "#000080", + chroma.NameVariableClass: "#008080", + chroma.NameVariableGlobal: "#008080", + chroma.NameVariableInstance: "#008080", + chroma.NameVariable: "#008080", + chroma.Operator: "bold #000000", + chroma.TextWhitespace: "#bbbbbb", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/gruvbox.go b/vendor/github.com/alecthomas/chroma/v2/styles/gruvbox.go new file mode 100644 index 0000000..44ccf9b --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/gruvbox.go @@ -0,0 +1,40 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Gruvbox style. +var Gruvbox = Register(chroma.MustNewStyle("gruvbox", chroma.StyleEntries{ + chroma.CommentPreproc: "noinherit #8ec07c", + chroma.Comment: "#928374 italic", + chroma.GenericDeleted: "noinherit #282828 bg:#fb4934", + chroma.GenericEmph: "#83a598 underline", + chroma.GenericError: "bg:#fb4934 bold", + chroma.GenericHeading: "#b8bb26 bold", + chroma.GenericInserted: "noinherit #282828 bg:#b8bb26", + chroma.GenericOutput: "noinherit #504945", + chroma.GenericPrompt: "#ebdbb2", + chroma.GenericStrong: "#ebdbb2", + chroma.GenericSubheading: "#b8bb26 bold", + chroma.GenericTraceback: "bg:#fb4934 bold", + chroma.Generic: "#ebdbb2", + chroma.KeywordType: "noinherit #fabd2f", + chroma.Keyword: "noinherit #fe8019", + chroma.NameAttribute: "#b8bb26 bold", + chroma.NameBuiltin: "#fabd2f", + chroma.NameConstant: "noinherit #d3869b", + chroma.NameEntity: "noinherit #fabd2f", + chroma.NameException: "noinherit #fb4934", + chroma.NameFunction: "#fabd2f", + chroma.NameLabel: "noinherit #fb4934", + chroma.NameTag: "noinherit #fb4934", + chroma.NameVariable: "noinherit #ebdbb2", + chroma.Name: "#ebdbb2", + chroma.LiteralNumberFloat: "noinherit #d3869b", + chroma.LiteralNumber: "noinherit #d3869b", + chroma.Operator: "#fe8019", + chroma.LiteralStringSymbol: "#83a598", + chroma.LiteralString: "noinherit #b8bb26", + chroma.Background: "noinherit #ebdbb2 bg:#282828 bg:#282828", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/hr_dark.go b/vendor/github.com/alecthomas/chroma/v2/styles/hr_dark.go new file mode 100644 index 0000000..74867f6 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/hr_dark.go @@ -0,0 +1,17 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Theme based on HackerRank Dark Editor theme +var HrDark = Register(chroma.MustNewStyle("hrdark", chroma.StyleEntries{ + chroma.Comment: "italic #828b96", + chroma.Keyword: "#ff636f", + chroma.OperatorWord: "#ff636f", + chroma.Name: "#58a1dd", + chroma.Literal: "#a6be9d", + chroma.Operator: "#ff636f", + chroma.Background: "#1d2432", + chroma.Other: "#fff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/hr_high_contrast.go b/vendor/github.com/alecthomas/chroma/v2/styles/hr_high_contrast.go new file mode 100644 index 0000000..6bf2eb2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/hr_high_contrast.go @@ -0,0 +1,19 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Theme based on HackerRank High Contrast Editor Theme +var HrHighContrast = Register(chroma.MustNewStyle("hr_high_contrast", chroma.StyleEntries{ + chroma.Comment: "#5a8349", + chroma.Keyword: "#467faf", + chroma.OperatorWord: "#467faf", + chroma.Name: "#ffffff", + chroma.LiteralString: "#a87662", + chroma.LiteralNumber: "#fff", + chroma.LiteralStringBoolean: "#467faf", + chroma.Operator: "#e4e400", + chroma.Background: "#000", + chroma.Other: "#d5d500", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/igor.go b/vendor/github.com/alecthomas/chroma/v2/styles/igor.go new file mode 100644 index 0000000..fef8eee --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/igor.go @@ -0,0 +1,16 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Igor style. +var Igor = Register(chroma.MustNewStyle("igor", chroma.StyleEntries{ + chroma.Comment: "italic #FF0000", + chroma.Keyword: "#0000FF", + chroma.NameFunction: "#C34E00", + chroma.NameDecorator: "#CC00A3", + chroma.NameClass: "#007575", + chroma.LiteralString: "#009C00", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/lovelace.go b/vendor/github.com/alecthomas/chroma/v2/styles/lovelace.go new file mode 100644 index 0000000..9099920 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/lovelace.go @@ -0,0 +1,60 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Lovelace style. +var Lovelace = Register(chroma.MustNewStyle("lovelace", chroma.StyleEntries{ + chroma.TextWhitespace: "#a89028", + chroma.Comment: "italic #888888", + chroma.CommentHashbang: "#287088", + chroma.CommentMultiline: "#888888", + chroma.CommentPreproc: "noitalic #289870", + chroma.Keyword: "#2838b0", + chroma.KeywordConstant: "italic #444444", + chroma.KeywordDeclaration: "italic", + chroma.KeywordType: "italic", + chroma.Operator: "#666666", + chroma.OperatorWord: "#a848a8", + chroma.Punctuation: "#888888", + chroma.NameAttribute: "#388038", + chroma.NameBuiltin: "#388038", + chroma.NameBuiltinPseudo: "italic", + chroma.NameClass: "#287088", + chroma.NameConstant: "#b85820", + chroma.NameDecorator: "#287088", + chroma.NameEntity: "#709030", + chroma.NameException: "#908828", + chroma.NameFunction: "#785840", + chroma.NameFunctionMagic: "#b85820", + chroma.NameLabel: "#289870", + chroma.NameNamespace: "#289870", + chroma.NameTag: "#2838b0", + chroma.NameVariable: "#b04040", + chroma.NameVariableGlobal: "#908828", + chroma.NameVariableMagic: "#b85820", + chroma.LiteralString: "#b83838", + chroma.LiteralStringAffix: "#444444", + chroma.LiteralStringChar: "#a848a8", + chroma.LiteralStringDelimiter: "#b85820", + chroma.LiteralStringDoc: "italic #b85820", + chroma.LiteralStringEscape: "#709030", + chroma.LiteralStringInterpol: "underline", + chroma.LiteralStringOther: "#a848a8", + chroma.LiteralStringRegex: "#a848a8", + chroma.LiteralNumber: "#444444", + chroma.GenericDeleted: "#c02828", + chroma.GenericEmph: "italic", + chroma.GenericError: "#c02828", + chroma.GenericHeading: "#666666", + chroma.GenericSubheading: "#444444", + chroma.GenericInserted: "#388038", + chroma.GenericOutput: "#666666", + chroma.GenericPrompt: "#444444", + chroma.GenericStrong: "bold", + chroma.GenericTraceback: "#2838b0", + chroma.GenericUnderline: "underline", + chroma.Error: "bg:#a848a8", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/manni.go b/vendor/github.com/alecthomas/chroma/v2/styles/manni.go new file mode 100644 index 0000000..c958176 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/manni.go @@ -0,0 +1,51 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Manni style. +var Manni = Register(chroma.MustNewStyle("manni", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "italic #0099FF", + chroma.CommentPreproc: "noitalic #009999", + chroma.CommentSpecial: "bold", + chroma.Keyword: "bold #006699", + chroma.KeywordPseudo: "nobold", + chroma.KeywordType: "#007788", + chroma.Operator: "#555555", + chroma.OperatorWord: "bold #000000", + chroma.NameBuiltin: "#336666", + chroma.NameFunction: "#CC00FF", + chroma.NameClass: "bold #00AA88", + chroma.NameNamespace: "bold #00CCFF", + chroma.NameException: "bold #CC0000", + chroma.NameVariable: "#003333", + chroma.NameConstant: "#336600", + chroma.NameLabel: "#9999FF", + chroma.NameEntity: "bold #999999", + chroma.NameAttribute: "#330099", + chroma.NameTag: "bold #330099", + chroma.NameDecorator: "#9999FF", + chroma.LiteralString: "#CC3300", + chroma.LiteralStringDoc: "italic", + chroma.LiteralStringInterpol: "#AA0000", + chroma.LiteralStringEscape: "bold #CC3300", + chroma.LiteralStringRegex: "#33AAAA", + chroma.LiteralStringSymbol: "#FFCC33", + chroma.LiteralStringOther: "#CC3300", + chroma.LiteralNumber: "#FF6600", + chroma.GenericHeading: "bold #003300", + chroma.GenericSubheading: "bold #003300", + chroma.GenericDeleted: "border:#CC0000 bg:#FFCCCC", + chroma.GenericInserted: "border:#00CC00 bg:#CCFFCC", + chroma.GenericError: "#FF0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold #000099", + chroma.GenericOutput: "#AAAAAA", + chroma.GenericTraceback: "#99CC66", + chroma.GenericUnderline: "underline", + chroma.Error: "bg:#FFAAAA #AA0000", + chroma.Background: " bg:#f0f3f3", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/monokai.go b/vendor/github.com/alecthomas/chroma/v2/styles/monokai.go new file mode 100644 index 0000000..85647a2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/monokai.go @@ -0,0 +1,36 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Monokai style. +var Monokai = Register(chroma.MustNewStyle("monokai", chroma.StyleEntries{ + chroma.Text: "#f8f8f2", + chroma.Error: "#960050 bg:#1e0010", + chroma.Comment: "#75715e", + chroma.Keyword: "#66d9ef", + chroma.KeywordNamespace: "#f92672", + chroma.Operator: "#f92672", + chroma.Punctuation: "#f8f8f2", + chroma.Name: "#f8f8f2", + chroma.NameAttribute: "#a6e22e", + chroma.NameClass: "#a6e22e", + chroma.NameConstant: "#66d9ef", + chroma.NameDecorator: "#a6e22e", + chroma.NameException: "#a6e22e", + chroma.NameFunction: "#a6e22e", + chroma.NameOther: "#a6e22e", + chroma.NameTag: "#f92672", + chroma.LiteralNumber: "#ae81ff", + chroma.Literal: "#ae81ff", + chroma.LiteralDate: "#e6db74", + chroma.LiteralString: "#e6db74", + chroma.LiteralStringEscape: "#ae81ff", + chroma.GenericDeleted: "#f92672", + chroma.GenericEmph: "italic", + chroma.GenericInserted: "#a6e22e", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "#75715e", + chroma.Background: "bg:#272822", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/monokailight.go b/vendor/github.com/alecthomas/chroma/v2/styles/monokailight.go new file mode 100644 index 0000000..74af78e --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/monokailight.go @@ -0,0 +1,33 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// MonokaiLight style. +var MonokaiLight = Register(chroma.MustNewStyle("monokailight", chroma.StyleEntries{ + chroma.Text: "#272822", + chroma.Error: "#960050 bg:#1e0010", + chroma.Comment: "#75715e", + chroma.Keyword: "#00a8c8", + chroma.KeywordNamespace: "#f92672", + chroma.Operator: "#f92672", + chroma.Punctuation: "#111111", + chroma.Name: "#111111", + chroma.NameAttribute: "#75af00", + chroma.NameClass: "#75af00", + chroma.NameConstant: "#00a8c8", + chroma.NameDecorator: "#75af00", + chroma.NameException: "#75af00", + chroma.NameFunction: "#75af00", + chroma.NameOther: "#75af00", + chroma.NameTag: "#f92672", + chroma.LiteralNumber: "#ae81ff", + chroma.Literal: "#ae81ff", + chroma.LiteralDate: "#d88200", + chroma.LiteralString: "#d88200", + chroma.LiteralStringEscape: "#8045FF", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.Background: " bg:#fafafa", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/murphy.go b/vendor/github.com/alecthomas/chroma/v2/styles/murphy.go new file mode 100644 index 0000000..d0d6ae0 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/murphy.go @@ -0,0 +1,59 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Murphy style. +var Murphy = Register(chroma.MustNewStyle("murphy", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "#666 italic", + chroma.CommentPreproc: "#579 noitalic", + chroma.CommentSpecial: "#c00 bold", + chroma.Keyword: "bold #289", + chroma.KeywordPseudo: "#08f", + chroma.KeywordType: "#66f", + chroma.Operator: "#333", + chroma.OperatorWord: "bold #000", + chroma.NameBuiltin: "#072", + chroma.NameFunction: "bold #5ed", + chroma.NameClass: "bold #e9e", + chroma.NameNamespace: "bold #0e84b5", + chroma.NameException: "bold #F00", + chroma.NameVariable: "#036", + chroma.NameVariableInstance: "#aaf", + chroma.NameVariableClass: "#ccf", + chroma.NameVariableGlobal: "#f84", + chroma.NameConstant: "bold #5ed", + chroma.NameLabel: "bold #970", + chroma.NameEntity: "#800", + chroma.NameAttribute: "#007", + chroma.NameTag: "#070", + chroma.NameDecorator: "bold #555", + chroma.LiteralString: "bg:#e0e0ff", + chroma.LiteralStringChar: "#88F bg:", + chroma.LiteralStringDoc: "#D42 bg:", + chroma.LiteralStringInterpol: "bg:#eee", + chroma.LiteralStringEscape: "bold #666", + chroma.LiteralStringRegex: "bg:#e0e0ff #000", + chroma.LiteralStringSymbol: "#fc8 bg:", + chroma.LiteralStringOther: "#f88", + chroma.LiteralNumber: "bold #60E", + chroma.LiteralNumberInteger: "bold #66f", + chroma.LiteralNumberFloat: "bold #60E", + chroma.LiteralNumberHex: "bold #058", + chroma.LiteralNumberOct: "bold #40E", + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#A00000", + chroma.GenericInserted: "#00A000", + chroma.GenericError: "#FF0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold #c65d09", + chroma.GenericOutput: "#888", + chroma.GenericTraceback: "#04D", + chroma.GenericUnderline: "underline", + chroma.Error: "#F00 bg:#FAA", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/native.go b/vendor/github.com/alecthomas/chroma/v2/styles/native.go new file mode 100644 index 0000000..2c6dfdb --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/native.go @@ -0,0 +1,42 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Native style. +var Native = Register(chroma.MustNewStyle("native", chroma.StyleEntries{ + chroma.Background: "#d0d0d0 bg:#202020", + chroma.TextWhitespace: "#666666", + chroma.Comment: "italic #999999", + chroma.CommentPreproc: "noitalic bold #cd2828", + chroma.CommentSpecial: "noitalic bold #e50808 bg:#520000", + chroma.Keyword: "bold #6ab825", + chroma.KeywordPseudo: "nobold", + chroma.OperatorWord: "bold #6ab825", + chroma.LiteralString: "#ed9d13", + chroma.LiteralStringOther: "#ffa500", + chroma.LiteralNumber: "#3677a9", + chroma.NameBuiltin: "#24909d", + chroma.NameVariable: "#40ffff", + chroma.NameConstant: "#40ffff", + chroma.NameClass: "underline #447fcf", + chroma.NameFunction: "#447fcf", + chroma.NameNamespace: "underline #447fcf", + chroma.NameException: "#bbbbbb", + chroma.NameTag: "bold #6ab825", + chroma.NameAttribute: "#bbbbbb", + chroma.NameDecorator: "#ffa500", + chroma.GenericHeading: "bold #ffffff", + chroma.GenericSubheading: "underline #ffffff", + chroma.GenericDeleted: "#d22323", + chroma.GenericInserted: "#589819", + chroma.GenericError: "#d22323", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "#aaaaaa", + chroma.GenericOutput: "#cccccc", + chroma.GenericTraceback: "#d22323", + chroma.GenericUnderline: "underline", + chroma.Error: "bg:#e3d2d2 #a61717", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/nord.go b/vendor/github.com/alecthomas/chroma/v2/styles/nord.go new file mode 100644 index 0000000..7763541 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/nord.go @@ -0,0 +1,75 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +var ( + // colors and palettes based on https://www.nordtheme.com/docs/colors-and-palettes + nord0 = "#2e3440" + nord1 = "#3b4252" // nolint + nord2 = "#434c5e" // nolint + nord3 = "#4c566a" + nord3b = "#616e87" + + nord4 = "#d8dee9" + nord5 = "#e5e9f0" // nolint + nord6 = "#eceff4" + + nord7 = "#8fbcbb" + nord8 = "#88c0d0" + nord9 = "#81a1c1" + nord10 = "#5e81ac" + + nord11 = "#bf616a" + nord12 = "#d08770" + nord13 = "#ebcb8b" + nord14 = "#a3be8c" + nord15 = "#b48ead" +) + +// Nord, an arctic, north-bluish color palette +var Nord = Register(chroma.MustNewStyle("nord", chroma.StyleEntries{ + chroma.TextWhitespace: nord4, + chroma.Comment: "italic " + nord3b, + chroma.CommentPreproc: nord10, + chroma.Keyword: "bold " + nord9, + chroma.KeywordPseudo: "nobold " + nord9, + chroma.KeywordType: "nobold " + nord9, + chroma.Operator: nord9, + chroma.OperatorWord: "bold " + nord9, + chroma.Name: nord4, + chroma.NameBuiltin: nord9, + chroma.NameFunction: nord8, + chroma.NameClass: nord7, + chroma.NameNamespace: nord7, + chroma.NameException: nord11, + chroma.NameVariable: nord4, + chroma.NameConstant: nord7, + chroma.NameLabel: nord7, + chroma.NameEntity: nord12, + chroma.NameAttribute: nord7, + chroma.NameTag: nord9, + chroma.NameDecorator: nord12, + chroma.Punctuation: nord6, + chroma.LiteralString: nord14, + chroma.LiteralStringDoc: nord3b, + chroma.LiteralStringInterpol: nord14, + chroma.LiteralStringEscape: nord13, + chroma.LiteralStringRegex: nord13, + chroma.LiteralStringSymbol: nord14, + chroma.LiteralStringOther: nord14, + chroma.LiteralNumber: nord15, + chroma.GenericHeading: "bold " + nord8, + chroma.GenericSubheading: "bold " + nord8, + chroma.GenericDeleted: nord11, + chroma.GenericInserted: nord14, + chroma.GenericError: nord11, + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold " + nord3, + chroma.GenericOutput: nord4, + chroma.GenericTraceback: nord11, + chroma.Error: nord11, + chroma.Background: nord4 + " bg:" + nord0, +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/onesenterprise.go b/vendor/github.com/alecthomas/chroma/v2/styles/onesenterprise.go new file mode 100644 index 0000000..7273b03 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/onesenterprise.go @@ -0,0 +1,17 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// 1S:Designer color palette +var OnesEnterprise = Register(chroma.MustNewStyle("onesenterprise", chroma.StyleEntries{ + chroma.Text: "#000000", + chroma.Comment: "#008000", + chroma.CommentPreproc: "#963200", + chroma.Operator: "#FF0000", + chroma.Keyword: "#FF0000", + chroma.Punctuation: "#FF0000", + chroma.LiteralString: "#000000", + chroma.Name: "#0000FF", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/paraiso-dark.go b/vendor/github.com/alecthomas/chroma/v2/styles/paraiso-dark.go new file mode 100644 index 0000000..d0c534a --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/paraiso-dark.go @@ -0,0 +1,44 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// ParaisoDark style. +var ParaisoDark = Register(chroma.MustNewStyle("paraiso-dark", chroma.StyleEntries{ + chroma.Text: "#e7e9db", + chroma.Error: "#ef6155", + chroma.Comment: "#776e71", + chroma.Keyword: "#815ba4", + chroma.KeywordNamespace: "#5bc4bf", + chroma.KeywordType: "#fec418", + chroma.Operator: "#5bc4bf", + chroma.Punctuation: "#e7e9db", + chroma.Name: "#e7e9db", + chroma.NameAttribute: "#06b6ef", + chroma.NameClass: "#fec418", + chroma.NameConstant: "#ef6155", + chroma.NameDecorator: "#5bc4bf", + chroma.NameException: "#ef6155", + chroma.NameFunction: "#06b6ef", + chroma.NameNamespace: "#fec418", + chroma.NameOther: "#06b6ef", + chroma.NameTag: "#5bc4bf", + chroma.NameVariable: "#ef6155", + chroma.LiteralNumber: "#f99b15", + chroma.Literal: "#f99b15", + chroma.LiteralDate: "#48b685", + chroma.LiteralString: "#48b685", + chroma.LiteralStringChar: "#e7e9db", + chroma.LiteralStringDoc: "#776e71", + chroma.LiteralStringEscape: "#f99b15", + chroma.LiteralStringInterpol: "#f99b15", + chroma.GenericDeleted: "#ef6155", + chroma.GenericEmph: "italic", + chroma.GenericHeading: "bold #e7e9db", + chroma.GenericInserted: "#48b685", + chroma.GenericPrompt: "bold #776e71", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "bold #5bc4bf", + chroma.Background: "bg:#2f1e2e", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/paraiso-light.go b/vendor/github.com/alecthomas/chroma/v2/styles/paraiso-light.go new file mode 100644 index 0000000..4048b26 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/paraiso-light.go @@ -0,0 +1,44 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// ParaisoLight style. +var ParaisoLight = Register(chroma.MustNewStyle("paraiso-light", chroma.StyleEntries{ + chroma.Text: "#2f1e2e", + chroma.Error: "#ef6155", + chroma.Comment: "#8d8687", + chroma.Keyword: "#815ba4", + chroma.KeywordNamespace: "#5bc4bf", + chroma.KeywordType: "#fec418", + chroma.Operator: "#5bc4bf", + chroma.Punctuation: "#2f1e2e", + chroma.Name: "#2f1e2e", + chroma.NameAttribute: "#06b6ef", + chroma.NameClass: "#fec418", + chroma.NameConstant: "#ef6155", + chroma.NameDecorator: "#5bc4bf", + chroma.NameException: "#ef6155", + chroma.NameFunction: "#06b6ef", + chroma.NameNamespace: "#fec418", + chroma.NameOther: "#06b6ef", + chroma.NameTag: "#5bc4bf", + chroma.NameVariable: "#ef6155", + chroma.LiteralNumber: "#f99b15", + chroma.Literal: "#f99b15", + chroma.LiteralDate: "#48b685", + chroma.LiteralString: "#48b685", + chroma.LiteralStringChar: "#2f1e2e", + chroma.LiteralStringDoc: "#8d8687", + chroma.LiteralStringEscape: "#f99b15", + chroma.LiteralStringInterpol: "#f99b15", + chroma.GenericDeleted: "#ef6155", + chroma.GenericEmph: "italic", + chroma.GenericHeading: "bold #2f1e2e", + chroma.GenericInserted: "#48b685", + chroma.GenericPrompt: "bold #8d8687", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "bold #5bc4bf", + chroma.Background: "bg:#e7e9db", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/pastie.go b/vendor/github.com/alecthomas/chroma/v2/styles/pastie.go new file mode 100644 index 0000000..8e41b50 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/pastie.go @@ -0,0 +1,52 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Pastie style. +var Pastie = Register(chroma.MustNewStyle("pastie", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "#888888", + chroma.CommentPreproc: "bold #cc0000", + chroma.CommentSpecial: "bg:#fff0f0 bold #cc0000", + chroma.LiteralString: "bg:#fff0f0 #dd2200", + chroma.LiteralStringRegex: "bg:#fff0ff #008800", + chroma.LiteralStringOther: "bg:#f0fff0 #22bb22", + chroma.LiteralStringSymbol: "#aa6600", + chroma.LiteralStringInterpol: "#3333bb", + chroma.LiteralStringEscape: "#0044dd", + chroma.OperatorWord: "#008800", + chroma.Keyword: "bold #008800", + chroma.KeywordPseudo: "nobold", + chroma.KeywordType: "#888888", + chroma.NameClass: "bold #bb0066", + chroma.NameException: "bold #bb0066", + chroma.NameFunction: "bold #0066bb", + chroma.NameProperty: "bold #336699", + chroma.NameNamespace: "bold #bb0066", + chroma.NameBuiltin: "#003388", + chroma.NameVariable: "#336699", + chroma.NameVariableClass: "#336699", + chroma.NameVariableInstance: "#3333bb", + chroma.NameVariableGlobal: "#dd7700", + chroma.NameConstant: "bold #003366", + chroma.NameTag: "bold #bb0066", + chroma.NameAttribute: "#336699", + chroma.NameDecorator: "#555555", + chroma.NameLabel: "italic #336699", + chroma.LiteralNumber: "bold #0000DD", + chroma.GenericHeading: "#333", + chroma.GenericSubheading: "#666", + chroma.GenericDeleted: "bg:#ffdddd #000000", + chroma.GenericInserted: "bg:#ddffdd #000000", + chroma.GenericError: "#aa0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "#555555", + chroma.GenericOutput: "#888888", + chroma.GenericTraceback: "#aa0000", + chroma.GenericUnderline: "underline", + chroma.Error: "bg:#e3d2d2 #a61717", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/perldoc.go b/vendor/github.com/alecthomas/chroma/v2/styles/perldoc.go new file mode 100644 index 0000000..813b713 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/perldoc.go @@ -0,0 +1,44 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Perldoc style. +var Perldoc = Register(chroma.MustNewStyle("perldoc", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "#228B22", + chroma.CommentPreproc: "#1e889b", + chroma.CommentSpecial: "#8B008B bold", + chroma.LiteralString: "#CD5555", + chroma.LiteralStringHeredoc: "#1c7e71 italic", + chroma.LiteralStringRegex: "#1c7e71", + chroma.LiteralStringOther: "#cb6c20", + chroma.LiteralNumber: "#B452CD", + chroma.OperatorWord: "#8B008B", + chroma.Keyword: "#8B008B bold", + chroma.KeywordType: "#00688B", + chroma.NameClass: "#008b45 bold", + chroma.NameException: "#008b45 bold", + chroma.NameFunction: "#008b45", + chroma.NameNamespace: "#008b45 underline", + chroma.NameVariable: "#00688B", + chroma.NameConstant: "#00688B", + chroma.NameDecorator: "#707a7c", + chroma.NameTag: "#8B008B bold", + chroma.NameAttribute: "#658b00", + chroma.NameBuiltin: "#658b00", + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#aa0000", + chroma.GenericInserted: "#00aa00", + chroma.GenericError: "#aa0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "#555555", + chroma.GenericOutput: "#888888", + chroma.GenericTraceback: "#aa0000", + chroma.GenericUnderline: "underline", + chroma.Error: "bg:#e3d2d2 #a61717", + chroma.Background: " bg:#eeeedd", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/pygments.go b/vendor/github.com/alecthomas/chroma/v2/styles/pygments.go new file mode 100644 index 0000000..856e387 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/pygments.go @@ -0,0 +1,55 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Pygments default theme. +var Pygments = Register(chroma.MustNewStyle("pygments", chroma.StyleEntries{ + chroma.Whitespace: "#bbbbbb", + chroma.Comment: "italic #408080", + chroma.CommentPreproc: "noitalic #BC7A00", + + chroma.Keyword: "bold #008000", + chroma.KeywordPseudo: "nobold", + chroma.KeywordType: "nobold #B00040", + + chroma.Operator: "#666666", + chroma.OperatorWord: "bold #AA22FF", + + chroma.NameBuiltin: "#008000", + chroma.NameFunction: "#0000FF", + chroma.NameClass: "bold #0000FF", + chroma.NameNamespace: "bold #0000FF", + chroma.NameException: "bold #D2413A", + chroma.NameVariable: "#19177C", + chroma.NameConstant: "#880000", + chroma.NameLabel: "#A0A000", + chroma.NameEntity: "bold #999999", + chroma.NameAttribute: "#7D9029", + chroma.NameTag: "bold #008000", + chroma.NameDecorator: "#AA22FF", + + chroma.String: "#BA2121", + chroma.StringDoc: "italic", + chroma.StringInterpol: "bold #BB6688", + chroma.StringEscape: "bold #BB6622", + chroma.StringRegex: "#BB6688", + chroma.StringSymbol: "#19177C", + chroma.StringOther: "#008000", + chroma.Number: "#666666", + + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#A00000", + chroma.GenericInserted: "#00A000", + chroma.GenericError: "#FF0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold #000080", + chroma.GenericOutput: "#888", + chroma.GenericTraceback: "#04D", + chroma.GenericUnderline: "underline", + + chroma.Error: "border:#FF0000", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/rainbow_dash.go b/vendor/github.com/alecthomas/chroma/v2/styles/rainbow_dash.go new file mode 100644 index 0000000..b681eb1 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/rainbow_dash.go @@ -0,0 +1,47 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// RainbowDash style. +var RainbowDash = Register(chroma.MustNewStyle("rainbow_dash", chroma.StyleEntries{ + chroma.Comment: "italic #0080ff", + chroma.CommentPreproc: "noitalic", + chroma.CommentSpecial: "bold", + chroma.Error: "bg:#cc0000 #ffffff", + chroma.GenericDeleted: "border:#c5060b bg:#ffcccc", + chroma.GenericEmph: "italic", + chroma.GenericError: "#ff0000", + chroma.GenericHeading: "bold #2c5dcd", + chroma.GenericInserted: "border:#00cc00 bg:#ccffcc", + chroma.GenericOutput: "#aaaaaa", + chroma.GenericPrompt: "bold #2c5dcd", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "bold #2c5dcd", + chroma.GenericTraceback: "#c5060b", + chroma.GenericUnderline: "underline", + chroma.Keyword: "bold #2c5dcd", + chroma.KeywordPseudo: "nobold", + chroma.KeywordType: "#5918bb", + chroma.NameAttribute: "italic #2c5dcd", + chroma.NameBuiltin: "bold #5918bb", + chroma.NameClass: "underline", + chroma.NameConstant: "#318495", + chroma.NameDecorator: "bold #ff8000", + chroma.NameEntity: "bold #5918bb", + chroma.NameException: "bold #5918bb", + chroma.NameFunction: "bold #ff8000", + chroma.NameTag: "bold #2c5dcd", + chroma.LiteralNumber: "bold #5918bb", + chroma.Operator: "#2c5dcd", + chroma.OperatorWord: "bold", + chroma.LiteralString: "#00cc66", + chroma.LiteralStringDoc: "italic", + chroma.LiteralStringEscape: "bold #c5060b", + chroma.LiteralStringOther: "#318495", + chroma.LiteralStringSymbol: "bold #c5060b", + chroma.Text: "#4d4d4d", + chroma.TextWhitespace: "#cbcbcb", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/rrt.go b/vendor/github.com/alecthomas/chroma/v2/styles/rrt.go new file mode 100644 index 0000000..6eda8c4 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/rrt.go @@ -0,0 +1,20 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Rrt style. +var Rrt = Register(chroma.MustNewStyle("rrt", chroma.StyleEntries{ + chroma.CommentPreproc: "#e5e5e5", + chroma.Comment: "#00ff00", + chroma.KeywordType: "#ee82ee", + chroma.Keyword: "#ff0000", + chroma.LiteralNumber: "#ff6600", + chroma.LiteralStringSymbol: "#ff6600", + chroma.LiteralString: "#87ceeb", + chroma.NameFunction: "#ffff00", + chroma.NameConstant: "#7fffd4", + chroma.NameVariable: "#eedd82", + chroma.Background: "#f8f8f2 bg:#000000", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/solarized-dark.go b/vendor/github.com/alecthomas/chroma/v2/styles/solarized-dark.go new file mode 100644 index 0000000..91ce4d9 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/solarized-dark.go @@ -0,0 +1,46 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// SolarizedDark style. +var SolarizedDark = Register(chroma.MustNewStyle("solarized-dark", chroma.StyleEntries{ + chroma.Keyword: "#719e07", + chroma.KeywordConstant: "#CB4B16", + chroma.KeywordDeclaration: "#268BD2", + chroma.KeywordReserved: "#268BD2", + chroma.KeywordType: "#DC322F", + chroma.NameAttribute: "#93A1A1", + chroma.NameBuiltin: "#B58900", + chroma.NameBuiltinPseudo: "#268BD2", + chroma.NameClass: "#268BD2", + chroma.NameConstant: "#CB4B16", + chroma.NameDecorator: "#268BD2", + chroma.NameEntity: "#CB4B16", + chroma.NameException: "#CB4B16", + chroma.NameFunction: "#268BD2", + chroma.NameTag: "#268BD2", + chroma.NameVariable: "#268BD2", + chroma.LiteralString: "#2AA198", + chroma.LiteralStringBacktick: "#586E75", + chroma.LiteralStringChar: "#2AA198", + chroma.LiteralStringDoc: "#93A1A1", + chroma.LiteralStringEscape: "#CB4B16", + chroma.LiteralStringHeredoc: "#93A1A1", + chroma.LiteralStringRegex: "#DC322F", + chroma.LiteralNumber: "#2AA198", + chroma.Operator: "#719e07", + chroma.Comment: "#586E75", + chroma.CommentPreproc: "#719e07", + chroma.CommentSpecial: "#719e07", + chroma.GenericDeleted: "#DC322F", + chroma.GenericEmph: "italic", + chroma.GenericError: "#DC322F bold", + chroma.GenericHeading: "#CB4B16", + chroma.GenericInserted: "#719e07", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "#268BD2", + chroma.Background: "#93A1A1 bg:#002B36", + chroma.Other: "#CB4B16", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/solarized-dark256.go b/vendor/github.com/alecthomas/chroma/v2/styles/solarized-dark256.go new file mode 100644 index 0000000..8e31392 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/solarized-dark256.go @@ -0,0 +1,48 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// SolarizedDark256 style. +var SolarizedDark256 = Register(chroma.MustNewStyle("solarized-dark256", chroma.StyleEntries{ + chroma.Keyword: "#5f8700", + chroma.KeywordConstant: "#d75f00", + chroma.KeywordDeclaration: "#0087ff", + chroma.KeywordNamespace: "#d75f00", + chroma.KeywordReserved: "#0087ff", + chroma.KeywordType: "#af0000", + chroma.NameAttribute: "#8a8a8a", + chroma.NameBuiltin: "#0087ff", + chroma.NameBuiltinPseudo: "#0087ff", + chroma.NameClass: "#0087ff", + chroma.NameConstant: "#d75f00", + chroma.NameDecorator: "#0087ff", + chroma.NameEntity: "#d75f00", + chroma.NameException: "#af8700", + chroma.NameFunction: "#0087ff", + chroma.NameTag: "#0087ff", + chroma.NameVariable: "#0087ff", + chroma.LiteralString: "#00afaf", + chroma.LiteralStringBacktick: "#4e4e4e", + chroma.LiteralStringChar: "#00afaf", + chroma.LiteralStringDoc: "#00afaf", + chroma.LiteralStringEscape: "#af0000", + chroma.LiteralStringHeredoc: "#00afaf", + chroma.LiteralStringRegex: "#af0000", + chroma.LiteralNumber: "#00afaf", + chroma.Operator: "#8a8a8a", + chroma.OperatorWord: "#5f8700", + chroma.Comment: "#4e4e4e", + chroma.CommentPreproc: "#5f8700", + chroma.CommentSpecial: "#5f8700", + chroma.GenericDeleted: "#af0000", + chroma.GenericEmph: "italic", + chroma.GenericError: "#af0000 bold", + chroma.GenericHeading: "#d75f00", + chroma.GenericInserted: "#5f8700", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "#0087ff", + chroma.Background: "#8a8a8a bg:#1c1c1c", + chroma.Other: "#d75f00", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/solarized-light.go b/vendor/github.com/alecthomas/chroma/v2/styles/solarized-light.go new file mode 100644 index 0000000..517fd02 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/solarized-light.go @@ -0,0 +1,24 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// SolarizedLight style. +var SolarizedLight = Register(chroma.MustNewStyle("solarized-light", chroma.StyleEntries{ + chroma.Text: "bg: #eee8d5 #586e75", + chroma.Keyword: "#859900", + chroma.KeywordConstant: "bold", + chroma.KeywordNamespace: "#dc322f bold", + chroma.KeywordType: "bold", + chroma.Name: "#268bd2", + chroma.NameBuiltin: "#cb4b16", + chroma.NameClass: "#cb4b16", + chroma.NameTag: "bold", + chroma.Literal: "#2aa198", + chroma.LiteralNumber: "bold", + chroma.OperatorWord: "#859900", + chroma.Comment: "#93a1a1 italic", + chroma.Generic: "#d33682", + chroma.Background: " bg:#eee8d5", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/swapoff.go b/vendor/github.com/alecthomas/chroma/v2/styles/swapoff.go new file mode 100644 index 0000000..0cf7135 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/swapoff.go @@ -0,0 +1,25 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// SwapOff theme. +var SwapOff = Register(chroma.MustNewStyle("swapoff", chroma.StyleEntries{ + chroma.Background: "#lightgray bg:#black", + chroma.Number: "bold #ansiyellow", + chroma.Comment: "#ansiteal", + chroma.CommentPreproc: "bold #ansigreen", + chroma.String: "bold #ansiturquoise", + chroma.Keyword: "bold #ansiwhite", + chroma.NameKeyword: "bold #ansiwhite", + chroma.NameBuiltin: "bold #ansiwhite", + chroma.GenericHeading: "bold", + chroma.GenericSubheading: "bold", + chroma.GenericStrong: "bold", + chroma.GenericUnderline: "underline", + chroma.NameTag: "bold", + chroma.NameAttribute: "#ansiteal", + chroma.Error: "#ansired", + chroma.LiteralDate: "bold #ansiyellow", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/tango.go b/vendor/github.com/alecthomas/chroma/v2/styles/tango.go new file mode 100644 index 0000000..5608752 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/tango.go @@ -0,0 +1,79 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Tango style. +var Tango = Register(chroma.MustNewStyle("tango", chroma.StyleEntries{ + chroma.TextWhitespace: "underline #f8f8f8", + chroma.Error: "#a40000 border:#ef2929", + chroma.Other: "#000000", + chroma.Comment: "italic #8f5902", + chroma.CommentMultiline: "italic #8f5902", + chroma.CommentPreproc: "italic #8f5902", + chroma.CommentSingle: "italic #8f5902", + chroma.CommentSpecial: "italic #8f5902", + chroma.Keyword: "bold #204a87", + chroma.KeywordConstant: "bold #204a87", + chroma.KeywordDeclaration: "bold #204a87", + chroma.KeywordNamespace: "bold #204a87", + chroma.KeywordPseudo: "bold #204a87", + chroma.KeywordReserved: "bold #204a87", + chroma.KeywordType: "bold #204a87", + chroma.Operator: "bold #ce5c00", + chroma.OperatorWord: "bold #204a87", + chroma.Punctuation: "bold #000000", + chroma.Name: "#000000", + chroma.NameAttribute: "#c4a000", + chroma.NameBuiltin: "#204a87", + chroma.NameBuiltinPseudo: "#3465a4", + chroma.NameClass: "#000000", + chroma.NameConstant: "#000000", + chroma.NameDecorator: "bold #5c35cc", + chroma.NameEntity: "#ce5c00", + chroma.NameException: "bold #cc0000", + chroma.NameFunction: "#000000", + chroma.NameProperty: "#000000", + chroma.NameLabel: "#f57900", + chroma.NameNamespace: "#000000", + chroma.NameOther: "#000000", + chroma.NameTag: "bold #204a87", + chroma.NameVariable: "#000000", + chroma.NameVariableClass: "#000000", + chroma.NameVariableGlobal: "#000000", + chroma.NameVariableInstance: "#000000", + chroma.LiteralNumber: "bold #0000cf", + chroma.LiteralNumberFloat: "bold #0000cf", + chroma.LiteralNumberHex: "bold #0000cf", + chroma.LiteralNumberInteger: "bold #0000cf", + chroma.LiteralNumberIntegerLong: "bold #0000cf", + chroma.LiteralNumberOct: "bold #0000cf", + chroma.Literal: "#000000", + chroma.LiteralDate: "#000000", + chroma.LiteralString: "#4e9a06", + chroma.LiteralStringBacktick: "#4e9a06", + chroma.LiteralStringChar: "#4e9a06", + chroma.LiteralStringDoc: "italic #8f5902", + chroma.LiteralStringDouble: "#4e9a06", + chroma.LiteralStringEscape: "#4e9a06", + chroma.LiteralStringHeredoc: "#4e9a06", + chroma.LiteralStringInterpol: "#4e9a06", + chroma.LiteralStringOther: "#4e9a06", + chroma.LiteralStringRegex: "#4e9a06", + chroma.LiteralStringSingle: "#4e9a06", + chroma.LiteralStringSymbol: "#4e9a06", + chroma.Generic: "#000000", + chroma.GenericDeleted: "#a40000", + chroma.GenericEmph: "italic #000000", + chroma.GenericError: "#ef2929", + chroma.GenericHeading: "bold #000080", + chroma.GenericInserted: "#00A000", + chroma.GenericOutput: "italic #000000", + chroma.GenericPrompt: "#8f5902", + chroma.GenericStrong: "bold #000000", + chroma.GenericSubheading: "bold #800080", + chroma.GenericTraceback: "bold #a40000", + chroma.GenericUnderline: "underline", + chroma.Background: " bg:#f8f8f8", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/trac.go b/vendor/github.com/alecthomas/chroma/v2/styles/trac.go new file mode 100644 index 0000000..c149cd2 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/trac.go @@ -0,0 +1,42 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Trac style. +var Trac = Register(chroma.MustNewStyle("trac", chroma.StyleEntries{ + chroma.TextWhitespace: "#bbbbbb", + chroma.Comment: "italic #999988", + chroma.CommentPreproc: "bold noitalic #999999", + chroma.CommentSpecial: "bold #999999", + chroma.Operator: "bold", + chroma.LiteralString: "#bb8844", + chroma.LiteralStringRegex: "#808000", + chroma.LiteralNumber: "#009999", + chroma.Keyword: "bold", + chroma.KeywordType: "#445588", + chroma.NameBuiltin: "#999999", + chroma.NameFunction: "bold #990000", + chroma.NameClass: "bold #445588", + chroma.NameException: "bold #990000", + chroma.NameNamespace: "#555555", + chroma.NameVariable: "#008080", + chroma.NameConstant: "#008080", + chroma.NameTag: "#000080", + chroma.NameAttribute: "#008080", + chroma.NameEntity: "#800080", + chroma.GenericHeading: "#999999", + chroma.GenericSubheading: "#aaaaaa", + chroma.GenericDeleted: "bg:#ffdddd #000000", + chroma.GenericInserted: "bg:#ddffdd #000000", + chroma.GenericError: "#aa0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "#555555", + chroma.GenericOutput: "#888888", + chroma.GenericTraceback: "#aa0000", + chroma.GenericUnderline: "underline", + chroma.Error: "bg:#e3d2d2 #a61717", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/vim.go b/vendor/github.com/alecthomas/chroma/v2/styles/vim.go new file mode 100644 index 0000000..caa2e09 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/vim.go @@ -0,0 +1,36 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Vim style. +var Vim = Register(chroma.MustNewStyle("vim", chroma.StyleEntries{ + chroma.Background: "#cccccc bg:#000000", + chroma.Comment: "#000080", + chroma.CommentSpecial: "bold #cd0000", + chroma.Keyword: "#cdcd00", + chroma.KeywordDeclaration: "#00cd00", + chroma.KeywordNamespace: "#cd00cd", + chroma.KeywordType: "#00cd00", + chroma.Operator: "#3399cc", + chroma.OperatorWord: "#cdcd00", + chroma.NameClass: "#00cdcd", + chroma.NameBuiltin: "#cd00cd", + chroma.NameException: "bold #666699", + chroma.NameVariable: "#00cdcd", + chroma.LiteralString: "#cd0000", + chroma.LiteralNumber: "#cd00cd", + chroma.GenericHeading: "bold #000080", + chroma.GenericSubheading: "bold #800080", + chroma.GenericDeleted: "#cd0000", + chroma.GenericInserted: "#00cd00", + chroma.GenericError: "#FF0000", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold #000080", + chroma.GenericOutput: "#888", + chroma.GenericTraceback: "#04D", + chroma.GenericUnderline: "underline", + chroma.Error: "border:#FF0000", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/vs.go b/vendor/github.com/alecthomas/chroma/v2/styles/vs.go new file mode 100644 index 0000000..c601a31 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/vs.go @@ -0,0 +1,23 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// VisualStudio style. +var VisualStudio = Register(chroma.MustNewStyle("vs", chroma.StyleEntries{ + chroma.Comment: "#008000", + chroma.CommentPreproc: "#0000ff", + chroma.Keyword: "#0000ff", + chroma.OperatorWord: "#0000ff", + chroma.KeywordType: "#2b91af", + chroma.NameClass: "#2b91af", + chroma.LiteralString: "#a31515", + chroma.GenericHeading: "bold", + chroma.GenericSubheading: "bold", + chroma.GenericEmph: "italic", + chroma.GenericStrong: "bold", + chroma.GenericPrompt: "bold", + chroma.Error: "border:#FF0000", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/vulcan.go b/vendor/github.com/alecthomas/chroma/v2/styles/vulcan.go new file mode 100644 index 0000000..4060422 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/vulcan.go @@ -0,0 +1,95 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +var ( + // inspired by Doom Emacs's One Doom Theme + black = "#282C34" + grey = "#3E4460" + grey2 = "#43454f" + white = "#C9C9C9" + red = "#CF5967" + yellow = "#ECBE7B" + green = "#82CC6A" + cyan = "#56B6C2" + blue = "#7FBAF5" + blue2 = "#57C7FF" + purple = "#BC74C4" +) + +var Vulcan = Register(chroma.MustNewStyle("vulcan", chroma.StyleEntries{ + chroma.Comment: grey, + chroma.CommentHashbang: grey + " italic", + chroma.CommentMultiline: grey, + chroma.CommentPreproc: blue, + chroma.CommentSingle: grey, + chroma.CommentSpecial: purple + " italic", + chroma.Generic: white, + chroma.GenericDeleted: red, + chroma.GenericEmph: white + " underline", + chroma.GenericError: red + " bold", + chroma.GenericHeading: yellow + " bold", + chroma.GenericInserted: yellow, + chroma.GenericOutput: grey2, + chroma.GenericPrompt: white, + chroma.GenericStrong: red + " bold", + chroma.GenericSubheading: red + " italic", + chroma.GenericTraceback: white, + chroma.GenericUnderline: "underline", + chroma.Error: red, + chroma.Keyword: blue, + chroma.KeywordConstant: red + " bg:" + grey2, + chroma.KeywordDeclaration: blue, + chroma.KeywordNamespace: purple, + chroma.KeywordPseudo: purple, + chroma.KeywordReserved: blue, + chroma.KeywordType: blue2 + " bold", + chroma.Literal: white, + chroma.LiteralDate: blue2, + chroma.Name: white, + chroma.NameAttribute: purple, + chroma.NameBuiltin: blue, + chroma.NameBuiltinPseudo: blue, + chroma.NameClass: yellow, + chroma.NameConstant: yellow, + chroma.NameDecorator: yellow, + chroma.NameEntity: white, + chroma.NameException: red, + chroma.NameFunction: blue2, + chroma.NameLabel: red, + chroma.NameNamespace: white, + chroma.NameOther: white, + chroma.NameTag: purple, + chroma.NameVariable: purple + " italic", + chroma.NameVariableClass: blue2 + " bold", + chroma.NameVariableGlobal: yellow, + chroma.NameVariableInstance: blue2, + chroma.LiteralNumber: cyan, + chroma.LiteralNumberBin: blue2, + chroma.LiteralNumberFloat: cyan, + chroma.LiteralNumberHex: blue2, + chroma.LiteralNumberInteger: cyan, + chroma.LiteralNumberIntegerLong: cyan, + chroma.LiteralNumberOct: blue2, + chroma.Operator: purple, + chroma.OperatorWord: purple, + chroma.Other: white, + chroma.Punctuation: cyan, + chroma.LiteralString: green, + chroma.LiteralStringBacktick: blue2, + chroma.LiteralStringChar: blue2, + chroma.LiteralStringDoc: green, + chroma.LiteralStringDouble: green, + chroma.LiteralStringEscape: cyan, + chroma.LiteralStringHeredoc: cyan, + chroma.LiteralStringInterpol: green, + chroma.LiteralStringOther: green, + chroma.LiteralStringRegex: blue2, + chroma.LiteralStringSingle: green, + chroma.LiteralStringSymbol: green, + chroma.Text: white, + chroma.TextWhitespace: white, + chroma.Background: " bg: " + black, +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/witchhazel.go b/vendor/github.com/alecthomas/chroma/v2/styles/witchhazel.go new file mode 100644 index 0000000..201e697 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/witchhazel.go @@ -0,0 +1,52 @@ +// Copyright 2018 Alethea Katherine Flowers +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// WitchHazel Style +var WitchHazel = Register(chroma.MustNewStyle("witchhazel", chroma.StyleEntries{ + chroma.Text: "#F8F8F2", + chroma.Whitespace: "#A8757B", + chroma.Error: "#960050 bg:#1e0010", + chroma.Comment: "#b0bec5", + chroma.Keyword: "#C2FFDF", + chroma.KeywordNamespace: "#FFB8D1", + chroma.Operator: "#FFB8D1", + chroma.Punctuation: "#F8F8F2", + chroma.Name: "#F8F8F2", + chroma.NameAttribute: "#ceb1ff", + chroma.NameBuiltinPseudo: "#80cbc4", + chroma.NameClass: "#ceb1ff", + chroma.NameConstant: "#C5A3FF", + chroma.NameDecorator: "#ceb1ff", + chroma.NameException: "#ceb1ff", + chroma.NameFunction: "#ceb1ff", + chroma.NameProperty: "#F8F8F2", + chroma.NameTag: "#FFB8D1", + chroma.NameVariable: "#F8F8F2", + chroma.Number: "#C5A3FF", + chroma.Literal: "#ae81ff", + chroma.LiteralDate: "#e6db74", + chroma.String: "#1bc5e0", + chroma.GenericDeleted: "#f92672", + chroma.GenericEmph: "italic", + chroma.GenericInserted: "#a6e22e", + chroma.GenericStrong: "bold", + chroma.GenericSubheading: "#75715e", + chroma.Background: " bg:#433e56", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/xcode-dark.go b/vendor/github.com/alecthomas/chroma/v2/styles/xcode-dark.go new file mode 100644 index 0000000..80a2a83 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/xcode-dark.go @@ -0,0 +1,62 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +var ( + // Inspired by Apple's Xcode "Default (Dark)" Theme + background = "#1F1F24" + plainText = "#FFFFFF" + comments = "#6C7986" + strings = "#FC6A5D" + numbers = "#D0BF69" + keywords = "#FC5FA3" + preprocessorStatements = "#FD8F3F" + typeDeclarations = "#5DD8FF" + otherDeclarations = "#41A1C0" + otherFunctionAndMethodNames = "#A167E6" + otherTypeNames = "#D0A8FF" +) + +// Xcode dark style +var XcodeDark = Register(chroma.MustNewStyle("xcode-dark", chroma.StyleEntries{ + chroma.Background: plainText + " bg:" + background, + + chroma.Comment: comments, + chroma.CommentMultiline: comments, + chroma.CommentPreproc: preprocessorStatements, + chroma.CommentSingle: comments, + chroma.CommentSpecial: comments + " italic", + + chroma.Error: "#960050", + + chroma.Keyword: keywords, + chroma.KeywordConstant: keywords, + chroma.KeywordDeclaration: keywords, + chroma.KeywordReserved: keywords, + + chroma.LiteralNumber: numbers, + chroma.LiteralNumberBin: numbers, + chroma.LiteralNumberFloat: numbers, + chroma.LiteralNumberHex: numbers, + chroma.LiteralNumberInteger: numbers, + chroma.LiteralNumberOct: numbers, + + chroma.LiteralString: strings, + chroma.LiteralStringEscape: strings, + chroma.LiteralStringInterpol: plainText, + + chroma.Name: plainText, + chroma.NameBuiltin: otherTypeNames, + chroma.NameBuiltinPseudo: otherFunctionAndMethodNames, + chroma.NameClass: typeDeclarations, + chroma.NameFunction: otherDeclarations, + chroma.NameVariable: otherDeclarations, + + chroma.Operator: plainText, + + chroma.Punctuation: plainText, + + chroma.Text: plainText, +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/styles/xcode.go b/vendor/github.com/alecthomas/chroma/v2/styles/xcode.go new file mode 100644 index 0000000..592c9e3 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/styles/xcode.go @@ -0,0 +1,29 @@ +package styles + +import ( + "github.com/alecthomas/chroma/v2" +) + +// Xcode style. +var Xcode = Register(chroma.MustNewStyle("xcode", chroma.StyleEntries{ + chroma.Comment: "#177500", + chroma.CommentPreproc: "#633820", + chroma.LiteralString: "#C41A16", + chroma.LiteralStringChar: "#2300CE", + chroma.Operator: "#000000", + chroma.Keyword: "#A90D91", + chroma.Name: "#000000", + chroma.NameAttribute: "#836C28", + chroma.NameClass: "#3F6E75", + chroma.NameFunction: "#000000", + chroma.NameBuiltin: "#A90D91", + chroma.NameBuiltinPseudo: "#5B269A", + chroma.NameVariable: "#000000", + chroma.NameTag: "#000000", + chroma.NameDecorator: "#000000", + chroma.NameLabel: "#000000", + chroma.Literal: "#1C01CE", + chroma.LiteralNumber: "#1C01CE", + chroma.Error: "#000000", + chroma.Background: " bg:#ffffff", +})) diff --git a/vendor/github.com/alecthomas/chroma/v2/table.py b/vendor/github.com/alecthomas/chroma/v2/table.py new file mode 100644 index 0000000..7794539 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/table.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +import re +from collections import defaultdict +from subprocess import check_output + +README_FILE = "README.md" + + +lines = check_output(["go", "run", "./cmd/chroma/main.go", "--list"]).decode("utf-8").splitlines() +lines = [line.strip() for line in lines if line.startswith(" ") and not line.startswith(" ")] +lines = sorted(lines, key=lambda l: l.lower()) + +table = defaultdict(list) + +for line in lines: + table[line[0].upper()].append(line) + +rows = [] +for key, value in table.items(): + rows.append("{} | {}".format(key, ", ".join(value))) +tbody = "\n".join(rows) + +with open(README_FILE, "r") as f: + content = f.read() + +with open(README_FILE, "w") as f: + marker = re.compile(r"(?P<start>:----: \\| --------\n).*?(?P<end>\n\n)", re.DOTALL) + replacement = r"\g<start>%s\g<end>" % tbody + updated_content = marker.sub(replacement, content) + f.write(updated_content) + +print(tbody) diff --git a/vendor/github.com/alecthomas/chroma/v2/tokentype_string.go b/vendor/github.com/alecthomas/chroma/v2/tokentype_string.go new file mode 100644 index 0000000..9c302f9 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/tokentype_string.go @@ -0,0 +1,219 @@ +// Code generated by "stringer -type TokenType"; DO NOT EDIT. + +package chroma + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[Background - -1] + _ = x[PreWrapper - -2] + _ = x[Line - -3] + _ = x[LineNumbers - -4] + _ = x[LineNumbersTable - -5] + _ = x[LineHighlight - -6] + _ = x[LineTable - -7] + _ = x[LineTableTD - -8] + _ = x[CodeLine - -9] + _ = x[Error - -10] + _ = x[Other - -11] + _ = x[None - -12] + _ = x[EOFType-0] + _ = x[Keyword-1000] + _ = x[KeywordConstant-1001] + _ = x[KeywordDeclaration-1002] + _ = x[KeywordNamespace-1003] + _ = x[KeywordPseudo-1004] + _ = x[KeywordReserved-1005] + _ = x[KeywordType-1006] + _ = x[Name-2000] + _ = x[NameAttribute-2001] + _ = x[NameBuiltin-2002] + _ = x[NameBuiltinPseudo-2003] + _ = x[NameClass-2004] + _ = x[NameConstant-2005] + _ = x[NameDecorator-2006] + _ = x[NameEntity-2007] + _ = x[NameException-2008] + _ = x[NameFunction-2009] + _ = x[NameFunctionMagic-2010] + _ = x[NameKeyword-2011] + _ = x[NameLabel-2012] + _ = x[NameNamespace-2013] + _ = x[NameOperator-2014] + _ = x[NameOther-2015] + _ = x[NamePseudo-2016] + _ = x[NameProperty-2017] + _ = x[NameTag-2018] + _ = x[NameVariable-2019] + _ = x[NameVariableAnonymous-2020] + _ = x[NameVariableClass-2021] + _ = x[NameVariableGlobal-2022] + _ = x[NameVariableInstance-2023] + _ = x[NameVariableMagic-2024] + _ = x[Literal-3000] + _ = x[LiteralDate-3001] + _ = x[LiteralOther-3002] + _ = x[LiteralString-3100] + _ = x[LiteralStringAffix-3101] + _ = x[LiteralStringAtom-3102] + _ = x[LiteralStringBacktick-3103] + _ = x[LiteralStringBoolean-3104] + _ = x[LiteralStringChar-3105] + _ = x[LiteralStringDelimiter-3106] + _ = x[LiteralStringDoc-3107] + _ = x[LiteralStringDouble-3108] + _ = x[LiteralStringEscape-3109] + _ = x[LiteralStringHeredoc-3110] + _ = x[LiteralStringInterpol-3111] + _ = x[LiteralStringName-3112] + _ = x[LiteralStringOther-3113] + _ = x[LiteralStringRegex-3114] + _ = x[LiteralStringSingle-3115] + _ = x[LiteralStringSymbol-3116] + _ = x[LiteralNumber-3200] + _ = x[LiteralNumberBin-3201] + _ = x[LiteralNumberFloat-3202] + _ = x[LiteralNumberHex-3203] + _ = x[LiteralNumberInteger-3204] + _ = x[LiteralNumberIntegerLong-3205] + _ = x[LiteralNumberOct-3206] + _ = x[Operator-4000] + _ = x[OperatorWord-4001] + _ = x[Punctuation-5000] + _ = x[Comment-6000] + _ = x[CommentHashbang-6001] + _ = x[CommentMultiline-6002] + _ = x[CommentSingle-6003] + _ = x[CommentSpecial-6004] + _ = x[CommentPreproc-6100] + _ = x[CommentPreprocFile-6101] + _ = x[Generic-7000] + _ = x[GenericDeleted-7001] + _ = x[GenericEmph-7002] + _ = x[GenericError-7003] + _ = x[GenericHeading-7004] + _ = x[GenericInserted-7005] + _ = x[GenericOutput-7006] + _ = x[GenericPrompt-7007] + _ = x[GenericStrong-7008] + _ = x[GenericSubheading-7009] + _ = x[GenericTraceback-7010] + _ = x[GenericUnderline-7011] + _ = x[Text-8000] + _ = x[TextWhitespace-8001] + _ = x[TextSymbol-8002] + _ = x[TextPunctuation-8003] +} + +const _TokenType_name = "NoneOtherErrorCodeLineLineTableTDLineTableLineHighlightLineNumbersTableLineNumbersLinePreWrapperBackgroundEOFTypeKeywordKeywordConstantKeywordDeclarationKeywordNamespaceKeywordPseudoKeywordReservedKeywordTypeNameNameAttributeNameBuiltinNameBuiltinPseudoNameClassNameConstantNameDecoratorNameEntityNameExceptionNameFunctionNameFunctionMagicNameKeywordNameLabelNameNamespaceNameOperatorNameOtherNamePseudoNamePropertyNameTagNameVariableNameVariableAnonymousNameVariableClassNameVariableGlobalNameVariableInstanceNameVariableMagicLiteralLiteralDateLiteralOtherLiteralStringLiteralStringAffixLiteralStringAtomLiteralStringBacktickLiteralStringBooleanLiteralStringCharLiteralStringDelimiterLiteralStringDocLiteralStringDoubleLiteralStringEscapeLiteralStringHeredocLiteralStringInterpolLiteralStringNameLiteralStringOtherLiteralStringRegexLiteralStringSingleLiteralStringSymbolLiteralNumberLiteralNumberBinLiteralNumberFloatLiteralNumberHexLiteralNumberIntegerLiteralNumberIntegerLongLiteralNumberOctOperatorOperatorWordPunctuationCommentCommentHashbangCommentMultilineCommentSingleCommentSpecialCommentPreprocCommentPreprocFileGenericGenericDeletedGenericEmphGenericErrorGenericHeadingGenericInsertedGenericOutputGenericPromptGenericStrongGenericSubheadingGenericTracebackGenericUnderlineTextTextWhitespaceTextSymbolTextPunctuation" + +var _TokenType_map = map[TokenType]string{ + -12: _TokenType_name[0:4], + -11: _TokenType_name[4:9], + -10: _TokenType_name[9:14], + -9: _TokenType_name[14:22], + -8: _TokenType_name[22:33], + -7: _TokenType_name[33:42], + -6: _TokenType_name[42:55], + -5: _TokenType_name[55:71], + -4: _TokenType_name[71:82], + -3: _TokenType_name[82:86], + -2: _TokenType_name[86:96], + -1: _TokenType_name[96:106], + 0: _TokenType_name[106:113], + 1000: _TokenType_name[113:120], + 1001: _TokenType_name[120:135], + 1002: _TokenType_name[135:153], + 1003: _TokenType_name[153:169], + 1004: _TokenType_name[169:182], + 1005: _TokenType_name[182:197], + 1006: _TokenType_name[197:208], + 2000: _TokenType_name[208:212], + 2001: _TokenType_name[212:225], + 2002: _TokenType_name[225:236], + 2003: _TokenType_name[236:253], + 2004: _TokenType_name[253:262], + 2005: _TokenType_name[262:274], + 2006: _TokenType_name[274:287], + 2007: _TokenType_name[287:297], + 2008: _TokenType_name[297:310], + 2009: _TokenType_name[310:322], + 2010: _TokenType_name[322:339], + 2011: _TokenType_name[339:350], + 2012: _TokenType_name[350:359], + 2013: _TokenType_name[359:372], + 2014: _TokenType_name[372:384], + 2015: _TokenType_name[384:393], + 2016: _TokenType_name[393:403], + 2017: _TokenType_name[403:415], + 2018: _TokenType_name[415:422], + 2019: _TokenType_name[422:434], + 2020: _TokenType_name[434:455], + 2021: _TokenType_name[455:472], + 2022: _TokenType_name[472:490], + 2023: _TokenType_name[490:510], + 2024: _TokenType_name[510:527], + 3000: _TokenType_name[527:534], + 3001: _TokenType_name[534:545], + 3002: _TokenType_name[545:557], + 3100: _TokenType_name[557:570], + 3101: _TokenType_name[570:588], + 3102: _TokenType_name[588:605], + 3103: _TokenType_name[605:626], + 3104: _TokenType_name[626:646], + 3105: _TokenType_name[646:663], + 3106: _TokenType_name[663:685], + 3107: _TokenType_name[685:701], + 3108: _TokenType_name[701:720], + 3109: _TokenType_name[720:739], + 3110: _TokenType_name[739:759], + 3111: _TokenType_name[759:780], + 3112: _TokenType_name[780:797], + 3113: _TokenType_name[797:815], + 3114: _TokenType_name[815:833], + 3115: _TokenType_name[833:852], + 3116: _TokenType_name[852:871], + 3200: _TokenType_name[871:884], + 3201: _TokenType_name[884:900], + 3202: _TokenType_name[900:918], + 3203: _TokenType_name[918:934], + 3204: _TokenType_name[934:954], + 3205: _TokenType_name[954:978], + 3206: _TokenType_name[978:994], + 4000: _TokenType_name[994:1002], + 4001: _TokenType_name[1002:1014], + 5000: _TokenType_name[1014:1025], + 6000: _TokenType_name[1025:1032], + 6001: _TokenType_name[1032:1047], + 6002: _TokenType_name[1047:1063], + 6003: _TokenType_name[1063:1076], + 6004: _TokenType_name[1076:1090], + 6100: _TokenType_name[1090:1104], + 6101: _TokenType_name[1104:1122], + 7000: _TokenType_name[1122:1129], + 7001: _TokenType_name[1129:1143], + 7002: _TokenType_name[1143:1154], + 7003: _TokenType_name[1154:1166], + 7004: _TokenType_name[1166:1180], + 7005: _TokenType_name[1180:1195], + 7006: _TokenType_name[1195:1208], + 7007: _TokenType_name[1208:1221], + 7008: _TokenType_name[1221:1234], + 7009: _TokenType_name[1234:1251], + 7010: _TokenType_name[1251:1267], + 7011: _TokenType_name[1267:1283], + 8000: _TokenType_name[1283:1287], + 8001: _TokenType_name[1287:1301], + 8002: _TokenType_name[1301:1311], + 8003: _TokenType_name[1311:1326], +} + +func (i TokenType) String() string { + if str, ok := _TokenType_map[i]; ok { + return str + } + return "TokenType(" + strconv.FormatInt(int64(i), 10) + ")" +} diff --git a/vendor/github.com/alecthomas/chroma/v2/types.go b/vendor/github.com/alecthomas/chroma/v2/types.go new file mode 100644 index 0000000..2ff8928 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/types.go @@ -0,0 +1,352 @@ +package chroma + +import ( + "fmt" +) + +//go:generate stringer -type TokenType + +// TokenType is the type of token to highlight. +// +// It is also an Emitter, emitting a single token of itself +type TokenType int + +// Set of TokenTypes. +// +// Categories of types are grouped in ranges of 1000, while sub-categories are in ranges of 100. For +// example, the literal category is in the range 3000-3999. The sub-category for literal strings is +// in the range 3100-3199. + +// Meta token types. +const ( + // Default background style. + Background TokenType = -1 - iota + // PreWrapper style. + PreWrapper + // Line style. + Line + // Line numbers in output. + LineNumbers + // Line numbers in output when in table. + LineNumbersTable + // Line higlight style. + LineHighlight + // Line numbers table wrapper style. + LineTable + // Line numbers table TD wrapper style. + LineTableTD + // Code line wrapper style. + CodeLine + // Input that could not be tokenised. + Error + // Other is used by the Delegate lexer to indicate which tokens should be handled by the delegate. + Other + // No highlighting. + None + // Used as an EOF marker / nil token + EOFType TokenType = 0 +) + +// Keywords. +const ( + Keyword TokenType = 1000 + iota + KeywordConstant + KeywordDeclaration + KeywordNamespace + KeywordPseudo + KeywordReserved + KeywordType +) + +// Names. +const ( + Name TokenType = 2000 + iota + NameAttribute + NameBuiltin + NameBuiltinPseudo + NameClass + NameConstant + NameDecorator + NameEntity + NameException + NameFunction + NameFunctionMagic + NameKeyword + NameLabel + NameNamespace + NameOperator + NameOther + NamePseudo + NameProperty + NameTag + NameVariable + NameVariableAnonymous + NameVariableClass + NameVariableGlobal + NameVariableInstance + NameVariableMagic +) + +// Literals. +const ( + Literal TokenType = 3000 + iota + LiteralDate + LiteralOther +) + +// Strings. +const ( + LiteralString TokenType = 3100 + iota + LiteralStringAffix + LiteralStringAtom + LiteralStringBacktick + LiteralStringBoolean + LiteralStringChar + LiteralStringDelimiter + LiteralStringDoc + LiteralStringDouble + LiteralStringEscape + LiteralStringHeredoc + LiteralStringInterpol + LiteralStringName + LiteralStringOther + LiteralStringRegex + LiteralStringSingle + LiteralStringSymbol +) + +// Literals. +const ( + LiteralNumber TokenType = 3200 + iota + LiteralNumberBin + LiteralNumberFloat + LiteralNumberHex + LiteralNumberInteger + LiteralNumberIntegerLong + LiteralNumberOct +) + +// Operators. +const ( + Operator TokenType = 4000 + iota + OperatorWord +) + +// Punctuation. +const ( + Punctuation TokenType = 5000 + iota +) + +// Comments. +const ( + Comment TokenType = 6000 + iota + CommentHashbang + CommentMultiline + CommentSingle + CommentSpecial +) + +// Preprocessor "comments". +const ( + CommentPreproc TokenType = 6100 + iota + CommentPreprocFile +) + +// Generic tokens. +const ( + Generic TokenType = 7000 + iota + GenericDeleted + GenericEmph + GenericError + GenericHeading + GenericInserted + GenericOutput + GenericPrompt + GenericStrong + GenericSubheading + GenericTraceback + GenericUnderline +) + +// Text. +const ( + Text TokenType = 8000 + iota + TextWhitespace + TextSymbol + TextPunctuation +) + +// Aliases. +const ( + Whitespace = TextWhitespace + + Date = LiteralDate + + String = LiteralString + StringAffix = LiteralStringAffix + StringBacktick = LiteralStringBacktick + StringChar = LiteralStringChar + StringDelimiter = LiteralStringDelimiter + StringDoc = LiteralStringDoc + StringDouble = LiteralStringDouble + StringEscape = LiteralStringEscape + StringHeredoc = LiteralStringHeredoc + StringInterpol = LiteralStringInterpol + StringOther = LiteralStringOther + StringRegex = LiteralStringRegex + StringSingle = LiteralStringSingle + StringSymbol = LiteralStringSymbol + + Number = LiteralNumber + NumberBin = LiteralNumberBin + NumberFloat = LiteralNumberFloat + NumberHex = LiteralNumberHex + NumberInteger = LiteralNumberInteger + NumberIntegerLong = LiteralNumberIntegerLong + NumberOct = LiteralNumberOct +) + +var ( + StandardTypes = map[TokenType]string{ + Background: "bg", + PreWrapper: "chroma", + Line: "line", + LineNumbers: "ln", + LineNumbersTable: "lnt", + LineHighlight: "hl", + LineTable: "lntable", + LineTableTD: "lntd", + CodeLine: "cl", + Text: "", + Whitespace: "w", + Error: "err", + Other: "x", + // I have no idea what this is used for... + // Escape: "esc", + + Keyword: "k", + KeywordConstant: "kc", + KeywordDeclaration: "kd", + KeywordNamespace: "kn", + KeywordPseudo: "kp", + KeywordReserved: "kr", + KeywordType: "kt", + + Name: "n", + NameAttribute: "na", + NameBuiltin: "nb", + NameBuiltinPseudo: "bp", + NameClass: "nc", + NameConstant: "no", + NameDecorator: "nd", + NameEntity: "ni", + NameException: "ne", + NameFunction: "nf", + NameFunctionMagic: "fm", + NameProperty: "py", + NameLabel: "nl", + NameNamespace: "nn", + NameOther: "nx", + NameTag: "nt", + NameVariable: "nv", + NameVariableClass: "vc", + NameVariableGlobal: "vg", + NameVariableInstance: "vi", + NameVariableMagic: "vm", + + Literal: "l", + LiteralDate: "ld", + + String: "s", + StringAffix: "sa", + StringBacktick: "sb", + StringChar: "sc", + StringDelimiter: "dl", + StringDoc: "sd", + StringDouble: "s2", + StringEscape: "se", + StringHeredoc: "sh", + StringInterpol: "si", + StringOther: "sx", + StringRegex: "sr", + StringSingle: "s1", + StringSymbol: "ss", + + Number: "m", + NumberBin: "mb", + NumberFloat: "mf", + NumberHex: "mh", + NumberInteger: "mi", + NumberIntegerLong: "il", + NumberOct: "mo", + + Operator: "o", + OperatorWord: "ow", + + Punctuation: "p", + + Comment: "c", + CommentHashbang: "ch", + CommentMultiline: "cm", + CommentPreproc: "cp", + CommentPreprocFile: "cpf", + CommentSingle: "c1", + CommentSpecial: "cs", + + Generic: "g", + GenericDeleted: "gd", + GenericEmph: "ge", + GenericError: "gr", + GenericHeading: "gh", + GenericInserted: "gi", + GenericOutput: "go", + GenericPrompt: "gp", + GenericStrong: "gs", + GenericSubheading: "gu", + GenericTraceback: "gt", + GenericUnderline: "gl", + } +) + +func (t TokenType) Parent() TokenType { + if t%100 != 0 { + return t / 100 * 100 + } + if t%1000 != 0 { + return t / 1000 * 1000 + } + return 0 +} + +func (t TokenType) Category() TokenType { + return t / 1000 * 1000 +} + +func (t TokenType) SubCategory() TokenType { + return t / 100 * 100 +} + +func (t TokenType) InCategory(other TokenType) bool { + return t/1000 == other/1000 +} + +func (t TokenType) InSubCategory(other TokenType) bool { + return t/100 == other/100 +} + +func (t TokenType) Emit(groups []string, _ *LexerState) Iterator { + return Literator(Token{Type: t, Value: groups[0]}) +} + +func (t TokenType) EmitterKind() string { return "token" } +func (t TokenType) MarshalText() ([]byte, error) { return []byte(t.String()), nil } +func (t *TokenType) UnmarshalText(data []byte) error { + key := string(data) + for tt, text := range _TokenType_map { + if text == key { + *t = tt + return nil + } + } + return fmt.Errorf("unknown TokenType %q", data) +} |