diff --git a/Makefile b/Makefile index 4ac85af..eca8e8b 100644 --- a/Makefile +++ b/Makefile @@ -1,17 +1,17 @@ -destdir ?= -goflags ?= -v -ldflags "-w -X `go list`.Version=$(version) -X `go list`.Commit=$(commit)" -tags "static_build" -prefix ?= /usr/local -version ?= `git describe --abbrev=0 --tags || echo "$version"` -commit ?= `git rev-parse --short HEAD || echo "$commit"` +DESTDIR ?= +GOFLAGS ?= -v -ldflags "-w -X `go list`.Version=$(VERSION) -X `go list`.Commit=$(COMMIT)" -tags "static_build" -mod=vendor +PREFIX ?= /usr/local +VERSION ?= `git describe --abbrev=0 --tags || echo "$VERSION"` +COMMIT ?= `git rev-parse --short HEAD || echo "$COMMIT"` build: - go build ${goflags} ./cmd/aya + go build ${GOFLAGS} ./cmd/aya clean: rm -f aya install: - install -Dm0755 aya ${destdir}${prefix}/bin/aya - install -Dm0644 aya.1 ${destdir}${prefix}/share/man/man1/aya.1 + install -Dm0755 aya ${DESTDIR}${PREFIX}/bin/aya + install -Dm0644 aya.1 ${DESTDIR}${PREFIX}/share/man/man1/aya.1 uninstall: - rm -f ${prefix}/bin/aya - rm -f ${prefix}/share/man/man1/aya.1 + rm -f ${PREFIX}/bin/aya + rm -f ${PREFIX}/share/man/man1/aya.1 diff --git a/go.mod b/go.mod index 754efb9..e3c3c34 100644 --- a/go.mod +++ b/go.mod @@ -12,7 +12,7 @@ require ( ) require ( - github.com/alecthomas/chroma/v2 v2.2.0 // indirect + github.com/alecthomas/chroma/v2 v2.3.0 // indirect github.com/dlclark/regexp2 v1.4.0 // indirect golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect ) diff --git a/go.sum b/go.sum index 7d4482d..66b698c 100644 --- a/go.sum +++ b/go.sum @@ -1,9 +1,11 @@ github.com/Depado/bfchroma/v2 v2.0.0 h1:IRpN9BPkNwEpR6w1ectIcNWOuhDSLx+8f1pn83fzxx8= github.com/Depado/bfchroma/v2 v2.0.0/go.mod h1:wFwW/Pw8Tnd0irzgO9Zxtxgzp3aPS8qBWlyadxujxmw= -github.com/alecthomas/chroma/v2 v2.2.0 h1:Aten8jfQwUqEdadVFFjNyjx7HTexhKP0XuqBG67mRDY= github.com/alecthomas/chroma/v2 v2.2.0/go.mod h1:vf4zrexSH54oEjJ7EdB65tGNHmH3pGZmVkgTP5RHvAs= -github.com/alecthomas/repr v0.0.0-20220113201626-b1b626ac65ae h1:zzGwJfFlFGD94CyyYwCJeSuD32Gj9GTaSi5y9hoVzdY= +github.com/alecthomas/chroma/v2 v2.3.0 h1:83xfxrnjv8eK+Cf8qZDzNo3PPF9IbTWHs7z28GY6D0U= +github.com/alecthomas/chroma/v2 v2.3.0/go.mod h1:mZxeWZlxP2Dy+/8cBob2PYd8O2DwNAzave5AY7A2eQw= github.com/alecthomas/repr v0.0.0-20220113201626-b1b626ac65ae/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8= +github.com/alecthomas/repr v0.1.0 h1:ENn2e1+J3k09gyj2shc0dHr/yjaWSHRlrJ4DPMevDqE= +github.com/alecthomas/repr v0.1.0/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -18,8 +20,11 @@ github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQD github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/yosssi/gcss v0.1.0 h1:jRuino7qq7kqntBIhT+0xSUI5/sBgCA/zCQ1Tuzd6Gg= github.com/yosssi/gcss v0.1.0/go.mod h1:M3mTPOWZWjVROkXKZ2AiDzOBOXu2MqQeDXF/nKO44sI= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 h1:0A+M6Uqn+Eje4kHMK80dtF3JCXC4ykBgQG4Fe06QRhQ= @@ -28,5 +33,6 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/vendor/github.com/Depado/bfchroma/v2/.drone.yml b/vendor/github.com/Depado/bfchroma/v2/.drone.yml new file mode 100644 index 0000000..9fceead --- /dev/null +++ b/vendor/github.com/Depado/bfchroma/v2/.drone.yml @@ -0,0 +1,52 @@ +--- +kind: pipeline +name: default +type: docker + +steps: +- name: test + image: golang:latest + volumes: + - name: deps + path: /go + commands: + - go test -race -coverprofile=coverage.txt -covermode=atomic + +- name: linter + image: golang:latest + volumes: + - name: deps + path: /go + commands: + - curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s + - ./bin/golangci-lint run --timeout 5m + - rm -r ./bin/ + +- name: coverage + image: plugins/codecov + settings: + token: + from_secret: codecov_token + files: + - coverage.txt + +- name: telegram + image: appleboy/drone-telegram + settings: + to: 790376882 + format: markdown + token: + from_secret: telegram_token + message: > + *{{repo.name}}* + [Build {{build.number}}]({{build.link}}) by {{commit.author}} {{#success build.status}}succeeded{{else}}failed{{/success}} in {{buildtime build.started}} + `{{truncate commit.sha 8}}`: "{{commit.message}}" + when: + status: + - success + - failure + +volumes: +- name: deps + host: + path: /var/lib/cache/godeps/ diff --git a/vendor/github.com/Depado/bfchroma/v2/.gitignore b/vendor/github.com/Depado/bfchroma/v2/.gitignore new file mode 100644 index 0000000..ca5c23e --- /dev/null +++ b/vendor/github.com/Depado/bfchroma/v2/.gitignore @@ -0,0 +1,17 @@ +# Binaries for programs and plugins +*.exe +*.dll +*.so +*.dylib + +# 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/ +vendor/ +coverage.txt + diff --git a/vendor/github.com/Depado/bfchroma/v2/LICENSE b/vendor/github.com/Depado/bfchroma/v2/LICENSE new file mode 100644 index 0000000..8864d4a --- /dev/null +++ b/vendor/github.com/Depado/bfchroma/v2/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 + +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/Depado/bfchroma/v2/README.md b/vendor/github.com/Depado/bfchroma/v2/README.md new file mode 100644 index 0000000..0425704 --- /dev/null +++ b/vendor/github.com/Depado/bfchroma/v2/README.md @@ -0,0 +1,206 @@ +# bfchroma + +[![forthebadge](https://forthebadge.com/images/badges/made-with-go.svg)](https://forthebadge.com)[![forthebadge](https://forthebadge.com/images/badges/built-with-love.svg)](https://forthebadge.com) + +[![Go Report Card](https://goreportcard.com/badge/github.com/Depado/bfchroma)](https://goreportcard.com/report/github.com/Depado/bfchroma) +[![Build Status](https://drone.depa.do/api/badges/Depado/bfchroma/status.svg)](https://drone.depa.do/Depado/bfchroma) +[![codecov](https://codecov.io/gh/Depado/bfchroma/branch/master/graph/badge.svg)](https://codecov.io/gh/Depado/bfchroma) +[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Depado/bfchroma/blob/master/LICENSE) +[![Godoc](https://godoc.org/github.com/Depado/bfchroma?status.svg)](https://godoc.org/github.com/Depado/bfchroma) +[![Sourcegraph](https://sourcegraph.com/github.com/Depado/bfchroma/-/badge.svg)](https://sourcegraph.com/github.com/Depado/bfchroma?badge) +[![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/Depado) + + +Integrating [Chroma](https://github.com/alecthomas/chroma) syntax highlighter as +a [Blackfriday](https://github.com/russross/blackfriday) renderer. + +## Install and prerequisites + +This project requires and uses the `v2` version of +[Blackfriday](https://github.com/russross/blackfriday/tree/v2). + +``` +$ go get github.com/Depado/bfchroma +``` + +## Features + +This renderer integrates chroma to highlight code with triple backtick notation. +It will try to use the given language when available otherwise it will try to +detect the language. If none of these two method works it will fallback to sane +defaults. + +## Usage + +bfchroma uses the functional options approach so you can customize the behavior +of the renderer. It uses sane defaults when no option is passed so you can use +the renderer simply by doing so : + +```go +html := bf.Run([]byte(md), bf.WithRenderer(bfchroma.NewRenderer())) +``` + +### Options + +- `Style(s string)` +Define the style used by chroma for the rendering. The full list can be found [here](https://github.com/alecthomas/chroma/tree/master/styles) +- `ChromaStyle(*chroma.Style)` +This option can be used to passe directly a `*chroma.Style` instead of the +string representing the style as with the `Style(string)` option. +- `WithoutAutodetect()` +By default when no language information is written in the code block, this +renderer will try to auto-detect the used language. This option disables +this behavior and will fallback to a sane default when no language +information is available. +- `EmbedCSS()` +This option will embed CSS needed for chroma's `html.WithClasses()` at the beginning of blackfriday document. +CSS can also be extracted separately by calling `Renderer`'s.`ChromaCSS(w)` method, which will return styleshet for currently set style +- `Extend(bf.Renderer)` +This option allows to define the base blackfriday that will be extended. +- `ChromaOptions(...html.Option)` +This option allows you to pass Chroma's html options in the renderer. Such +options can be found [here](https://github.com/alecthomas/chroma#the-html-formatter). + +### Option examples + +Disabling language auto-detection and displaying line numbers + +```go +r := bfchroma.NewRenderer( + bfchroma.WithoutAutodetect(), + bfchroma.ChromaOptions(html.WithLineNumbers()), +) +``` + +Extend a blackfriday renderer + +```go +b := bf.NewHTMLRenderer(bf.HTMLRendererParameters{ + Flags: bf.CommonHTMLFlags, +}) + +r := bfchroma.NewRenderer(bfchroma.Extend(b)) +``` + +Use a different style + +```go +r := bfchroma.NewRenderer(bfchroma.Style("dracula")) +// Or +r = bfchroma.NewRenderer(bfchroma.ChromaStyle(styles.Dracula)) +``` + + + +## Examples + +```go +package main + +import ( + "fmt" + + "github.com/Depado/bfchroma" + + bf "github.com/russross/blackfriday/v2" +) + +var md = "This is some sample code.\n\n```go\n" + + `func main() { + fmt.Println("Hi") +} +` + "```" + +func main() { + html := bf.Run([]byte(md), bf.WithRenderer(bfchroma.NewRenderer())) + fmt.Println(string(html)) +} +``` + + +Will output : + +```html +
This is some sample code.
+func main() { +fmt.Println("Hi") +} ++``` + +## Real-life example + +In [smallblog](https://github.com/Depado/smallblog) I'm using bfchroma to render +my articles. It's using a combination of both bfchroma's options and blackfriday +extensions and flags. + +```go +package main + +import ( + "github.com/Depado/bfchroma" + "github.com/alecthomas/chroma/formatters/html" + bf "github.com/russross/blackfriday/v2" +) + +// Defines the extensions that are used +var exts = bf.NoIntraEmphasis | bf.Tables | bf.FencedCode | bf.Autolink | + bf.Strikethrough | bf.SpaceHeadings | bf.BackslashLineBreak | + bf.DefinitionLists | bf.Footnotes + +// Defines the HTML rendering flags that are used +var flags = bf.UseXHTML | bf.Smartypants | bf.SmartypantsFractions | + bf.SmartypantsDashes | bf.SmartypantsLatexDashes | bf.TOC + +// render will take a []byte input and will render it using a new renderer each +// time because reusing the same can mess with TOC and header IDs +func render(input []byte) []byte { + return bf.Run( + input, + bf.WithRenderer( + bfchroma.NewRenderer( + bfchroma.WithoutAutodetect(), + bfchroma.ChromaOptions( + html.WithLineNumbers(), + ), + bfchroma.Extend( + bf.NewHTMLRenderer(bf.HTMLRendererParameters{ + Flags: flags, + }), + ), + ), + ), + bf.WithExtensions(exts), + ) +} +``` + +## Classes + +If you have loads of code in your markdown, you might want to consider using +`html.WithClasses()` in your `bfchroma.ChromaOptions()`. The CSS of the style +you chose can then be accessed like this : + +```go +r := bfchroma.NewRenderer( + bfchroma.WithoutAutodetect(), + bfchroma.Extend( + bf.NewHTMLRenderer(bf.HTMLRendererParameters{Flags: flags}), + ), + bfchroma.Style("monokai"), + bfchroma.ChromaOptions(html.WithClasses()), +) + +var css template.CSS + +b := new(bytes.Buffer) +if err := r.ChromaCSS(b); err != nil { + logrus.WithError(err).Warning("Couldn't write CSS") +} +css = template.CSS(b.String()) + +bf.Run(input, bf.WithRenderer(r), bf.WithExtensions(exts)) +``` + +This way, you can pass your `css` var to any template and render it along the +rendered markdown. diff --git a/vendor/github.com/Depado/bfchroma/v2/renderer.go b/vendor/github.com/Depado/bfchroma/v2/renderer.go new file mode 100644 index 0000000..a87e75a --- /dev/null +++ b/vendor/github.com/Depado/bfchroma/v2/renderer.go @@ -0,0 +1,147 @@ +// Package bfchroma provides an easy and extensible blackfriday renderer that +// uses the chroma syntax highlighter to render code blocks. +package bfchroma + +import ( + "io" + + "github.com/alecthomas/chroma/v2" + "github.com/alecthomas/chroma/v2/formatters/html" + "github.com/alecthomas/chroma/v2/lexers" + "github.com/alecthomas/chroma/v2/styles" + bf "github.com/russross/blackfriday/v2" +) + +// Option defines the functional option type +type Option func(r *Renderer) + +// Style is a function option allowing to set the style used by chroma +// Default : "monokai" +func Style(s string) Option { + return func(r *Renderer) { + r.Style = styles.Get(s) + } +} + +// ChromaStyle is an option to directly set the style of the renderer using a +// chroma style instead of a string +func ChromaStyle(s *chroma.Style) Option { + return func(r *Renderer) { + r.Style = s + } +} + +// WithoutAutodetect disables chroma's language detection when no codeblock +// extra information is given. It will fallback to a sane default instead of +// trying to detect the language. +func WithoutAutodetect() Option { + return func(r *Renderer) { + r.Autodetect = false + } +} + +// EmbedCSS will embed CSS needed for html.WithClasses() in beginning of the document +func EmbedCSS() Option { + return func(r *Renderer) { + r.embedCSS = true + } +} + +// ChromaOptions allows to pass Chroma html.Option such as Standalone() +// WithClasses(), ClassPrefix(prefix)... +func ChromaOptions(options ...html.Option) Option { + return func(r *Renderer) { + r.ChromaOptions = options + } +} + +// Extend allows to specify the blackfriday renderer which is extended +func Extend(br bf.Renderer) Option { + return func(r *Renderer) { + r.Base = br + } +} + +// NewRenderer will return a new bfchroma renderer with sane defaults +func NewRenderer(options ...Option) *Renderer { + r := &Renderer{ + Base: bf.NewHTMLRenderer(bf.HTMLRendererParameters{ + Flags: bf.CommonHTMLFlags, + }), + Style: styles.Monokai, + Autodetect: true, + } + for _, option := range options { + option(r) + } + r.Formatter = html.New(r.ChromaOptions...) + return r +} + +// RenderWithChroma will render the given text to the w io.Writer +func (r *Renderer) RenderWithChroma(w io.Writer, text []byte, data bf.CodeBlockData) error { + var lexer chroma.Lexer + + // Determining the lexer to use + if len(data.Info) > 0 { + lexer = lexers.Get(string(data.Info)) + } else if r.Autodetect { + lexer = lexers.Analyse(string(text)) + } + if lexer == nil { + lexer = lexers.Fallback + } + + // Tokenize the code + iterator, err := lexer.Tokenise(nil, string(text)) + if err != nil { + return err + } + return r.Formatter.Format(w, r.Style, iterator) +} + +// Renderer is a custom Blackfriday renderer that uses the capabilities of +// chroma to highlight code with triple backtick notation +type Renderer struct { + Base bf.Renderer + Autodetect bool + ChromaOptions []html.Option + Style *chroma.Style + Formatter *html.Formatter + embedCSS bool +} + +// RenderNode satisfies the Renderer interface +func (r *Renderer) RenderNode(w io.Writer, node *bf.Node, entering bool) bf.WalkStatus { + switch node.Type { + case bf.Document: + if entering && r.embedCSS { + w.Write([]byte("")) // nolint: errcheck + } + return r.Base.RenderNode(w, node, entering) + case bf.CodeBlock: + if err := r.RenderWithChroma(w, node.Literal, node.CodeBlockData); err != nil { + return r.Base.RenderNode(w, node, entering) + } + return bf.SkipChildren + default: + return r.Base.RenderNode(w, node, entering) + } +} + +// RenderHeader satisfies the Renderer interface +func (r *Renderer) RenderHeader(w io.Writer, ast *bf.Node) { + r.Base.RenderHeader(w, ast) +} + +// RenderFooter satisfies the Renderer interface +func (r *Renderer) RenderFooter(w io.Writer, ast *bf.Node) { + r.Base.RenderFooter(w, ast) +} + +// ChromaCSS returns CSS used with chroma's html.WithClasses() option +func (r *Renderer) ChromaCSS(w io.Writer) error { + return r.Formatter.WriteCSS(w, r.Style) +} 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..ffaccb6 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/README.md @@ -0,0 +1,285 @@ +# Chroma — A general purpose syntax highlighter in pure Go +[![Golang Documentation](https://godoc.org/github.com/alecthomas/chroma?status.svg)](https://godoc.org/github.com/alecthomas/chroma) [![CI](https://github.com/alecthomas/chroma/actions/workflows/ci.yml/badge.svg)](https://github.com/alecthomas/chroma/actions/workflows/ci.yml) [![Slack chat](https://img.shields.io/static/v1?logo=slack&style=flat&label=slack&color=green&message=gophers)](https://invite.slack.golangbridge.org/) + +> **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. + + +## Table of Contents + + + +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) + + + + +## 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, Chapel, 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, Properties, 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`._ + + +## Try it + +Try out various languages and styles on the [Chroma Playground](https://swapoff.org/chroma/playground/). + + +## 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. + + +### 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") +``` + + +### 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) +``` + + +### 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) +``` + + +### 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) +``` + + +## More detail + + +### 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. + + +### 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. + + +### 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/). + + +## 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`. + + +## 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..b7fd6e0 --- /dev/null +++ b/vendor/github.com/alecthomas/chroma/v2/colour.go @@ -0,0 +1,192 @@ +package chroma + +import ( + "fmt" + "math" + "strconv" + "strings" +) + +// ANSI2RGB maps ANSI colour names, as supported by Chroma, to hex RGB values. +var ANSI2RGB = map[string]string{ + "#ansiblack": "000000", + "#ansidarkred": "7f0000", + "#ansidarkgreen": "007f00", + "#ansibrown": "7f7fe0", + "#ansidarkblue": "00007f", + "#ansipurple": "7f007f", + "#ansiteal": "007f7f", + "#ansilightgray": "e5e5e5", + // Normal + "#ansidarkgray": "555555", + "#ansired": "ff0000", + "#ansigreen": "00ff00", + "#ansiyellow": "ffff00", + "#ansiblue": "0000ff", + "#ansifuchsia": "ff00ff", + "#ansiturquoise": "00ffff", + "#ansiwhite": "ffffff", + + // Aliases without the "ansi" prefix, because...why? + "#black": "000000", + "#darkred": "7f0000", + "#darkgreen": "007f00", + "#brown": "7f7fe0", + "#darkblue": "00007f", + "#purple": "7f007f", + "#teal": "007f7f", + "#lightgray": "e5e5e5", + // Normal + "#darkgray": "555555", + "#red": "ff0000", + "#green": "00ff00", + "#yellow": "ffff00", + "#blue": "0000ff", + "#fuchsia": "ff00ff", + "#turquoise": "00ffff", + "#white": "ffffff", +} + +// Colour represents an RGB colour. +type Colour int32 + +// NewColour creates a Colour directly from RGB values. +func NewColour(r, g, b uint8) Colour { + return ParseColour(fmt.Sprintf("%02x%02x%02x", r, g, b)) +} + +// Distance between this colour and another. +// +// This uses the approach described here (https://www.compuphase.com/cmetric.htm). +// This is not as accurate as LAB, et. al. but is *vastly* simpler and sufficient for our needs. +func (c Colour) Distance(e2 Colour) float64 { + ar, ag, ab := int64(c.Red()), int64(c.Green()), int64(c.Blue()) + br, bg, bb := int64(e2.Red()), int64(e2.Green()), int64(e2.Blue()) + rmean := (ar + br) / 2 + r := ar - br + g := ag - bg + b := ab - bb + return math.Sqrt(float64((((512 + rmean) * r * r) >> 8) + 4*g*g + (((767 - rmean) * b * b) >> 8))) +} + +// Brighten returns a copy of this colour with its brightness adjusted. +// +// If factor is negative, the colour is darkened. +// +// Uses approach described here (http://www.pvladov.com/2012/09/make-color-lighter-or-darker.html). +func (c Colour) Brighten(factor float64) Colour { + r := float64(c.Red()) + g := float64(c.Green()) + b := float64(c.Blue()) + + if factor < 0 { + factor++ + r *= factor + g *= factor + b *= factor + } else { + r = (255-r)*factor + r + g = (255-g)*factor + g + b = (255-b)*factor + b + } + return NewColour(uint8(r), uint8(g), uint8(b)) +} + +// BrightenOrDarken brightens a colour if it is < 0.5 brightness or darkens if > 0.5 brightness. +func (c Colour) BrightenOrDarken(factor float64) Colour { + if c.Brightness() < 0.5 { + return c.Brighten(factor) + } + return c.Brighten(-factor) +} + +// ClampBrightness returns a copy of this colour with its brightness adjusted such that +// it falls within the range [min, max] (or very close to it due to rounding errors). +// The supplied values use the same [0.0, 1.0] range as Brightness. +func (c Colour) ClampBrightness(min, max float64) Colour { + if !c.IsSet() { + return c + } + + min = math.Max(min, 0) + max = math.Min(max, 1) + current := c.Brightness() + target := math.Min(math.Max(current, min), max) + if current == target { + return c + } + + r := float64(c.Red()) + g := float64(c.Green()) + b := float64(c.Blue()) + rgb := r + g + b + if target > current { + // Solve for x: target == ((255-r)*x + r + (255-g)*x + g + (255-b)*x + b) / 255 / 3 + return c.Brighten((target*255*3 - rgb) / (255*3 - rgb)) + } + // Solve for x: target == (r*(x+1) + g*(x+1) + b*(x+1)) / 255 / 3 + return c.Brighten((target*255*3)/rgb - 1) +} + +// Brightness of the colour (roughly) in the range 0.0 to 1.0. +func (c Colour) Brightness() float64 { + return (float64(c.Red()) + float64(c.Green()) + float64(c.Blue())) / 255.0 / 3.0 +} + +// ParseColour in the forms #rgb, #rrggbb, #ansi
`, styleAttr)
+ }
+
+ return ``
+ },
+ end: func(code bool) string {
+ if code {
+ return `
`
+ }
+
+ 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 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 endelement. + 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(`
`, styleAttr)
+ }
+
+ return fmt.Sprintf(``, styleAttr)
+ },
+ end: func(code bool) string {
+ if code {
+ return `
`
+ }
+
+ return ``
+ },
+ }
+)
+
+// 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, "\n")
+ if f.Classes {
+ fmt.Fprint(w, "")
+ }
+ fmt.Fprintf(w, "\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 \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, "", f.styleAttr(css, chroma.LineHighlight)) + } + + fmt.Fprintf(w, "%s\n", f.styleAttr(css, chroma.LineNumbersTable), f.lineIDAttribute(line), f.lineTitleWithLinkIfNeeded(lineDigits, line)) + + if highlight { + fmt.Fprintf(w, "") + } + } + fmt.Fprint(w, f.preWrapper.End(false)) + fmt.Fprint(w, " | \n") + fmt.Fprintf(w, "\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, ``) + } else { + fmt.Fprintf(w, "%s>", f.styleAttr(css, chroma.Line)) + } + + // Line number + if f.lineNumbers && !wrapInTable { + fmt.Fprintf(w, "%s", f.styleAttr(css, chroma.LineNumbers), f.lineIDAttribute(line), f.lineTitleWithLinkIfNeeded(lineDigits, line)) + } + + fmt.Fprintf(w, ``, 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("%s", attr, html) + } + fmt.Fprint(w, html) + } + + if !(f.preventSurroundingPre || f.inlineCode) { + fmt.Fprint(w, ``) // End of CodeLine + + fmt.Fprint(w, ``) // End of Line + } + } + fmt.Fprintf(w, f.preWrapper.End(true)) + + if wrapInTable { + fmt.Fprint(w, " |
, B, ...
+ {
+ `(?[CBIUDTKRPAELZVMSXN])(?<+|«)`,
+ 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": {
+ {`(?>(?!\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": {
+ {
+ `(?\.)(?` + 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": {
+ {`(? -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 = `(? 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.*(?)(`__?)", 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, Pop(1)},
+ {`.+?`, Other, nil},
+ },
+ "templates": {
+ {`}`, Punctuation, Pop(1)},
+ // Let TypeScript handle strings and the curly braces inside them
+ {`(?]*>`, 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": {
+ {`(?>=|>>>=|>>>|<<|>>|<=|>=|\^=|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\||<-|\+\+|--|==|!=|:=|\.\.\.|\.\.|[+\-*/%&|^~=#@!])`, 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:
+//
+//
+//
+//
+// [<$EMITTER ...>]
+// [<$MUTATOR ...>]
+//
+//
+//
+//
+// eg. Include("String") would become:
+//
+//
+//
+//
+//
+// [null, null, {"kind": "include", "state": "String"}]
+//
+// eg. Rule{`\d+`, Text, nil} would become:
+//
+//
+//
+//
+//
+// eg. Rule{`"`, String, Push("String")}
+//
+//
+//
+//
+//
+//
+// eg. Rule{`(\w+)(\n)`, ByGroups(Keyword, Whitespace), nil},
+//
+//
+//
+//
+//
+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 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..8edea13
--- /dev/null
+++ b/vendor/github.com/alecthomas/chroma/v2/style.go
@@ -0,0 +1,366 @@
+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 not having to check errors on each Add().
+ entry, _ := ParseStyleEntry(s.entries[ttype])
+ if s.parent != nil {
+ entry = entry.Inherit(s.parent.Get(ttype))
+ }
+ return entry
+}
+
+// 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
+}
+
+// Transform passes each style entry currently defined in the builder to the supplied
+// function and saves the returned value. This can be used to adjust a style's colours;
+// see Colour's ClampBrightness function, for example.
+func (s *StyleBuilder) Transform(transform func(StyleEntry) StyleEntry) *StyleBuilder {
+ types := make(map[TokenType]struct{})
+ for tt := range s.entries {
+ types[tt] = struct{}{}
+ }
+ if s.parent != nil {
+ for _, tt := range s.parent.Types() {
+ types[tt] = struct{}{}
+ }
+ }
+ for tt := range types {
+ s.AddEntry(tt, transform(s.Get(tt)))
+ }
+ 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-dark.go b/vendor/github.com/alecthomas/chroma/v2/styles/github-dark.go
new file mode 100644
index 0000000..48c0d61
--- /dev/null
+++ b/vendor/github.com/alecthomas/chroma/v2/styles/github-dark.go
@@ -0,0 +1,86 @@
+package styles
+
+import (
+ "fmt"
+
+ "github.com/alecthomas/chroma/v2"
+)
+
+var (
+ // colors used from https://github.com/primer/primitives
+ ghRed2 = "#ffa198"
+ ghRed3 = "#ff7b72"
+ ghRed9 = "#490202"
+ ghOrange2 = "#ffa657"
+ ghOrange3 = "#f0883e"
+ ghGreen1 = "#7ee787"
+ ghGreen2 = "#56d364"
+ ghGreen7 = "#0f5323"
+ ghBlue1 = "#a5d6ff"
+ ghBlue2 = "#79c0ff"
+ ghPurple2 = "#d2a8ff"
+ ghGray3 = "#8b949e"
+ ghGray4 = "#6e7681"
+ ghFgSubtle = "#6e7681"
+ ghFgDefault = "#c9d1d9"
+ ghBgDefault = "#0d1117"
+ ghDangerFg = "#f85149"
+)
+
+// GitHub Dark style.
+var GitHubDark = Register(chroma.MustNewStyle("github-dark", chroma.StyleEntries{
+ // Default Token Style
+ chroma.Background: fmt.Sprintf("bg:%s %s", ghBgDefault, ghFgDefault),
+
+ chroma.LineNumbers: ghGray4,
+ // has transparency in VS Code theme as `colors.codemirror.activelineBg`
+ chroma.LineHighlight: ghGray4,
+
+ chroma.Error: ghDangerFg,
+
+ chroma.Keyword: ghRed3,
+ chroma.KeywordConstant: ghBlue2,
+ chroma.KeywordPseudo: ghBlue2,
+
+ chroma.Name: ghFgDefault,
+ chroma.NameClass: "bold " + ghOrange3,
+ chroma.NameConstant: "bold " + ghBlue2,
+ chroma.NameDecorator: "bold " + ghPurple2,
+ chroma.NameEntity: ghOrange2,
+ chroma.NameException: "bold " + ghOrange3,
+ chroma.NameFunction: "bold " + ghPurple2,
+ chroma.NameLabel: "bold " + ghBlue2,
+ chroma.NameNamespace: ghRed3,
+ chroma.NameProperty: ghBlue2,
+ chroma.NameTag: ghGreen1,
+ chroma.NameVariable: ghBlue2,
+
+ chroma.Literal: ghBlue1,
+ chroma.LiteralDate: ghBlue2,
+ chroma.LiteralStringAffix: ghBlue2,
+ chroma.LiteralStringDelimiter: ghBlue2,
+ chroma.LiteralStringEscape: ghBlue2,
+ chroma.LiteralStringHeredoc: ghBlue2,
+ chroma.LiteralStringRegex: ghBlue2,
+
+ chroma.Operator: "bold " + ghRed3,
+
+ chroma.Comment: "italic " + ghGray3,
+ chroma.CommentPreproc: "bold " + ghGray3,
+ chroma.CommentSpecial: "bold italic " + ghGray3,
+
+ chroma.Generic: ghFgDefault,
+ chroma.GenericDeleted: fmt.Sprintf("bg:%s %s", ghRed9, ghRed2),
+ chroma.GenericEmph: "italic",
+ chroma.GenericError: ghRed2,
+ chroma.GenericHeading: "bold " + ghBlue2,
+ chroma.GenericInserted: fmt.Sprintf("bg:%s %s", ghGreen7, ghGreen2),
+ chroma.GenericOutput: ghGray3,
+ chroma.GenericPrompt: ghGray3,
+ chroma.GenericStrong: "bold",
+ chroma.GenericSubheading: ghBlue2,
+ chroma.GenericTraceback: ghRed3,
+ chroma.GenericUnderline: "underline",
+
+ chroma.TextWhitespace: ghFgSubtle,
+}))
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-light.go b/vendor/github.com/alecthomas/chroma/v2/styles/gruvbox-light.go
new file mode 100644
index 0000000..6f6de7c
--- /dev/null
+++ b/vendor/github.com/alecthomas/chroma/v2/styles/gruvbox-light.go
@@ -0,0 +1,40 @@
+package styles
+
+import (
+ "github.com/alecthomas/chroma/v2"
+)
+
+// Gruvbox light style.
+var GruvboxLight = Register(chroma.MustNewStyle("gruvbox-light", chroma.StyleEntries{
+ chroma.CommentPreproc: "noinherit #427B58",
+ chroma.Comment: "#928374 italic",
+ chroma.GenericDeleted: "noinherit #282828 bg:#9D0006",
+ chroma.GenericEmph: "#076678 underline",
+ chroma.GenericError: "bg:#9D0006 bold",
+ chroma.GenericHeading: "#79740E bold",
+ chroma.GenericInserted: "noinherit #282828 bg:#79740E",
+ chroma.GenericOutput: "noinherit #504945",
+ chroma.GenericPrompt: "#3C3836",
+ chroma.GenericStrong: "#3C3836",
+ chroma.GenericSubheading: "#79740E bold",
+ chroma.GenericTraceback: "bg:#3C3836 bold",
+ chroma.Generic: "#3C3836",
+ chroma.KeywordType: "noinherit #B57614",
+ chroma.Keyword: "noinherit #AF3A03",
+ chroma.NameAttribute: "#79740E bold",
+ chroma.NameBuiltin: "#B57614",
+ chroma.NameConstant: "noinherit #d3869b",
+ chroma.NameEntity: "noinherit #B57614",
+ chroma.NameException: "noinherit #fb4934",
+ chroma.NameFunction: "#B57614",
+ chroma.NameLabel: "noinherit #9D0006",
+ chroma.NameTag: "noinherit #9D0006",
+ chroma.NameVariable: "noinherit #3C3836",
+ chroma.Name: "#3C3836",
+ chroma.LiteralNumberFloat: "noinherit #8F3F71",
+ chroma.LiteralNumber: "noinherit #8F3F71",
+ chroma.Operator: "#AF3A03",
+ chroma.LiteralStringSymbol: "#076678",
+ chroma.LiteralString: "noinherit #79740E",
+ chroma.Background: "noinherit #3C3836 bg:#FBF1C7 bg:#FBF1C7",
+}))
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:----: \\| --------\n).*?(?P\n\n)", re.DOTALL)
+ replacement = r"\g%s\g" % 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)
+}
diff --git a/vendor/github.com/dlclark/regexp2/.gitignore b/vendor/github.com/dlclark/regexp2/.gitignore
new file mode 100644
index 0000000..fb844c3
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/.gitignore
@@ -0,0 +1,27 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+*.out
+
+.DS_Store
diff --git a/vendor/github.com/dlclark/regexp2/.travis.yml b/vendor/github.com/dlclark/regexp2/.travis.yml
new file mode 100644
index 0000000..2aa5ea1
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/.travis.yml
@@ -0,0 +1,5 @@
+language: go
+
+go:
+ - 1.9
+ - tip
\ No newline at end of file
diff --git a/vendor/github.com/dlclark/regexp2/ATTRIB b/vendor/github.com/dlclark/regexp2/ATTRIB
new file mode 100644
index 0000000..cdf4560
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/ATTRIB
@@ -0,0 +1,133 @@
+============
+These pieces of code were ported from dotnet/corefx:
+
+syntax/charclass.go (from RegexCharClass.cs): ported to use the built-in Go unicode classes. Canonicalize is
+ a direct port, but most of the other code required large changes because the C# implementation
+ used a string to represent the CharSet data structure and I cleaned that up in my implementation.
+
+syntax/code.go (from RegexCode.cs): ported literally with various cleanups and layout to make it more Go-ish.
+
+syntax/escape.go (from RegexParser.cs): ported Escape method and added some optimizations. Unescape is inspired by
+ the C# implementation but couldn't be directly ported because of the lack of do-while syntax in Go.
+
+syntax/parser.go (from RegexpParser.cs and RegexOptions.cs): ported parser struct and associated methods as
+ literally as possible. Several language differences required changes. E.g. lack pre/post-fix increments as
+ expressions, lack of do-while loops, lack of overloads, etc.
+
+syntax/prefix.go (from RegexFCD.cs and RegexBoyerMoore.cs): ported as literally as possible and added support
+ for unicode chars that are longer than the 16-bit char in C# for the 32-bit rune in Go.
+
+syntax/replacerdata.go (from RegexReplacement.cs): conceptually ported and re-organized to handle differences
+ in charclass implementation, and fix odd code layout between RegexParser.cs, Regex.cs, and RegexReplacement.cs.
+
+syntax/tree.go (from RegexTree.cs and RegexNode.cs): ported literally as possible.
+
+syntax/writer.go (from RegexWriter.cs): ported literally with minor changes to make it more Go-ish.
+
+match.go (from RegexMatch.cs): ported, simplified, and changed to handle Go's lack of inheritence.
+
+regexp.go (from Regex.cs and RegexOptions.cs): conceptually serves the same "starting point", but is simplified
+ and changed to handle differences in C# strings and Go strings/runes.
+
+replace.go (from RegexReplacement.cs): ported closely and then cleaned up to combine the MatchEvaluator and
+ simple string replace implementations.
+
+runner.go (from RegexRunner.cs): ported literally as possible.
+
+regexp_test.go (from CaptureTests.cs and GroupNamesAndNumbers.cs): conceptually ported, but the code was
+ manually structured like Go tests.
+
+replace_test.go (from RegexReplaceStringTest0.cs): conceptually ported
+
+rtl_test.go (from RightToLeft.cs): conceptually ported
+---
+dotnet/corefx was released under this license:
+
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation
+
+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.
+
+============
+These pieces of code are copied from the Go framework:
+
+- The overall directory structure of regexp2 was inspired by the Go runtime regexp package.
+- The optimization in the escape method of syntax/escape.go is from the Go runtime QuoteMeta() func in regexp/regexp.go
+- The method signatures in regexp.go are designed to match the Go framework regexp methods closely
+- func regexp2.MustCompile and func quote are almost identifical to the regexp package versions
+- BenchmarkMatch* and TestProgramTooLong* funcs in regexp_performance_test.go were copied from the framework
+ regexp/exec_test.go
+---
+The Go framework was released under this license:
+
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+============
+Some test data were gathered from the Mono project.
+
+regexp_mono_test.go: ported from https://github.com/mono/mono/blob/master/mcs/class/System/Test/System.Text.RegularExpressions/PerlTrials.cs
+---
+Mono tests released under this license:
+
+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/dlclark/regexp2/LICENSE b/vendor/github.com/dlclark/regexp2/LICENSE
new file mode 100644
index 0000000..fe83dfd
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Doug Clark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/dlclark/regexp2/README.md b/vendor/github.com/dlclark/regexp2/README.md
new file mode 100644
index 0000000..4e4abb4
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/README.md
@@ -0,0 +1,83 @@
+# regexp2 - full featured regular expressions for Go
+Regexp2 is a feature-rich RegExp engine for Go. It doesn't have constant time guarantees like the built-in `regexp` package, but it allows backtracking and is compatible with Perl5 and .NET. You'll likely be better off with the RE2 engine from the `regexp` package and should only use this if you need to write very complex patterns or require compatibility with .NET.
+
+## Basis of the engine
+The engine is ported from the .NET framework's System.Text.RegularExpressions.Regex engine. That engine was open sourced in 2015 under the MIT license. There are some fundamental differences between .NET strings and Go strings that required a bit of borrowing from the Go framework regex engine as well. I cleaned up a couple of the dirtier bits during the port (regexcharclass.cs was terrible), but the parse tree, code emmitted, and therefore patterns matched should be identical.
+
+## Installing
+This is a go-gettable library, so install is easy:
+
+ go get github.com/dlclark/regexp2/...
+
+## Usage
+Usage is similar to the Go `regexp` package. Just like in `regexp`, you start by converting a regex into a state machine via the `Compile` or `MustCompile` methods. They ultimately do the same thing, but `MustCompile` will panic if the regex is invalid. You can then use the provided `Regexp` struct to find matches repeatedly. A `Regexp` struct is safe to use across goroutines.
+
+```go
+re := regexp2.MustCompile(`Your pattern`, 0)
+if isMatch, _ := re.MatchString(`Something to match`); isMatch {
+ //do something
+}
+```
+
+The only error that the `*Match*` methods *should* return is a Timeout if you set the `re.MatchTimeout` field. Any other error is a bug in the `regexp2` package. If you need more details about capture groups in a match then use the `FindStringMatch` method, like so:
+
+```go
+if m, _ := re.FindStringMatch(`Something to match`); m != nil {
+ // the whole match is always group 0
+ fmt.Printf("Group 0: %v\n", m.String())
+
+ // you can get all the groups too
+ gps := m.Groups()
+
+ // a group can be captured multiple times, so each cap is separately addressable
+ fmt.Printf("Group 1, first capture", gps[1].Captures[0].String())
+ fmt.Printf("Group 1, second capture", gps[1].Captures[1].String())
+}
+```
+
+Group 0 is embedded in the Match. Group 0 is an automatically-assigned group that encompasses the whole pattern. This means that `m.String()` is the same as `m.Group.String()` and `m.Groups()[0].String()`
+
+The __last__ capture is embedded in each group, so `g.String()` will return the same thing as `g.Capture.String()` and `g.Captures[len(g.Captures)-1].String()`.
+
+## Compare `regexp` and `regexp2`
+| Category | regexp | regexp2 |
+| --- | --- | --- |
+| Catastrophic backtracking possible | no, constant execution time guarantees | yes, if your pattern is at risk you can use the `re.MatchTimeout` field |
+| Python-style capture groups `(?Pre)` | yes | no (yes in RE2 compat mode) |
+| .NET-style capture groups `(?re)` or `(?'name're)` | no | yes |
+| comments `(?#comment)` | no | yes |
+| branch numbering reset `(?\|a\|b)` | no | no |
+| possessive match `(?>re)` | no | yes |
+| positive lookahead `(?=re)` | no | yes |
+| negative lookahead `(?!re)` | no | yes |
+| positive lookbehind `(?<=re)` | no | yes |
+| negative lookbehind `(?re)`)
+* change singleline behavior for `$` to only match end of string (like RE2) (see [#24](https://github.com/dlclark/regexp2/issues/24))
+
+```go
+re := regexp2.MustCompile(`Your RE2-compatible pattern`, regexp2.RE2)
+if isMatch, _ := re.MatchString(`Something to match`); isMatch {
+ //do something
+}
+```
+
+This feature is a work in progress and I'm open to ideas for more things to put here (maybe more relaxed character escaping rules?).
+
+
+## Library features that I'm still working on
+- Regex split
+
+## Potential bugs
+I've run a battery of tests against regexp2 from various sources and found the debug output matches the .NET engine, but .NET and Go handle strings very differently. I've attempted to handle these differences, but most of my testing deals with basic ASCII with a little bit of multi-byte Unicode. There's a chance that there are bugs in the string handling related to character sets with supplementary Unicode chars. Right-to-Left support is coded, but not well tested either.
+
+## Find a bug?
+I'm open to new issues and pull requests with tests if you find something odd!
diff --git a/vendor/github.com/dlclark/regexp2/match.go b/vendor/github.com/dlclark/regexp2/match.go
new file mode 100644
index 0000000..1871cff
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/match.go
@@ -0,0 +1,347 @@
+package regexp2
+
+import (
+ "bytes"
+ "fmt"
+)
+
+// Match is a single regex result match that contains groups and repeated captures
+// -Groups
+// -Capture
+type Match struct {
+ Group //embeded group 0
+
+ regex *Regexp
+ otherGroups []Group
+
+ // input to the match
+ textpos int
+ textstart int
+
+ capcount int
+ caps []int
+ sparseCaps map[int]int
+
+ // output from the match
+ matches [][]int
+ matchcount []int
+
+ // whether we've done any balancing with this match. If we
+ // have done balancing, we'll need to do extra work in Tidy().
+ balancing bool
+}
+
+// Group is an explicit or implit (group 0) matched group within the pattern
+type Group struct {
+ Capture // the last capture of this group is embeded for ease of use
+
+ Name string // group name
+ Captures []Capture // captures of this group
+}
+
+// Capture is a single capture of text within the larger original string
+type Capture struct {
+ // the original string
+ text []rune
+ // the position in the original string where the first character of
+ // captured substring was found.
+ Index int
+ // the length of the captured substring.
+ Length int
+}
+
+// String returns the captured text as a String
+func (c *Capture) String() string {
+ return string(c.text[c.Index : c.Index+c.Length])
+}
+
+// Runes returns the captured text as a rune slice
+func (c *Capture) Runes() []rune {
+ return c.text[c.Index : c.Index+c.Length]
+}
+
+func newMatch(regex *Regexp, capcount int, text []rune, startpos int) *Match {
+ m := Match{
+ regex: regex,
+ matchcount: make([]int, capcount),
+ matches: make([][]int, capcount),
+ textstart: startpos,
+ balancing: false,
+ }
+ m.Name = "0"
+ m.text = text
+ m.matches[0] = make([]int, 2)
+ return &m
+}
+
+func newMatchSparse(regex *Regexp, caps map[int]int, capcount int, text []rune, startpos int) *Match {
+ m := newMatch(regex, capcount, text, startpos)
+ m.sparseCaps = caps
+ return m
+}
+
+func (m *Match) reset(text []rune, textstart int) {
+ m.text = text
+ m.textstart = textstart
+ for i := 0; i < len(m.matchcount); i++ {
+ m.matchcount[i] = 0
+ }
+ m.balancing = false
+}
+
+func (m *Match) tidy(textpos int) {
+
+ interval := m.matches[0]
+ m.Index = interval[0]
+ m.Length = interval[1]
+ m.textpos = textpos
+ m.capcount = m.matchcount[0]
+ //copy our root capture to the list
+ m.Group.Captures = []Capture{m.Group.Capture}
+
+ if m.balancing {
+ // The idea here is that we want to compact all of our unbalanced captures. To do that we
+ // use j basically as a count of how many unbalanced captures we have at any given time
+ // (really j is an index, but j/2 is the count). First we skip past all of the real captures
+ // until we find a balance captures. Then we check each subsequent entry. If it's a balance
+ // capture (it's negative), we decrement j. If it's a real capture, we increment j and copy
+ // it down to the last free position.
+ for cap := 0; cap < len(m.matchcount); cap++ {
+ limit := m.matchcount[cap] * 2
+ matcharray := m.matches[cap]
+
+ var i, j int
+
+ for i = 0; i < limit; i++ {
+ if matcharray[i] < 0 {
+ break
+ }
+ }
+
+ for j = i; i < limit; i++ {
+ if matcharray[i] < 0 {
+ // skip negative values
+ j--
+ } else {
+ // but if we find something positive (an actual capture), copy it back to the last
+ // unbalanced position.
+ if i != j {
+ matcharray[j] = matcharray[i]
+ }
+ j++
+ }
+ }
+
+ m.matchcount[cap] = j / 2
+ }
+
+ m.balancing = false
+ }
+}
+
+// isMatched tells if a group was matched by capnum
+func (m *Match) isMatched(cap int) bool {
+ return cap < len(m.matchcount) && m.matchcount[cap] > 0 && m.matches[cap][m.matchcount[cap]*2-1] != (-3+1)
+}
+
+// matchIndex returns the index of the last specified matched group by capnum
+func (m *Match) matchIndex(cap int) int {
+ i := m.matches[cap][m.matchcount[cap]*2-2]
+ if i >= 0 {
+ return i
+ }
+
+ return m.matches[cap][-3-i]
+}
+
+// matchLength returns the length of the last specified matched group by capnum
+func (m *Match) matchLength(cap int) int {
+ i := m.matches[cap][m.matchcount[cap]*2-1]
+ if i >= 0 {
+ return i
+ }
+
+ return m.matches[cap][-3-i]
+}
+
+// Nonpublic builder: add a capture to the group specified by "c"
+func (m *Match) addMatch(c, start, l int) {
+
+ if m.matches[c] == nil {
+ m.matches[c] = make([]int, 2)
+ }
+
+ capcount := m.matchcount[c]
+
+ if capcount*2+2 > len(m.matches[c]) {
+ oldmatches := m.matches[c]
+ newmatches := make([]int, capcount*8)
+ copy(newmatches, oldmatches[:capcount*2])
+ m.matches[c] = newmatches
+ }
+
+ m.matches[c][capcount*2] = start
+ m.matches[c][capcount*2+1] = l
+ m.matchcount[c] = capcount + 1
+ //log.Printf("addMatch: c=%v, i=%v, l=%v ... matches: %v", c, start, l, m.matches)
+}
+
+// Nonpublic builder: Add a capture to balance the specified group. This is used by the
+// balanced match construct. (?...)
+//
+// If there were no such thing as backtracking, this would be as simple as calling RemoveMatch(c).
+// However, since we have backtracking, we need to keep track of everything.
+func (m *Match) balanceMatch(c int) {
+ m.balancing = true
+
+ // we'll look at the last capture first
+ capcount := m.matchcount[c]
+ target := capcount*2 - 2
+
+ // first see if it is negative, and therefore is a reference to the next available
+ // capture group for balancing. If it is, we'll reset target to point to that capture.
+ if m.matches[c][target] < 0 {
+ target = -3 - m.matches[c][target]
+ }
+
+ // move back to the previous capture
+ target -= 2
+
+ // if the previous capture is a reference, just copy that reference to the end. Otherwise, point to it.
+ if target >= 0 && m.matches[c][target] < 0 {
+ m.addMatch(c, m.matches[c][target], m.matches[c][target+1])
+ } else {
+ m.addMatch(c, -3-target, -4-target /* == -3 - (target + 1) */)
+ }
+}
+
+// Nonpublic builder: removes a group match by capnum
+func (m *Match) removeMatch(c int) {
+ m.matchcount[c]--
+}
+
+// GroupCount returns the number of groups this match has matched
+func (m *Match) GroupCount() int {
+ return len(m.matchcount)
+}
+
+// GroupByName returns a group based on the name of the group, or nil if the group name does not exist
+func (m *Match) GroupByName(name string) *Group {
+ num := m.regex.GroupNumberFromName(name)
+ if num < 0 {
+ return nil
+ }
+ return m.GroupByNumber(num)
+}
+
+// GroupByNumber returns a group based on the number of the group, or nil if the group number does not exist
+func (m *Match) GroupByNumber(num int) *Group {
+ // check our sparse map
+ if m.sparseCaps != nil {
+ if newNum, ok := m.sparseCaps[num]; ok {
+ num = newNum
+ }
+ }
+ if num >= len(m.matchcount) || num < 0 {
+ return nil
+ }
+
+ if num == 0 {
+ return &m.Group
+ }
+
+ m.populateOtherGroups()
+
+ return &m.otherGroups[num-1]
+}
+
+// Groups returns all the capture groups, starting with group 0 (the full match)
+func (m *Match) Groups() []Group {
+ m.populateOtherGroups()
+ g := make([]Group, len(m.otherGroups)+1)
+ g[0] = m.Group
+ copy(g[1:], m.otherGroups)
+ return g
+}
+
+func (m *Match) populateOtherGroups() {
+ // Construct all the Group objects first time called
+ if m.otherGroups == nil {
+ m.otherGroups = make([]Group, len(m.matchcount)-1)
+ for i := 0; i < len(m.otherGroups); i++ {
+ m.otherGroups[i] = newGroup(m.regex.GroupNameFromNumber(i+1), m.text, m.matches[i+1], m.matchcount[i+1])
+ }
+ }
+}
+
+func (m *Match) groupValueAppendToBuf(groupnum int, buf *bytes.Buffer) {
+ c := m.matchcount[groupnum]
+ if c == 0 {
+ return
+ }
+
+ matches := m.matches[groupnum]
+
+ index := matches[(c-1)*2]
+ last := index + matches[(c*2)-1]
+
+ for ; index < last; index++ {
+ buf.WriteRune(m.text[index])
+ }
+}
+
+func newGroup(name string, text []rune, caps []int, capcount int) Group {
+ g := Group{}
+ g.text = text
+ if capcount > 0 {
+ g.Index = caps[(capcount-1)*2]
+ g.Length = caps[(capcount*2)-1]
+ }
+ g.Name = name
+ g.Captures = make([]Capture, capcount)
+ for i := 0; i < capcount; i++ {
+ g.Captures[i] = Capture{
+ text: text,
+ Index: caps[i*2],
+ Length: caps[i*2+1],
+ }
+ }
+ //log.Printf("newGroup! capcount %v, %+v", capcount, g)
+
+ return g
+}
+
+func (m *Match) dump() string {
+ buf := &bytes.Buffer{}
+ buf.WriteRune('\n')
+ if len(m.sparseCaps) > 0 {
+ for k, v := range m.sparseCaps {
+ fmt.Fprintf(buf, "Slot %v -> %v\n", k, v)
+ }
+ }
+
+ for i, g := range m.Groups() {
+ fmt.Fprintf(buf, "Group %v (%v), %v caps:\n", i, g.Name, len(g.Captures))
+
+ for _, c := range g.Captures {
+ fmt.Fprintf(buf, " (%v, %v) %v\n", c.Index, c.Length, c.String())
+ }
+ }
+ /*
+ for i := 0; i < len(m.matchcount); i++ {
+ fmt.Fprintf(buf, "\nGroup %v (%v):\n", i, m.regex.GroupNameFromNumber(i))
+
+ for j := 0; j < m.matchcount[i]; j++ {
+ text := ""
+
+ if m.matches[i][j*2] >= 0 {
+ start := m.matches[i][j*2]
+ text = m.text[start : start+m.matches[i][j*2+1]]
+ }
+
+ fmt.Fprintf(buf, " (%v, %v) %v\n", m.matches[i][j*2], m.matches[i][j*2+1], text)
+ }
+ }
+ */
+ return buf.String()
+}
diff --git a/vendor/github.com/dlclark/regexp2/regexp.go b/vendor/github.com/dlclark/regexp2/regexp.go
new file mode 100644
index 0000000..7c7b01d
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/regexp.go
@@ -0,0 +1,355 @@
+/*
+Package regexp2 is a regexp package that has an interface similar to Go's framework regexp engine but uses a
+more feature full regex engine behind the scenes.
+
+It doesn't have constant time guarantees, but it allows backtracking and is compatible with Perl5 and .NET.
+You'll likely be better off with the RE2 engine from the regexp package and should only use this if you
+need to write very complex patterns or require compatibility with .NET.
+*/
+package regexp2
+
+import (
+ "errors"
+ "math"
+ "strconv"
+ "sync"
+ "time"
+
+ "github.com/dlclark/regexp2/syntax"
+)
+
+// Default timeout used when running regexp matches -- "forever"
+var DefaultMatchTimeout = time.Duration(math.MaxInt64)
+
+// Regexp is the representation of a compiled regular expression.
+// A Regexp is safe for concurrent use by multiple goroutines.
+type Regexp struct {
+ //timeout when trying to find matches
+ MatchTimeout time.Duration
+
+ // read-only after Compile
+ pattern string // as passed to Compile
+ options RegexOptions // options
+
+ caps map[int]int // capnum->index
+ capnames map[string]int //capture group name -> index
+ capslist []string //sorted list of capture group names
+ capsize int // size of the capture array
+
+ code *syntax.Code // compiled program
+
+ // cache of machines for running regexp
+ muRun sync.Mutex
+ runner []*runner
+}
+
+// Compile parses a regular expression and returns, if successful,
+// a Regexp object that can be used to match against text.
+func Compile(expr string, opt RegexOptions) (*Regexp, error) {
+ // parse it
+ tree, err := syntax.Parse(expr, syntax.RegexOptions(opt))
+ if err != nil {
+ return nil, err
+ }
+
+ // translate it to code
+ code, err := syntax.Write(tree)
+ if err != nil {
+ return nil, err
+ }
+
+ // return it
+ return &Regexp{
+ pattern: expr,
+ options: opt,
+ caps: code.Caps,
+ capnames: tree.Capnames,
+ capslist: tree.Caplist,
+ capsize: code.Capsize,
+ code: code,
+ MatchTimeout: DefaultMatchTimeout,
+ }, nil
+}
+
+// MustCompile is like Compile but panics if the expression cannot be parsed.
+// It simplifies safe initialization of global variables holding compiled regular
+// expressions.
+func MustCompile(str string, opt RegexOptions) *Regexp {
+ regexp, error := Compile(str, opt)
+ if error != nil {
+ panic(`regexp2: Compile(` + quote(str) + `): ` + error.Error())
+ }
+ return regexp
+}
+
+// Escape adds backslashes to any special characters in the input string
+func Escape(input string) string {
+ return syntax.Escape(input)
+}
+
+// Unescape removes any backslashes from previously-escaped special characters in the input string
+func Unescape(input string) (string, error) {
+ return syntax.Unescape(input)
+}
+
+// String returns the source text used to compile the regular expression.
+func (re *Regexp) String() string {
+ return re.pattern
+}
+
+func quote(s string) string {
+ if strconv.CanBackquote(s) {
+ return "`" + s + "`"
+ }
+ return strconv.Quote(s)
+}
+
+// RegexOptions impact the runtime and parsing behavior
+// for each specific regex. They are setable in code as well
+// as in the regex pattern itself.
+type RegexOptions int32
+
+const (
+ None RegexOptions = 0x0
+ IgnoreCase = 0x0001 // "i"
+ Multiline = 0x0002 // "m"
+ ExplicitCapture = 0x0004 // "n"
+ Compiled = 0x0008 // "c"
+ Singleline = 0x0010 // "s"
+ IgnorePatternWhitespace = 0x0020 // "x"
+ RightToLeft = 0x0040 // "r"
+ Debug = 0x0080 // "d"
+ ECMAScript = 0x0100 // "e"
+ RE2 = 0x0200 // RE2 (regexp package) compatibility mode
+)
+
+func (re *Regexp) RightToLeft() bool {
+ return re.options&RightToLeft != 0
+}
+
+func (re *Regexp) Debug() bool {
+ return re.options&Debug != 0
+}
+
+// Replace searches the input string and replaces each match found with the replacement text.
+// Count will limit the number of matches attempted and startAt will allow
+// us to skip past possible matches at the start of the input (left or right depending on RightToLeft option).
+// Set startAt and count to -1 to go through the whole string
+func (re *Regexp) Replace(input, replacement string, startAt, count int) (string, error) {
+ data, err := syntax.NewReplacerData(replacement, re.caps, re.capsize, re.capnames, syntax.RegexOptions(re.options))
+ if err != nil {
+ return "", err
+ }
+ //TODO: cache ReplacerData
+
+ return replace(re, data, nil, input, startAt, count)
+}
+
+// ReplaceFunc searches the input string and replaces each match found using the string from the evaluator
+// Count will limit the number of matches attempted and startAt will allow
+// us to skip past possible matches at the start of the input (left or right depending on RightToLeft option).
+// Set startAt and count to -1 to go through the whole string.
+func (re *Regexp) ReplaceFunc(input string, evaluator MatchEvaluator, startAt, count int) (string, error) {
+ return replace(re, nil, evaluator, input, startAt, count)
+}
+
+// FindStringMatch searches the input string for a Regexp match
+func (re *Regexp) FindStringMatch(s string) (*Match, error) {
+ // convert string to runes
+ return re.run(false, -1, getRunes(s))
+}
+
+// FindRunesMatch searches the input rune slice for a Regexp match
+func (re *Regexp) FindRunesMatch(r []rune) (*Match, error) {
+ return re.run(false, -1, r)
+}
+
+// FindStringMatchStartingAt searches the input string for a Regexp match starting at the startAt index
+func (re *Regexp) FindStringMatchStartingAt(s string, startAt int) (*Match, error) {
+ if startAt > len(s) {
+ return nil, errors.New("startAt must be less than the length of the input string")
+ }
+ r, startAt := re.getRunesAndStart(s, startAt)
+ if startAt == -1 {
+ // we didn't find our start index in the string -- that's a problem
+ return nil, errors.New("startAt must align to the start of a valid rune in the input string")
+ }
+
+ return re.run(false, startAt, r)
+}
+
+// FindRunesMatchStartingAt searches the input rune slice for a Regexp match starting at the startAt index
+func (re *Regexp) FindRunesMatchStartingAt(r []rune, startAt int) (*Match, error) {
+ return re.run(false, startAt, r)
+}
+
+// FindNextMatch returns the next match in the same input string as the match parameter.
+// Will return nil if there is no next match or if given a nil match.
+func (re *Regexp) FindNextMatch(m *Match) (*Match, error) {
+ if m == nil {
+ return nil, nil
+ }
+
+ // If previous match was empty, advance by one before matching to prevent
+ // infinite loop
+ startAt := m.textpos
+ if m.Length == 0 {
+ if m.textpos == len(m.text) {
+ return nil, nil
+ }
+
+ if re.RightToLeft() {
+ startAt--
+ } else {
+ startAt++
+ }
+ }
+ return re.run(false, startAt, m.text)
+}
+
+// MatchString return true if the string matches the regex
+// error will be set if a timeout occurs
+func (re *Regexp) MatchString(s string) (bool, error) {
+ m, err := re.run(true, -1, getRunes(s))
+ if err != nil {
+ return false, err
+ }
+ return m != nil, nil
+}
+
+func (re *Regexp) getRunesAndStart(s string, startAt int) ([]rune, int) {
+ if startAt < 0 {
+ if re.RightToLeft() {
+ r := getRunes(s)
+ return r, len(r)
+ }
+ return getRunes(s), 0
+ }
+ ret := make([]rune, len(s))
+ i := 0
+ runeIdx := -1
+ for strIdx, r := range s {
+ if strIdx == startAt {
+ runeIdx = i
+ }
+ ret[i] = r
+ i++
+ }
+ if startAt == len(s) {
+ runeIdx = i
+ }
+ return ret[:i], runeIdx
+}
+
+func getRunes(s string) []rune {
+ return []rune(s)
+}
+
+// MatchRunes return true if the runes matches the regex
+// error will be set if a timeout occurs
+func (re *Regexp) MatchRunes(r []rune) (bool, error) {
+ m, err := re.run(true, -1, r)
+ if err != nil {
+ return false, err
+ }
+ return m != nil, nil
+}
+
+// GetGroupNames Returns the set of strings used to name capturing groups in the expression.
+func (re *Regexp) GetGroupNames() []string {
+ var result []string
+
+ if re.capslist == nil {
+ result = make([]string, re.capsize)
+
+ for i := 0; i < len(result); i++ {
+ result[i] = strconv.Itoa(i)
+ }
+ } else {
+ result = make([]string, len(re.capslist))
+ copy(result, re.capslist)
+ }
+
+ return result
+}
+
+// GetGroupNumbers returns the integer group numbers corresponding to a group name.
+func (re *Regexp) GetGroupNumbers() []int {
+ var result []int
+
+ if re.caps == nil {
+ result = make([]int, re.capsize)
+
+ for i := 0; i < len(result); i++ {
+ result[i] = i
+ }
+ } else {
+ result = make([]int, len(re.caps))
+
+ for k, v := range re.caps {
+ result[v] = k
+ }
+ }
+
+ return result
+}
+
+// GroupNameFromNumber retrieves a group name that corresponds to a group number.
+// It will return "" for and unknown group number. Unnamed groups automatically
+// receive a name that is the decimal string equivalent of its number.
+func (re *Regexp) GroupNameFromNumber(i int) string {
+ if re.capslist == nil {
+ if i >= 0 && i < re.capsize {
+ return strconv.Itoa(i)
+ }
+
+ return ""
+ }
+
+ if re.caps != nil {
+ var ok bool
+ if i, ok = re.caps[i]; !ok {
+ return ""
+ }
+ }
+
+ if i >= 0 && i < len(re.capslist) {
+ return re.capslist[i]
+ }
+
+ return ""
+}
+
+// GroupNumberFromName returns a group number that corresponds to a group name.
+// Returns -1 if the name is not a recognized group name. Numbered groups
+// automatically get a group name that is the decimal string equivalent of its number.
+func (re *Regexp) GroupNumberFromName(name string) int {
+ // look up name if we have a hashtable of names
+ if re.capnames != nil {
+ if k, ok := re.capnames[name]; ok {
+ return k
+ }
+
+ return -1
+ }
+
+ // convert to an int if it looks like a number
+ result := 0
+ for i := 0; i < len(name); i++ {
+ ch := name[i]
+
+ if ch > '9' || ch < '0' {
+ return -1
+ }
+
+ result *= 10
+ result += int(ch - '0')
+ }
+
+ // return int if it's in range
+ if result >= 0 && result < re.capsize {
+ return result
+ }
+
+ return -1
+}
diff --git a/vendor/github.com/dlclark/regexp2/replace.go b/vendor/github.com/dlclark/regexp2/replace.go
new file mode 100644
index 0000000..0376bd9
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/replace.go
@@ -0,0 +1,177 @@
+package regexp2
+
+import (
+ "bytes"
+ "errors"
+
+ "github.com/dlclark/regexp2/syntax"
+)
+
+const (
+ replaceSpecials = 4
+ replaceLeftPortion = -1
+ replaceRightPortion = -2
+ replaceLastGroup = -3
+ replaceWholeString = -4
+)
+
+// MatchEvaluator is a function that takes a match and returns a replacement string to be used
+type MatchEvaluator func(Match) string
+
+// Three very similar algorithms appear below: replace (pattern),
+// replace (evaluator), and split.
+
+// Replace Replaces all occurrences of the regex in the string with the
+// replacement pattern.
+//
+// Note that the special case of no matches is handled on its own:
+// with no matches, the input string is returned unchanged.
+// The right-to-left case is split out because StringBuilder
+// doesn't handle right-to-left string building directly very well.
+func replace(regex *Regexp, data *syntax.ReplacerData, evaluator MatchEvaluator, input string, startAt, count int) (string, error) {
+ if count < -1 {
+ return "", errors.New("Count too small")
+ }
+ if count == 0 {
+ return "", nil
+ }
+
+ m, err := regex.FindStringMatchStartingAt(input, startAt)
+
+ if err != nil {
+ return "", err
+ }
+ if m == nil {
+ return input, nil
+ }
+
+ buf := &bytes.Buffer{}
+ text := m.text
+
+ if !regex.RightToLeft() {
+ prevat := 0
+ for m != nil {
+ if m.Index != prevat {
+ buf.WriteString(string(text[prevat:m.Index]))
+ }
+ prevat = m.Index + m.Length
+ if evaluator == nil {
+ replacementImpl(data, buf, m)
+ } else {
+ buf.WriteString(evaluator(*m))
+ }
+
+ count--
+ if count == 0 {
+ break
+ }
+ m, err = regex.FindNextMatch(m)
+ if err != nil {
+ return "", nil
+ }
+ }
+
+ if prevat < len(text) {
+ buf.WriteString(string(text[prevat:]))
+ }
+ } else {
+ prevat := len(text)
+ var al []string
+
+ for m != nil {
+ if m.Index+m.Length != prevat {
+ al = append(al, string(text[m.Index+m.Length:prevat]))
+ }
+ prevat = m.Index
+ if evaluator == nil {
+ replacementImplRTL(data, &al, m)
+ } else {
+ al = append(al, evaluator(*m))
+ }
+
+ count--
+ if count == 0 {
+ break
+ }
+ m, err = regex.FindNextMatch(m)
+ if err != nil {
+ return "", nil
+ }
+ }
+
+ if prevat > 0 {
+ buf.WriteString(string(text[:prevat]))
+ }
+
+ for i := len(al) - 1; i >= 0; i-- {
+ buf.WriteString(al[i])
+ }
+ }
+
+ return buf.String(), nil
+}
+
+// Given a Match, emits into the StringBuilder the evaluated
+// substitution pattern.
+func replacementImpl(data *syntax.ReplacerData, buf *bytes.Buffer, m *Match) {
+ for _, r := range data.Rules {
+
+ if r >= 0 { // string lookup
+ buf.WriteString(data.Strings[r])
+ } else if r < -replaceSpecials { // group lookup
+ m.groupValueAppendToBuf(-replaceSpecials-1-r, buf)
+ } else {
+ switch -replaceSpecials - 1 - r { // special insertion patterns
+ case replaceLeftPortion:
+ for i := 0; i < m.Index; i++ {
+ buf.WriteRune(m.text[i])
+ }
+ case replaceRightPortion:
+ for i := m.Index + m.Length; i < len(m.text); i++ {
+ buf.WriteRune(m.text[i])
+ }
+ case replaceLastGroup:
+ m.groupValueAppendToBuf(m.GroupCount()-1, buf)
+ case replaceWholeString:
+ for i := 0; i < len(m.text); i++ {
+ buf.WriteRune(m.text[i])
+ }
+ }
+ }
+ }
+}
+
+func replacementImplRTL(data *syntax.ReplacerData, al *[]string, m *Match) {
+ l := *al
+ buf := &bytes.Buffer{}
+
+ for _, r := range data.Rules {
+ buf.Reset()
+ if r >= 0 { // string lookup
+ l = append(l, data.Strings[r])
+ } else if r < -replaceSpecials { // group lookup
+ m.groupValueAppendToBuf(-replaceSpecials-1-r, buf)
+ l = append(l, buf.String())
+ } else {
+ switch -replaceSpecials - 1 - r { // special insertion patterns
+ case replaceLeftPortion:
+ for i := 0; i < m.Index; i++ {
+ buf.WriteRune(m.text[i])
+ }
+ case replaceRightPortion:
+ for i := m.Index + m.Length; i < len(m.text); i++ {
+ buf.WriteRune(m.text[i])
+ }
+ case replaceLastGroup:
+ m.groupValueAppendToBuf(m.GroupCount()-1, buf)
+ case replaceWholeString:
+ for i := 0; i < len(m.text); i++ {
+ buf.WriteRune(m.text[i])
+ }
+ }
+ l = append(l, buf.String())
+ }
+ }
+
+ *al = l
+}
diff --git a/vendor/github.com/dlclark/regexp2/runner.go b/vendor/github.com/dlclark/regexp2/runner.go
new file mode 100644
index 0000000..4d7f9b0
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/runner.go
@@ -0,0 +1,1634 @@
+package regexp2
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "math"
+ "strconv"
+ "strings"
+ "time"
+ "unicode"
+
+ "github.com/dlclark/regexp2/syntax"
+)
+
+type runner struct {
+ re *Regexp
+ code *syntax.Code
+
+ runtextstart int // starting point for search
+
+ runtext []rune // text to search
+ runtextpos int // current position in text
+ runtextend int
+
+ // The backtracking stack. Opcodes use this to store data regarding
+ // what they have matched and where to backtrack to. Each "frame" on
+ // the stack takes the form of [CodePosition Data1 Data2...], where
+ // CodePosition is the position of the current opcode and
+ // the data values are all optional. The CodePosition can be negative, and
+ // these values (also called "back2") are used by the BranchMark family of opcodes
+ // to indicate whether they are backtracking after a successful or failed
+ // match.
+ // When we backtrack, we pop the CodePosition off the stack, set the current
+ // instruction pointer to that code position, and mark the opcode
+ // with a backtracking flag ("Back"). Each opcode then knows how to
+ // handle its own data.
+ runtrack []int
+ runtrackpos int
+
+ // This stack is used to track text positions across different opcodes.
+ // For example, in /(a*b)+/, the parentheses result in a SetMark/CaptureMark
+ // pair. SetMark records the text position before we match a*b. Then
+ // CaptureMark uses that position to figure out where the capture starts.
+ // Opcodes which push onto this stack are always paired with other opcodes
+ // which will pop the value from it later. A successful match should mean
+ // that this stack is empty.
+ runstack []int
+ runstackpos int
+
+ // The crawl stack is used to keep track of captures. Every time a group
+ // has a capture, we push its group number onto the runcrawl stack. In
+ // the case of a balanced match, we push BOTH groups onto the stack.
+ runcrawl []int
+ runcrawlpos int
+
+ runtrackcount int // count of states that may do backtracking
+
+ runmatch *Match // result object
+
+ ignoreTimeout bool
+ timeout time.Duration // timeout in milliseconds (needed for actual)
+ timeoutChecksToSkip int
+ timeoutAt time.Time
+
+ operator syntax.InstOp
+ codepos int
+ rightToLeft bool
+ caseInsensitive bool
+}
+
+// run searches for matches and can continue from the previous match
+//
+// quick is usually false, but can be true to not return matches, just put it in caches
+// textstart is -1 to start at the "beginning" (depending on Right-To-Left), otherwise an index in input
+// input is the string to search for our regex pattern
+func (re *Regexp) run(quick bool, textstart int, input []rune) (*Match, error) {
+
+ // get a cached runner
+ runner := re.getRunner()
+ defer re.putRunner(runner)
+
+ if textstart < 0 {
+ if re.RightToLeft() {
+ textstart = len(input)
+ } else {
+ textstart = 0
+ }
+ }
+
+ return runner.scan(input, textstart, quick, re.MatchTimeout)
+}
+
+// Scans the string to find the first match. Uses the Match object
+// both to feed text in and as a place to store matches that come out.
+//
+// All the action is in the Go() method. Our
+// responsibility is to load up the class members before
+// calling Go.
+//
+// The optimizer can compute a set of candidate starting characters,
+// and we could use a separate method Skip() that will quickly scan past
+// any characters that we know can't match.
+func (r *runner) scan(rt []rune, textstart int, quick bool, timeout time.Duration) (*Match, error) {
+ r.timeout = timeout
+ r.ignoreTimeout = (time.Duration(math.MaxInt64) == timeout)
+ r.runtextstart = textstart
+ r.runtext = rt
+ r.runtextend = len(rt)
+
+ stoppos := r.runtextend
+ bump := 1
+
+ if r.re.RightToLeft() {
+ bump = -1
+ stoppos = 0
+ }
+
+ r.runtextpos = textstart
+ initted := false
+
+ r.startTimeoutWatch()
+ for {
+ if r.re.Debug() {
+ //fmt.Printf("\nSearch content: %v\n", string(r.runtext))
+ fmt.Printf("\nSearch range: from 0 to %v\n", r.runtextend)
+ fmt.Printf("Firstchar search starting at %v stopping at %v\n", r.runtextpos, stoppos)
+ }
+
+ if r.findFirstChar() {
+ if err := r.checkTimeout(); err != nil {
+ return nil, err
+ }
+
+ if !initted {
+ r.initMatch()
+ initted = true
+ }
+
+ if r.re.Debug() {
+ fmt.Printf("Executing engine starting at %v\n\n", r.runtextpos)
+ }
+
+ if err := r.execute(); err != nil {
+ return nil, err
+ }
+
+ if r.runmatch.matchcount[0] > 0 {
+ // We'll return a match even if it touches a previous empty match
+ return r.tidyMatch(quick), nil
+ }
+
+ // reset state for another go
+ r.runtrackpos = len(r.runtrack)
+ r.runstackpos = len(r.runstack)
+ r.runcrawlpos = len(r.runcrawl)
+ }
+
+ // failure!
+
+ if r.runtextpos == stoppos {
+ r.tidyMatch(true)
+ return nil, nil
+ }
+
+ // Recognize leading []* and various anchors, and bump on failure accordingly
+
+ // r.bump by one and start again
+
+ r.runtextpos += bump
+ }
+ // We never get here
+}
+
+func (r *runner) execute() error {
+
+ r.goTo(0)
+
+ for {
+
+ if r.re.Debug() {
+ r.dumpState()
+ }
+
+ if err := r.checkTimeout(); err != nil {
+ return err
+ }
+
+ switch r.operator {
+ case syntax.Stop:
+ return nil
+
+ case syntax.Nothing:
+ break
+
+ case syntax.Goto:
+ r.goTo(r.operand(0))
+ continue
+
+ case syntax.Testref:
+ if !r.runmatch.isMatched(r.operand(0)) {
+ break
+ }
+ r.advance(1)
+ continue
+
+ case syntax.Lazybranch:
+ r.trackPush1(r.textPos())
+ r.advance(1)
+ continue
+
+ case syntax.Lazybranch | syntax.Back:
+ r.trackPop()
+ r.textto(r.trackPeek())
+ r.goTo(r.operand(0))
+ continue
+
+ case syntax.Setmark:
+ r.stackPush(r.textPos())
+ r.trackPush()
+ r.advance(0)
+ continue
+
+ case syntax.Nullmark:
+ r.stackPush(-1)
+ r.trackPush()
+ r.advance(0)
+ continue
+
+ case syntax.Setmark | syntax.Back, syntax.Nullmark | syntax.Back:
+ r.stackPop()
+ break
+
+ case syntax.Getmark:
+ r.stackPop()
+ r.trackPush1(r.stackPeek())
+ r.textto(r.stackPeek())
+ r.advance(0)
+ continue
+
+ case syntax.Getmark | syntax.Back:
+ r.trackPop()
+ r.stackPush(r.trackPeek())
+ break
+
+ case syntax.Capturemark:
+ if r.operand(1) != -1 && !r.runmatch.isMatched(r.operand(1)) {
+ break
+ }
+ r.stackPop()
+ if r.operand(1) != -1 {
+ r.transferCapture(r.operand(0), r.operand(1), r.stackPeek(), r.textPos())
+ } else {
+ r.capture(r.operand(0), r.stackPeek(), r.textPos())
+ }
+ r.trackPush1(r.stackPeek())
+
+ r.advance(2)
+
+ continue
+
+ case syntax.Capturemark | syntax.Back:
+ r.trackPop()
+ r.stackPush(r.trackPeek())
+ r.uncapture()
+ if r.operand(0) != -1 && r.operand(1) != -1 {
+ r.uncapture()
+ }
+
+ break
+
+ case syntax.Branchmark:
+ r.stackPop()
+
+ matched := r.textPos() - r.stackPeek()
+
+ if matched != 0 { // Nonempty match -> loop now
+ r.trackPush2(r.stackPeek(), r.textPos()) // Save old mark, textpos
+ r.stackPush(r.textPos()) // Make new mark
+ r.goTo(r.operand(0)) // Loop
+ } else { // Empty match -> straight now
+ r.trackPushNeg1(r.stackPeek()) // Save old mark
+ r.advance(1) // Straight
+ }
+ continue
+
+ case syntax.Branchmark | syntax.Back:
+ r.trackPopN(2)
+ r.stackPop()
+ r.textto(r.trackPeekN(1)) // Recall position
+ r.trackPushNeg1(r.trackPeek()) // Save old mark
+ r.advance(1) // Straight
+ continue
+
+ case syntax.Branchmark | syntax.Back2:
+ r.trackPop()
+ r.stackPush(r.trackPeek()) // Recall old mark
+ break // Backtrack
+
+ case syntax.Lazybranchmark:
+ {
+ // We hit this the first time through a lazy loop and after each
+ // successful match of the inner expression. It simply continues
+ // on and doesn't loop.
+ r.stackPop()
+
+ oldMarkPos := r.stackPeek()
+
+ if r.textPos() != oldMarkPos { // Nonempty match -> try to loop again by going to 'back' state
+ if oldMarkPos != -1 {
+ r.trackPush2(oldMarkPos, r.textPos()) // Save old mark, textpos
+ } else {
+ r.trackPush2(r.textPos(), r.textPos())
+ }
+ } else {
+ // The inner expression found an empty match, so we'll go directly to 'back2' if we
+ // backtrack. In this case, we need to push something on the stack, since back2 pops.
+ // However, in the case of ()+? or similar, this empty match may be legitimate, so push the text
+ // position associated with that empty match.
+ r.stackPush(oldMarkPos)
+
+ r.trackPushNeg1(r.stackPeek()) // Save old mark
+ }
+ r.advance(1)
+ continue
+ }
+
+ case syntax.Lazybranchmark | syntax.Back:
+
+ // After the first time, Lazybranchmark | syntax.Back occurs
+ // with each iteration of the loop, and therefore with every attempted
+ // match of the inner expression. We'll try to match the inner expression,
+ // then go back to Lazybranchmark if successful. If the inner expression
+ // fails, we go to Lazybranchmark | syntax.Back2
+
+ r.trackPopN(2)
+ pos := r.trackPeekN(1)
+ r.trackPushNeg1(r.trackPeek()) // Save old mark
+ r.stackPush(pos) // Make new mark
+ r.textto(pos) // Recall position
+ r.goTo(r.operand(0)) // Loop
+ continue
+
+ case syntax.Lazybranchmark | syntax.Back2:
+ // The lazy loop has failed. We'll do a true backtrack and
+ // start over before the lazy loop.
+ r.stackPop()
+ r.trackPop()
+ r.stackPush(r.trackPeek()) // Recall old mark
+ break
+
+ case syntax.Setcount:
+ r.stackPush2(r.textPos(), r.operand(0))
+ r.trackPush()
+ r.advance(1)
+ continue
+
+ case syntax.Nullcount:
+ r.stackPush2(-1, r.operand(0))
+ r.trackPush()
+ r.advance(1)
+ continue
+
+ case syntax.Setcount | syntax.Back:
+ r.stackPopN(2)
+ break
+
+ case syntax.Nullcount | syntax.Back:
+ r.stackPopN(2)
+ break
+
+ case syntax.Branchcount:
+ // r.stackPush:
+ // 0: Mark
+ // 1: Count
+
+ r.stackPopN(2)
+ mark := r.stackPeek()
+ count := r.stackPeekN(1)
+ matched := r.textPos() - mark
+
+ if count >= r.operand(1) || (matched == 0 && count >= 0) { // Max loops or empty match -> straight now
+ r.trackPushNeg2(mark, count) // Save old mark, count
+ r.advance(2) // Straight
+ } else { // Nonempty match -> count+loop now
+ r.trackPush1(mark) // remember mark
+ r.stackPush2(r.textPos(), count+1) // Make new mark, incr count
+ r.goTo(r.operand(0)) // Loop
+ }
+ continue
+
+ case syntax.Branchcount | syntax.Back:
+ // r.trackPush:
+ // 0: Previous mark
+ // r.stackPush:
+ // 0: Mark (= current pos, discarded)
+ // 1: Count
+ r.trackPop()
+ r.stackPopN(2)
+ if r.stackPeekN(1) > 0 { // Positive -> can go straight
+ r.textto(r.stackPeek()) // Zap to mark
+ r.trackPushNeg2(r.trackPeek(), r.stackPeekN(1)-1) // Save old mark, old count
+ r.advance(2) // Straight
+ continue
+ }
+ r.stackPush2(r.trackPeek(), r.stackPeekN(1)-1) // recall old mark, old count
+ break
+
+ case syntax.Branchcount | syntax.Back2:
+ // r.trackPush:
+ // 0: Previous mark
+ // 1: Previous count
+ r.trackPopN(2)
+ r.stackPush2(r.trackPeek(), r.trackPeekN(1)) // Recall old mark, old count
+ break // Backtrack
+
+ case syntax.Lazybranchcount:
+ // r.stackPush:
+ // 0: Mark
+ // 1: Count
+
+ r.stackPopN(2)
+ mark := r.stackPeek()
+ count := r.stackPeekN(1)
+
+ if count < 0 { // Negative count -> loop now
+ r.trackPushNeg1(mark) // Save old mark
+ r.stackPush2(r.textPos(), count+1) // Make new mark, incr count
+ r.goTo(r.operand(0)) // Loop
+ } else { // Nonneg count -> straight now
+ r.trackPush3(mark, count, r.textPos()) // Save mark, count, position
+ r.advance(2) // Straight
+ }
+ continue
+
+ case syntax.Lazybranchcount | syntax.Back:
+ // r.trackPush:
+ // 0: Mark
+ // 1: Count
+ // 2: r.textPos
+
+ r.trackPopN(3)
+ mark := r.trackPeek()
+ textpos := r.trackPeekN(2)
+
+ if r.trackPeekN(1) < r.operand(1) && textpos != mark { // Under limit and not empty match -> loop
+ r.textto(textpos) // Recall position
+ r.stackPush2(textpos, r.trackPeekN(1)+1) // Make new mark, incr count
+ r.trackPushNeg1(mark) // Save old mark
+ r.goTo(r.operand(0)) // Loop
+ continue
+ } else { // Max loops or empty match -> backtrack
+ r.stackPush2(r.trackPeek(), r.trackPeekN(1)) // Recall old mark, count
+ break // backtrack
+ }
+
+ case syntax.Lazybranchcount | syntax.Back2:
+ // r.trackPush:
+ // 0: Previous mark
+ // r.stackPush:
+ // 0: Mark (== current pos, discarded)
+ // 1: Count
+ r.trackPop()
+ r.stackPopN(2)
+ r.stackPush2(r.trackPeek(), r.stackPeekN(1)-1) // Recall old mark, count
+ break // Backtrack
+
+ case syntax.Setjump:
+ r.stackPush2(r.trackpos(), r.crawlpos())
+ r.trackPush()
+ r.advance(0)
+ continue
+
+ case syntax.Setjump | syntax.Back:
+ r.stackPopN(2)
+ break
+
+ case syntax.Backjump:
+ // r.stackPush:
+ // 0: Saved trackpos
+ // 1: r.crawlpos
+ r.stackPopN(2)
+ r.trackto(r.stackPeek())
+
+ for r.crawlpos() != r.stackPeekN(1) {
+ r.uncapture()
+ }
+
+ break
+
+ case syntax.Forejump:
+ // r.stackPush:
+ // 0: Saved trackpos
+ // 1: r.crawlpos
+ r.stackPopN(2)
+ r.trackto(r.stackPeek())
+ r.trackPush1(r.stackPeekN(1))
+ r.advance(0)
+ continue
+
+ case syntax.Forejump | syntax.Back:
+ // r.trackPush:
+ // 0: r.crawlpos
+ r.trackPop()
+
+ for r.crawlpos() != r.trackPeek() {
+ r.uncapture()
+ }
+
+ break
+
+ case syntax.Bol:
+ if r.leftchars() > 0 && r.charAt(r.textPos()-1) != '\n' {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.Eol:
+ if r.rightchars() > 0 && r.charAt(r.textPos()) != '\n' {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.Boundary:
+ if !r.isBoundary(r.textPos(), 0, r.runtextend) {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.Nonboundary:
+ if r.isBoundary(r.textPos(), 0, r.runtextend) {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.ECMABoundary:
+ if !r.isECMABoundary(r.textPos(), 0, r.runtextend) {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.NonECMABoundary:
+ if r.isECMABoundary(r.textPos(), 0, r.runtextend) {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.Beginning:
+ if r.leftchars() > 0 {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.Start:
+ if r.textPos() != r.textstart() {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.EndZ:
+ rchars := r.rightchars()
+ if rchars > 1 {
+ break
+ }
+ // RE2 and EcmaScript define $ as "asserts position at the end of the string"
+ // PCRE/.NET adds "or before the line terminator right at the end of the string (if any)"
+ if (r.re.options & (RE2 | ECMAScript)) != 0 {
+ // RE2/Ecmascript mode
+ if rchars > 0 {
+ break
+ }
+ } else if rchars == 1 && r.charAt(r.textPos()) != '\n' {
+ // "regular" mode
+ break
+ }
+
+ r.advance(0)
+ continue
+
+ case syntax.End:
+ if r.rightchars() > 0 {
+ break
+ }
+ r.advance(0)
+ continue
+
+ case syntax.One:
+ if r.forwardchars() < 1 || r.forwardcharnext() != rune(r.operand(0)) {
+ break
+ }
+
+ r.advance(1)
+ continue
+
+ case syntax.Notone:
+ if r.forwardchars() < 1 || r.forwardcharnext() == rune(r.operand(0)) {
+ break
+ }
+
+ r.advance(1)
+ continue
+
+ case syntax.Set:
+
+ if r.forwardchars() < 1 || !r.code.Sets[r.operand(0)].CharIn(r.forwardcharnext()) {
+ break
+ }
+
+ r.advance(1)
+ continue
+
+ case syntax.Multi:
+ if !r.runematch(r.code.Strings[r.operand(0)]) {
+ break
+ }
+
+ r.advance(1)
+ continue
+
+ case syntax.Ref:
+
+ capnum := r.operand(0)
+
+ if r.runmatch.isMatched(capnum) {
+ if !r.refmatch(r.runmatch.matchIndex(capnum), r.runmatch.matchLength(capnum)) {
+ break
+ }
+ } else {
+ if (r.re.options & ECMAScript) == 0 {
+ break
+ }
+ }
+
+ r.advance(1)
+ continue
+
+ case syntax.Onerep:
+
+ c := r.operand(1)
+
+ if r.forwardchars() < c {
+ break
+ }
+
+ ch := rune(r.operand(0))
+
+ for c > 0 {
+ if r.forwardcharnext() != ch {
+ goto BreakBackward
+ }
+ c--
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Notonerep:
+
+ c := r.operand(1)
+
+ if r.forwardchars() < c {
+ break
+ }
+ ch := rune(r.operand(0))
+
+ for c > 0 {
+ if r.forwardcharnext() == ch {
+ goto BreakBackward
+ }
+ c--
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Setrep:
+
+ c := r.operand(1)
+
+ if r.forwardchars() < c {
+ break
+ }
+
+ set := r.code.Sets[r.operand(0)]
+
+ for c > 0 {
+ if !set.CharIn(r.forwardcharnext()) {
+ goto BreakBackward
+ }
+ c--
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Oneloop:
+
+ c := r.operand(1)
+
+ if c > r.forwardchars() {
+ c = r.forwardchars()
+ }
+
+ ch := rune(r.operand(0))
+ i := c
+
+ for ; i > 0; i-- {
+ if r.forwardcharnext() != ch {
+ r.backwardnext()
+ break
+ }
+ }
+
+ if c > i {
+ r.trackPush2(c-i-1, r.textPos()-r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Notoneloop:
+
+ c := r.operand(1)
+
+ if c > r.forwardchars() {
+ c = r.forwardchars()
+ }
+
+ ch := rune(r.operand(0))
+ i := c
+
+ for ; i > 0; i-- {
+ if r.forwardcharnext() == ch {
+ r.backwardnext()
+ break
+ }
+ }
+
+ if c > i {
+ r.trackPush2(c-i-1, r.textPos()-r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Setloop:
+
+ c := r.operand(1)
+
+ if c > r.forwardchars() {
+ c = r.forwardchars()
+ }
+
+ set := r.code.Sets[r.operand(0)]
+ i := c
+
+ for ; i > 0; i-- {
+ if !set.CharIn(r.forwardcharnext()) {
+ r.backwardnext()
+ break
+ }
+ }
+
+ if c > i {
+ r.trackPush2(c-i-1, r.textPos()-r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Oneloop | syntax.Back, syntax.Notoneloop | syntax.Back:
+
+ r.trackPopN(2)
+ i := r.trackPeek()
+ pos := r.trackPeekN(1)
+
+ r.textto(pos)
+
+ if i > 0 {
+ r.trackPush2(i-1, pos-r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Setloop | syntax.Back:
+
+ r.trackPopN(2)
+ i := r.trackPeek()
+ pos := r.trackPeekN(1)
+
+ r.textto(pos)
+
+ if i > 0 {
+ r.trackPush2(i-1, pos-r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Onelazy, syntax.Notonelazy:
+
+ c := r.operand(1)
+
+ if c > r.forwardchars() {
+ c = r.forwardchars()
+ }
+
+ if c > 0 {
+ r.trackPush2(c-1, r.textPos())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Setlazy:
+
+ c := r.operand(1)
+
+ if c > r.forwardchars() {
+ c = r.forwardchars()
+ }
+
+ if c > 0 {
+ r.trackPush2(c-1, r.textPos())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Onelazy | syntax.Back:
+
+ r.trackPopN(2)
+ pos := r.trackPeekN(1)
+ r.textto(pos)
+
+ if r.forwardcharnext() != rune(r.operand(0)) {
+ break
+ }
+
+ i := r.trackPeek()
+
+ if i > 0 {
+ r.trackPush2(i-1, pos+r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Notonelazy | syntax.Back:
+
+ r.trackPopN(2)
+ pos := r.trackPeekN(1)
+ r.textto(pos)
+
+ if r.forwardcharnext() == rune(r.operand(0)) {
+ break
+ }
+
+ i := r.trackPeek()
+
+ if i > 0 {
+ r.trackPush2(i-1, pos+r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ case syntax.Setlazy | syntax.Back:
+
+ r.trackPopN(2)
+ pos := r.trackPeekN(1)
+ r.textto(pos)
+
+ if !r.code.Sets[r.operand(0)].CharIn(r.forwardcharnext()) {
+ break
+ }
+
+ i := r.trackPeek()
+
+ if i > 0 {
+ r.trackPush2(i-1, pos+r.bump())
+ }
+
+ r.advance(2)
+ continue
+
+ default:
+ return errors.New("unknown state in regex runner")
+ }
+
+ BreakBackward:
+ ;
+
+ // "break Backward" comes here:
+ r.backtrack()
+ }
+}
+
+// increase the size of stack and track storage
+func (r *runner) ensureStorage() {
+ if r.runstackpos < r.runtrackcount*4 {
+ doubleIntSlice(&r.runstack, &r.runstackpos)
+ }
+ if r.runtrackpos < r.runtrackcount*4 {
+ doubleIntSlice(&r.runtrack, &r.runtrackpos)
+ }
+}
+
+func doubleIntSlice(s *[]int, pos *int) {
+ oldLen := len(*s)
+ newS := make([]int, oldLen*2)
+
+ copy(newS[oldLen:], *s)
+ *pos += oldLen
+ *s = newS
+}
+
+// Save a number on the longjump unrolling stack
+func (r *runner) crawl(i int) {
+ if r.runcrawlpos == 0 {
+ doubleIntSlice(&r.runcrawl, &r.runcrawlpos)
+ }
+ r.runcrawlpos--
+ r.runcrawl[r.runcrawlpos] = i
+}
+
+// Remove a number from the longjump unrolling stack
+func (r *runner) popcrawl() int {
+ val := r.runcrawl[r.runcrawlpos]
+ r.runcrawlpos++
+ return val
+}
+
+// Get the height of the stack
+func (r *runner) crawlpos() int {
+ return len(r.runcrawl) - r.runcrawlpos
+}
+
+func (r *runner) advance(i int) {
+ r.codepos += (i + 1)
+ r.setOperator(r.code.Codes[r.codepos])
+}
+
+func (r *runner) goTo(newpos int) {
+ // when branching backward or in place, ensure storage
+ if newpos <= r.codepos {
+ r.ensureStorage()
+ }
+
+ r.setOperator(r.code.Codes[newpos])
+ r.codepos = newpos
+}
+
+func (r *runner) textto(newpos int) {
+ r.runtextpos = newpos
+}
+
+func (r *runner) trackto(newpos int) {
+ r.runtrackpos = len(r.runtrack) - newpos
+}
+
+func (r *runner) textstart() int {
+ return r.runtextstart
+}
+
+func (r *runner) textPos() int {
+ return r.runtextpos
+}
+
+// push onto the backtracking stack
+func (r *runner) trackpos() int {
+ return len(r.runtrack) - r.runtrackpos
+}
+
+func (r *runner) trackPush() {
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = r.codepos
+}
+
+func (r *runner) trackPush1(I1 int) {
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I1
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = r.codepos
+}
+
+func (r *runner) trackPush2(I1, I2 int) {
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I1
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I2
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = r.codepos
+}
+
+func (r *runner) trackPush3(I1, I2, I3 int) {
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I1
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I2
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I3
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = r.codepos
+}
+
+func (r *runner) trackPushNeg1(I1 int) {
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I1
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = -r.codepos
+}
+
+func (r *runner) trackPushNeg2(I1, I2 int) {
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I1
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = I2
+ r.runtrackpos--
+ r.runtrack[r.runtrackpos] = -r.codepos
+}
+
+func (r *runner) backtrack() {
+ newpos := r.runtrack[r.runtrackpos]
+ r.runtrackpos++
+
+ if r.re.Debug() {
+ if newpos < 0 {
+ fmt.Printf(" Backtracking (back2) to code position %v\n", -newpos)
+ } else {
+ fmt.Printf(" Backtracking to code position %v\n", newpos)
+ }
+ }
+
+ if newpos < 0 {
+ newpos = -newpos
+ r.setOperator(r.code.Codes[newpos] | syntax.Back2)
+ } else {
+ r.setOperator(r.code.Codes[newpos] | syntax.Back)
+ }
+
+ // When branching backward, ensure storage
+ if newpos < r.codepos {
+ r.ensureStorage()
+ }
+
+ r.codepos = newpos
+}
+
+func (r *runner) setOperator(op int) {
+ r.caseInsensitive = (0 != (op & syntax.Ci))
+ r.rightToLeft = (0 != (op & syntax.Rtl))
+ r.operator = syntax.InstOp(op & ^(syntax.Rtl | syntax.Ci))
+}
+
+func (r *runner) trackPop() {
+ r.runtrackpos++
+}
+
+// pop framesize items from the backtracking stack
+func (r *runner) trackPopN(framesize int) {
+ r.runtrackpos += framesize
+}
+
+// Technically we are actually peeking at items already popped. So if you want to
+// get and pop the top item from the stack, you do
+// r.trackPop();
+// r.trackPeek();
+func (r *runner) trackPeek() int {
+ return r.runtrack[r.runtrackpos-1]
+}
+
+// get the ith element down on the backtracking stack
+func (r *runner) trackPeekN(i int) int {
+ return r.runtrack[r.runtrackpos-i-1]
+}
+
+// Push onto the grouping stack
+func (r *runner) stackPush(I1 int) {
+ r.runstackpos--
+ r.runstack[r.runstackpos] = I1
+}
+
+func (r *runner) stackPush2(I1, I2 int) {
+ r.runstackpos--
+ r.runstack[r.runstackpos] = I1
+ r.runstackpos--
+ r.runstack[r.runstackpos] = I2
+}
+
+func (r *runner) stackPop() {
+ r.runstackpos++
+}
+
+// pop framesize items from the grouping stack
+func (r *runner) stackPopN(framesize int) {
+ r.runstackpos += framesize
+}
+
+// Technically we are actually peeking at items already popped. So if you want to
+// get and pop the top item from the stack, you do
+// r.stackPop();
+// r.stackPeek();
+func (r *runner) stackPeek() int {
+ return r.runstack[r.runstackpos-1]
+}
+
+// get the ith element down on the grouping stack
+func (r *runner) stackPeekN(i int) int {
+ return r.runstack[r.runstackpos-i-1]
+}
+
+func (r *runner) operand(i int) int {
+ return r.code.Codes[r.codepos+i+1]
+}
+
+func (r *runner) leftchars() int {
+ return r.runtextpos
+}
+
+func (r *runner) rightchars() int {
+ return r.runtextend - r.runtextpos
+}
+
+func (r *runner) bump() int {
+ if r.rightToLeft {
+ return -1
+ }
+ return 1
+}
+
+func (r *runner) forwardchars() int {
+ if r.rightToLeft {
+ return r.runtextpos
+ }
+ return r.runtextend - r.runtextpos
+}
+
+func (r *runner) forwardcharnext() rune {
+ var ch rune
+ if r.rightToLeft {
+ r.runtextpos--
+ ch = r.runtext[r.runtextpos]
+ } else {
+ ch = r.runtext[r.runtextpos]
+ r.runtextpos++
+ }
+
+ if r.caseInsensitive {
+ return unicode.ToLower(ch)
+ }
+ return ch
+}
+
+func (r *runner) runematch(str []rune) bool {
+ var pos int
+
+ c := len(str)
+ if !r.rightToLeft {
+ if r.runtextend-r.runtextpos < c {
+ return false
+ }
+
+ pos = r.runtextpos + c
+ } else {
+ if r.runtextpos-0 < c {
+ return false
+ }
+
+ pos = r.runtextpos
+ }
+
+ if !r.caseInsensitive {
+ for c != 0 {
+ c--
+ pos--
+ if str[c] != r.runtext[pos] {
+ return false
+ }
+ }
+ } else {
+ for c != 0 {
+ c--
+ pos--
+ if str[c] != unicode.ToLower(r.runtext[pos]) {
+ return false
+ }
+ }
+ }
+
+ if !r.rightToLeft {
+ pos += len(str)
+ }
+
+ r.runtextpos = pos
+
+ return true
+}
+
+func (r *runner) refmatch(index, len int) bool {
+ var c, pos, cmpos int
+
+ if !r.rightToLeft {
+ if r.runtextend-r.runtextpos < len {
+ return false
+ }
+
+ pos = r.runtextpos + len
+ } else {
+ if r.runtextpos-0 < len {
+ return false
+ }
+
+ pos = r.runtextpos
+ }
+ cmpos = index + len
+
+ c = len
+
+ if !r.caseInsensitive {
+ for c != 0 {
+ c--
+ cmpos--
+ pos--
+ if r.runtext[cmpos] != r.runtext[pos] {
+ return false
+ }
+
+ }
+ } else {
+ for c != 0 {
+ c--
+ cmpos--
+ pos--
+
+ if unicode.ToLower(r.runtext[cmpos]) != unicode.ToLower(r.runtext[pos]) {
+ return false
+ }
+ }
+ }
+
+ if !r.rightToLeft {
+ pos += len
+ }
+
+ r.runtextpos = pos
+
+ return true
+}
+
+func (r *runner) backwardnext() {
+ if r.rightToLeft {
+ r.runtextpos++
+ } else {
+ r.runtextpos--
+ }
+}
+
+func (r *runner) charAt(j int) rune {
+ return r.runtext[j]
+}
+
+func (r *runner) findFirstChar() bool {
+
+ if 0 != (r.code.Anchors & (syntax.AnchorBeginning | syntax.AnchorStart | syntax.AnchorEndZ | syntax.AnchorEnd)) {
+ if !r.code.RightToLeft {
+ if (0 != (r.code.Anchors&syntax.AnchorBeginning) && r.runtextpos > 0) ||
+ (0 != (r.code.Anchors&syntax.AnchorStart) && r.runtextpos > r.runtextstart) {
+ r.runtextpos = r.runtextend
+ return false
+ }
+ if 0 != (r.code.Anchors&syntax.AnchorEndZ) && r.runtextpos < r.runtextend-1 {
+ r.runtextpos = r.runtextend - 1
+ } else if 0 != (r.code.Anchors&syntax.AnchorEnd) && r.runtextpos < r.runtextend {
+ r.runtextpos = r.runtextend
+ }
+ } else {
+ if (0 != (r.code.Anchors&syntax.AnchorEnd) && r.runtextpos < r.runtextend) ||
+ (0 != (r.code.Anchors&syntax.AnchorEndZ) && (r.runtextpos < r.runtextend-1 ||
+ (r.runtextpos == r.runtextend-1 && r.charAt(r.runtextpos) != '\n'))) ||
+ (0 != (r.code.Anchors&syntax.AnchorStart) && r.runtextpos < r.runtextstart) {
+ r.runtextpos = 0
+ return false
+ }
+ if 0 != (r.code.Anchors&syntax.AnchorBeginning) && r.runtextpos > 0 {
+ r.runtextpos = 0
+ }
+ }
+
+ if r.code.BmPrefix != nil {
+ return r.code.BmPrefix.IsMatch(r.runtext, r.runtextpos, 0, r.runtextend)
+ }
+
+ return true // found a valid start or end anchor
+ } else if r.code.BmPrefix != nil {
+ r.runtextpos = r.code.BmPrefix.Scan(r.runtext, r.runtextpos, 0, r.runtextend)
+
+ if r.runtextpos == -1 {
+ if r.code.RightToLeft {
+ r.runtextpos = 0
+ } else {
+ r.runtextpos = r.runtextend
+ }
+ return false
+ }
+
+ return true
+ } else if r.code.FcPrefix == nil {
+ return true
+ }
+
+ r.rightToLeft = r.code.RightToLeft
+ r.caseInsensitive = r.code.FcPrefix.CaseInsensitive
+
+ set := r.code.FcPrefix.PrefixSet
+ if set.IsSingleton() {
+ ch := set.SingletonChar()
+ for i := r.forwardchars(); i > 0; i-- {
+ if ch == r.forwardcharnext() {
+ r.backwardnext()
+ return true
+ }
+ }
+ } else {
+ for i := r.forwardchars(); i > 0; i-- {
+ n := r.forwardcharnext()
+ //fmt.Printf("%v in %v: %v\n", string(n), set.String(), set.CharIn(n))
+ if set.CharIn(n) {
+ r.backwardnext()
+ return true
+ }
+ }
+ }
+
+ return false
+}
+
+func (r *runner) initMatch() {
+ // Use a hashtable'ed Match object if the capture numbers are sparse
+
+ if r.runmatch == nil {
+ if r.re.caps != nil {
+ r.runmatch = newMatchSparse(r.re, r.re.caps, r.re.capsize, r.runtext, r.runtextstart)
+ } else {
+ r.runmatch = newMatch(r.re, r.re.capsize, r.runtext, r.runtextstart)
+ }
+ } else {
+ r.runmatch.reset(r.runtext, r.runtextstart)
+ }
+
+ // note we test runcrawl, because it is the last one to be allocated
+ // If there is an alloc failure in the middle of the three allocations,
+ // we may still return to reuse this instance, and we want to behave
+ // as if the allocations didn't occur. (we used to test _trackcount != 0)
+
+ if r.runcrawl != nil {
+ r.runtrackpos = len(r.runtrack)
+ r.runstackpos = len(r.runstack)
+ r.runcrawlpos = len(r.runcrawl)
+ return
+ }
+
+ r.initTrackCount()
+
+ tracksize := r.runtrackcount * 8
+ stacksize := r.runtrackcount * 8
+
+ if tracksize < 32 {
+ tracksize = 32
+ }
+ if stacksize < 16 {
+ stacksize = 16
+ }
+
+ r.runtrack = make([]int, tracksize)
+ r.runtrackpos = tracksize
+
+ r.runstack = make([]int, stacksize)
+ r.runstackpos = stacksize
+
+ r.runcrawl = make([]int, 32)
+ r.runcrawlpos = 32
+}
+
+func (r *runner) tidyMatch(quick bool) *Match {
+ if !quick {
+ match := r.runmatch
+
+ r.runmatch = nil
+
+ match.tidy(r.runtextpos)
+ return match
+ } else {
+ // send back our match -- it's not leaving the package, so it's safe to not clean it up
+ // this reduces allocs for frequent calls to the "IsMatch" bool-only functions
+ return r.runmatch
+ }
+}
+
+// capture captures a subexpression. Note that the
+// capnum used here has already been mapped to a non-sparse
+// index (by the code generator RegexWriter).
+func (r *runner) capture(capnum, start, end int) {
+ if end < start {
+ T := end
+ end = start
+ start = T
+ }
+
+ r.crawl(capnum)
+ r.runmatch.addMatch(capnum, start, end-start)
+}
+
+// transferCapture captures a subexpression. Note that the
+// capnum used here has already been mapped to a non-sparse
+// index (by the code generator RegexWriter).
+func (r *runner) transferCapture(capnum, uncapnum, start, end int) {
+ var start2, end2 int
+
+ // these are the two intervals that are cancelling each other
+
+ if end < start {
+ T := end
+ end = start
+ start = T
+ }
+
+ start2 = r.runmatch.matchIndex(uncapnum)
+ end2 = start2 + r.runmatch.matchLength(uncapnum)
+
+ // The new capture gets the innermost defined interval
+
+ if start >= end2 {
+ end = start
+ start = end2
+ } else if end <= start2 {
+ start = start2
+ } else {
+ if end > end2 {
+ end = end2
+ }
+ if start2 > start {
+ start = start2
+ }
+ }
+
+ r.crawl(uncapnum)
+ r.runmatch.balanceMatch(uncapnum)
+
+ if capnum != -1 {
+ r.crawl(capnum)
+ r.runmatch.addMatch(capnum, start, end-start)
+ }
+}
+
+// revert the last capture
+func (r *runner) uncapture() {
+ capnum := r.popcrawl()
+ r.runmatch.removeMatch(capnum)
+}
+
+//debug
+
+func (r *runner) dumpState() {
+ back := ""
+ if r.operator&syntax.Back != 0 {
+ back = " Back"
+ }
+ if r.operator&syntax.Back2 != 0 {
+ back += " Back2"
+ }
+ fmt.Printf("Text: %v\nTrack: %v\nStack: %v\n %s%s\n\n",
+ r.textposDescription(),
+ r.stackDescription(r.runtrack, r.runtrackpos),
+ r.stackDescription(r.runstack, r.runstackpos),
+ r.code.OpcodeDescription(r.codepos),
+ back)
+}
+
+func (r *runner) stackDescription(a []int, index int) string {
+ buf := &bytes.Buffer{}
+
+ fmt.Fprintf(buf, "%v/%v", len(a)-index, len(a))
+ if buf.Len() < 8 {
+ buf.WriteString(strings.Repeat(" ", 8-buf.Len()))
+ }
+
+ buf.WriteRune('(')
+ for i := index; i < len(a); i++ {
+ if i > index {
+ buf.WriteRune(' ')
+ }
+
+ buf.WriteString(strconv.Itoa(a[i]))
+ }
+
+ buf.WriteRune(')')
+
+ return buf.String()
+}
+
+func (r *runner) textposDescription() string {
+ buf := &bytes.Buffer{}
+
+ buf.WriteString(strconv.Itoa(r.runtextpos))
+
+ if buf.Len() < 8 {
+ buf.WriteString(strings.Repeat(" ", 8-buf.Len()))
+ }
+
+ if r.runtextpos > 0 {
+ buf.WriteString(syntax.CharDescription(r.runtext[r.runtextpos-1]))
+ } else {
+ buf.WriteRune('^')
+ }
+
+ buf.WriteRune('>')
+
+ for i := r.runtextpos; i < r.runtextend; i++ {
+ buf.WriteString(syntax.CharDescription(r.runtext[i]))
+ }
+ if buf.Len() >= 64 {
+ buf.Truncate(61)
+ buf.WriteString("...")
+ } else {
+ buf.WriteRune('$')
+ }
+
+ return buf.String()
+}
+
+// decide whether the pos
+// at the specified index is a boundary or not. It's just not worth
+// emitting inline code for this logic.
+func (r *runner) isBoundary(index, startpos, endpos int) bool {
+ return (index > startpos && syntax.IsWordChar(r.runtext[index-1])) !=
+ (index < endpos && syntax.IsWordChar(r.runtext[index]))
+}
+
+func (r *runner) isECMABoundary(index, startpos, endpos int) bool {
+ return (index > startpos && syntax.IsECMAWordChar(r.runtext[index-1])) !=
+ (index < endpos && syntax.IsECMAWordChar(r.runtext[index]))
+}
+
+// this seems like a comment to justify randomly picking 1000 :-P
+// We have determined this value in a series of experiments where x86 retail
+// builds (ono-lab-optimized) were run on different pattern/input pairs. Larger values
+// of TimeoutCheckFrequency did not tend to increase performance; smaller values
+// of TimeoutCheckFrequency tended to slow down the execution.
+const timeoutCheckFrequency int = 1000
+
+func (r *runner) startTimeoutWatch() {
+ if r.ignoreTimeout {
+ return
+ }
+
+ r.timeoutChecksToSkip = timeoutCheckFrequency
+ r.timeoutAt = time.Now().Add(r.timeout)
+}
+
+func (r *runner) checkTimeout() error {
+ if r.ignoreTimeout {
+ return nil
+ }
+ r.timeoutChecksToSkip--
+ if r.timeoutChecksToSkip != 0 {
+ return nil
+ }
+
+ r.timeoutChecksToSkip = timeoutCheckFrequency
+ return r.doCheckTimeout()
+}
+
+func (r *runner) doCheckTimeout() error {
+ current := time.Now()
+
+ if current.Before(r.timeoutAt) {
+ return nil
+ }
+
+ if r.re.Debug() {
+ //Debug.WriteLine("")
+ //Debug.WriteLine("RegEx match timeout occurred!")
+ //Debug.WriteLine("Specified timeout: " + TimeSpan.FromMilliseconds(_timeout).ToString())
+ //Debug.WriteLine("Timeout check frequency: " + TimeoutCheckFrequency)
+ //Debug.WriteLine("Search pattern: " + _runregex._pattern)
+ //Debug.WriteLine("Input: " + r.runtext)
+ //Debug.WriteLine("About to throw RegexMatchTimeoutException.")
+ }
+
+ return fmt.Errorf("match timeout after %v on input `%v`", r.timeout, string(r.runtext))
+}
+
+func (r *runner) initTrackCount() {
+ r.runtrackcount = r.code.TrackCount
+}
+
+// getRunner returns a run to use for matching re.
+// It uses the re's runner cache if possible, to avoid
+// unnecessary allocation.
+func (re *Regexp) getRunner() *runner {
+ re.muRun.Lock()
+ if n := len(re.runner); n > 0 {
+ z := re.runner[n-1]
+ re.runner = re.runner[:n-1]
+ re.muRun.Unlock()
+ return z
+ }
+ re.muRun.Unlock()
+ z := &runner{
+ re: re,
+ code: re.code,
+ }
+ return z
+}
+
+// putRunner returns a runner to the re's cache.
+// There is no attempt to limit the size of the cache, so it will
+// grow to the maximum number of simultaneous matches
+// run using re. (The cache empties when re gets garbage collected.)
+func (re *Regexp) putRunner(r *runner) {
+ re.muRun.Lock()
+ re.runner = append(re.runner, r)
+ re.muRun.Unlock()
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/charclass.go b/vendor/github.com/dlclark/regexp2/syntax/charclass.go
new file mode 100644
index 0000000..53974d1
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/charclass.go
@@ -0,0 +1,854 @@
+package syntax
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "sort"
+ "unicode"
+ "unicode/utf8"
+)
+
+// CharSet combines start-end rune ranges and unicode categories representing a set of characters
+type CharSet struct {
+ ranges []singleRange
+ categories []category
+ sub *CharSet //optional subtractor
+ negate bool
+ anything bool
+}
+
+type category struct {
+ negate bool
+ cat string
+}
+
+type singleRange struct {
+ first rune
+ last rune
+}
+
+const (
+ spaceCategoryText = " "
+ wordCategoryText = "W"
+)
+
+var (
+ ecmaSpace = []rune{0x0009, 0x000e, 0x0020, 0x0021, 0x00a0, 0x00a1, 0x1680, 0x1681, 0x2000, 0x200b, 0x2028, 0x202a, 0x202f, 0x2030, 0x205f, 0x2060, 0x3000, 0x3001, 0xfeff, 0xff00}
+ ecmaWord = []rune{0x0030, 0x003a, 0x0041, 0x005b, 0x005f, 0x0060, 0x0061, 0x007b}
+ ecmaDigit = []rune{0x0030, 0x003a}
+)
+
+var (
+ AnyClass = getCharSetFromOldString([]rune{0}, false)
+ ECMAAnyClass = getCharSetFromOldString([]rune{0, 0x000a, 0x000b, 0x000d, 0x000e}, false)
+ NoneClass = getCharSetFromOldString(nil, false)
+ ECMAWordClass = getCharSetFromOldString(ecmaWord, false)
+ NotECMAWordClass = getCharSetFromOldString(ecmaWord, true)
+ ECMASpaceClass = getCharSetFromOldString(ecmaSpace, false)
+ NotECMASpaceClass = getCharSetFromOldString(ecmaSpace, true)
+ ECMADigitClass = getCharSetFromOldString(ecmaDigit, false)
+ NotECMADigitClass = getCharSetFromOldString(ecmaDigit, true)
+
+ WordClass = getCharSetFromCategoryString(false, false, wordCategoryText)
+ NotWordClass = getCharSetFromCategoryString(true, false, wordCategoryText)
+ SpaceClass = getCharSetFromCategoryString(false, false, spaceCategoryText)
+ NotSpaceClass = getCharSetFromCategoryString(true, false, spaceCategoryText)
+ DigitClass = getCharSetFromCategoryString(false, false, "Nd")
+ NotDigitClass = getCharSetFromCategoryString(false, true, "Nd")
+)
+
+var unicodeCategories = func() map[string]*unicode.RangeTable {
+ retVal := make(map[string]*unicode.RangeTable)
+ for k, v := range unicode.Scripts {
+ retVal[k] = v
+ }
+ for k, v := range unicode.Categories {
+ retVal[k] = v
+ }
+ for k, v := range unicode.Properties {
+ retVal[k] = v
+ }
+ return retVal
+}()
+
+func getCharSetFromCategoryString(negateSet bool, negateCat bool, cats ...string) func() *CharSet {
+ if negateCat && negateSet {
+ panic("BUG! You should only negate the set OR the category in a constant setup, but not both")
+ }
+
+ c := CharSet{negate: negateSet}
+
+ c.categories = make([]category, len(cats))
+ for i, cat := range cats {
+ c.categories[i] = category{cat: cat, negate: negateCat}
+ }
+ return func() *CharSet {
+ //make a copy each time
+ local := c
+ //return that address
+ return &local
+ }
+}
+
+func getCharSetFromOldString(setText []rune, negate bool) func() *CharSet {
+ c := CharSet{}
+ if len(setText) > 0 {
+ fillFirst := false
+ l := len(setText)
+ if negate {
+ if setText[0] == 0 {
+ setText = setText[1:]
+ } else {
+ l++
+ fillFirst = true
+ }
+ }
+
+ if l%2 == 0 {
+ c.ranges = make([]singleRange, l/2)
+ } else {
+ c.ranges = make([]singleRange, l/2+1)
+ }
+
+ first := true
+ if fillFirst {
+ c.ranges[0] = singleRange{first: 0}
+ first = false
+ }
+
+ i := 0
+ for _, r := range setText {
+ if first {
+ // lower bound in a new range
+ c.ranges[i] = singleRange{first: r}
+ first = false
+ } else {
+ c.ranges[i].last = r - 1
+ i++
+ first = true
+ }
+ }
+ if !first {
+ c.ranges[i].last = utf8.MaxRune
+ }
+ }
+
+ return func() *CharSet {
+ local := c
+ return &local
+ }
+}
+
+// Copy makes a deep copy to prevent accidental mutation of a set
+func (c CharSet) Copy() CharSet {
+ ret := CharSet{
+ anything: c.anything,
+ negate: c.negate,
+ }
+
+ ret.ranges = append(ret.ranges, c.ranges...)
+ ret.categories = append(ret.categories, c.categories...)
+
+ if c.sub != nil {
+ sub := c.sub.Copy()
+ ret.sub = &sub
+ }
+
+ return ret
+}
+
+// gets a human-readable description for a set string
+func (c CharSet) String() string {
+ buf := &bytes.Buffer{}
+ buf.WriteRune('[')
+
+ if c.IsNegated() {
+ buf.WriteRune('^')
+ }
+
+ for _, r := range c.ranges {
+
+ buf.WriteString(CharDescription(r.first))
+ if r.first != r.last {
+ if r.last-r.first != 1 {
+ //groups that are 1 char apart skip the dash
+ buf.WriteRune('-')
+ }
+ buf.WriteString(CharDescription(r.last))
+ }
+ }
+
+ for _, c := range c.categories {
+ buf.WriteString(c.String())
+ }
+
+ if c.sub != nil {
+ buf.WriteRune('-')
+ buf.WriteString(c.sub.String())
+ }
+
+ buf.WriteRune(']')
+
+ return buf.String()
+}
+
+// mapHashFill converts a charset into a buffer for use in maps
+func (c CharSet) mapHashFill(buf *bytes.Buffer) {
+ if c.negate {
+ buf.WriteByte(0)
+ } else {
+ buf.WriteByte(1)
+ }
+
+ binary.Write(buf, binary.LittleEndian, len(c.ranges))
+ binary.Write(buf, binary.LittleEndian, len(c.categories))
+ for _, r := range c.ranges {
+ buf.WriteRune(r.first)
+ buf.WriteRune(r.last)
+ }
+ for _, ct := range c.categories {
+ buf.WriteString(ct.cat)
+ if ct.negate {
+ buf.WriteByte(1)
+ } else {
+ buf.WriteByte(0)
+ }
+ }
+
+ if c.sub != nil {
+ c.sub.mapHashFill(buf)
+ }
+}
+
+// CharIn returns true if the rune is in our character set (either ranges or categories).
+// It handles negations and subtracted sub-charsets.
+func (c CharSet) CharIn(ch rune) bool {
+ val := false
+ // in s && !s.subtracted
+
+ //check ranges
+ for _, r := range c.ranges {
+ if ch < r.first {
+ continue
+ }
+ if ch <= r.last {
+ val = true
+ break
+ }
+ }
+
+ //check categories if we haven't already found a range
+ if !val && len(c.categories) > 0 {
+ for _, ct := range c.categories {
+ // special categories...then unicode
+ if ct.cat == spaceCategoryText {
+ if unicode.IsSpace(ch) {
+ // we found a space so we're done
+ // negate means this is a "bad" thing
+ val = !ct.negate
+ break
+ } else if ct.negate {
+ val = true
+ break
+ }
+ } else if ct.cat == wordCategoryText {
+ if IsWordChar(ch) {
+ val = !ct.negate
+ break
+ } else if ct.negate {
+ val = true
+ break
+ }
+ } else if unicode.Is(unicodeCategories[ct.cat], ch) {
+ // if we're in this unicode category then we're done
+ // if negate=true on this category then we "failed" our test
+ // otherwise we're good that we found it
+ val = !ct.negate
+ break
+ } else if ct.negate {
+ val = true
+ break
+ }
+ }
+ }
+
+ // negate the whole char set
+ if c.negate {
+ val = !val
+ }
+
+ // get subtracted recurse
+ if val && c.sub != nil {
+ val = !c.sub.CharIn(ch)
+ }
+
+ //log.Printf("Char '%v' in %v == %v", string(ch), c.String(), val)
+ return val
+}
+
+func (c category) String() string {
+ switch c.cat {
+ case spaceCategoryText:
+ if c.negate {
+ return "\\S"
+ }
+ return "\\s"
+ case wordCategoryText:
+ if c.negate {
+ return "\\W"
+ }
+ return "\\w"
+ }
+ if _, ok := unicodeCategories[c.cat]; ok {
+
+ if c.negate {
+ return "\\P{" + c.cat + "}"
+ }
+ return "\\p{" + c.cat + "}"
+ }
+ return "Unknown category: " + c.cat
+}
+
+// CharDescription Produces a human-readable description for a single character.
+func CharDescription(ch rune) string {
+ /*if ch == '\\' {
+ return "\\\\"
+ }
+
+ if ch > ' ' && ch <= '~' {
+ return string(ch)
+ } else if ch == '\n' {
+ return "\\n"
+ } else if ch == ' ' {
+ return "\\ "
+ }*/
+
+ b := &bytes.Buffer{}
+ escape(b, ch, false) //fmt.Sprintf("%U", ch)
+ return b.String()
+}
+
+// According to UTS#18 Unicode Regular Expressions (http://www.unicode.org/reports/tr18/)
+// RL 1.4 Simple Word Boundaries The class of includes all Alphabetic
+// values from the Unicode character database, from UnicodeData.txt [UData], plus the U+200C
+// ZERO WIDTH NON-JOINER and U+200D ZERO WIDTH JOINER.
+func IsWordChar(r rune) bool {
+ //"L", "Mn", "Nd", "Pc"
+ return unicode.In(r,
+ unicode.Categories["L"], unicode.Categories["Mn"],
+ unicode.Categories["Nd"], unicode.Categories["Pc"]) || r == '\u200D' || r == '\u200C'
+ //return 'A' <= r && r <= 'Z' || 'a' <= r && r <= 'z' || '0' <= r && r <= '9' || r == '_'
+}
+
+func IsECMAWordChar(r rune) bool {
+ return unicode.In(r,
+ unicode.Categories["L"], unicode.Categories["Mn"],
+ unicode.Categories["Nd"], unicode.Categories["Pc"])
+
+ //return 'A' <= r && r <= 'Z' || 'a' <= r && r <= 'z' || '0' <= r && r <= '9' || r == '_'
+}
+
+// SingletonChar will return the char from the first range without validation.
+// It assumes you have checked for IsSingleton or IsSingletonInverse and will panic given bad input
+func (c CharSet) SingletonChar() rune {
+ return c.ranges[0].first
+}
+
+func (c CharSet) IsSingleton() bool {
+ return !c.negate && //negated is multiple chars
+ len(c.categories) == 0 && len(c.ranges) == 1 && // multiple ranges and unicode classes represent multiple chars
+ c.sub == nil && // subtraction means we've got multiple chars
+ c.ranges[0].first == c.ranges[0].last // first and last equal means we're just 1 char
+}
+
+func (c CharSet) IsSingletonInverse() bool {
+ return c.negate && //same as above, but requires negated
+ len(c.categories) == 0 && len(c.ranges) == 1 && // multiple ranges and unicode classes represent multiple chars
+ c.sub == nil && // subtraction means we've got multiple chars
+ c.ranges[0].first == c.ranges[0].last // first and last equal means we're just 1 char
+}
+
+func (c CharSet) IsMergeable() bool {
+ return !c.IsNegated() && !c.HasSubtraction()
+}
+
+func (c CharSet) IsNegated() bool {
+ return c.negate
+}
+
+func (c CharSet) HasSubtraction() bool {
+ return c.sub != nil
+}
+
+func (c CharSet) IsEmpty() bool {
+ return len(c.ranges) == 0 && len(c.categories) == 0 && c.sub == nil
+}
+
+func (c *CharSet) addDigit(ecma, negate bool, pattern string) {
+ if ecma {
+ if negate {
+ c.addRanges(NotECMADigitClass().ranges)
+ } else {
+ c.addRanges(ECMADigitClass().ranges)
+ }
+ } else {
+ c.addCategories(category{cat: "Nd", negate: negate})
+ }
+}
+
+func (c *CharSet) addChar(ch rune) {
+ c.addRange(ch, ch)
+}
+
+func (c *CharSet) addSpace(ecma, negate bool) {
+ if ecma {
+ if negate {
+ c.addRanges(NotECMASpaceClass().ranges)
+ } else {
+ c.addRanges(ECMASpaceClass().ranges)
+ }
+ } else {
+ c.addCategories(category{cat: spaceCategoryText, negate: negate})
+ }
+}
+
+func (c *CharSet) addWord(ecma, negate bool) {
+ if ecma {
+ if negate {
+ c.addRanges(NotECMAWordClass().ranges)
+ } else {
+ c.addRanges(ECMAWordClass().ranges)
+ }
+ } else {
+ c.addCategories(category{cat: wordCategoryText, negate: negate})
+ }
+}
+
+// Add set ranges and categories into ours -- no deduping or anything
+func (c *CharSet) addSet(set CharSet) {
+ if c.anything {
+ return
+ }
+ if set.anything {
+ c.makeAnything()
+ return
+ }
+ // just append here to prevent double-canon
+ c.ranges = append(c.ranges, set.ranges...)
+ c.addCategories(set.categories...)
+ c.canonicalize()
+}
+
+func (c *CharSet) makeAnything() {
+ c.anything = true
+ c.categories = []category{}
+ c.ranges = AnyClass().ranges
+}
+
+func (c *CharSet) addCategories(cats ...category) {
+ // don't add dupes and remove positive+negative
+ if c.anything {
+ // if we've had a previous positive+negative group then
+ // just return, we're as broad as we can get
+ return
+ }
+
+ for _, ct := range cats {
+ found := false
+ for _, ct2 := range c.categories {
+ if ct.cat == ct2.cat {
+ if ct.negate != ct2.negate {
+ // oposite negations...this mean we just
+ // take us as anything and move on
+ c.makeAnything()
+ return
+ }
+ found = true
+ break
+ }
+ }
+
+ if !found {
+ c.categories = append(c.categories, ct)
+ }
+ }
+}
+
+// Merges new ranges to our own
+func (c *CharSet) addRanges(ranges []singleRange) {
+ if c.anything {
+ return
+ }
+ c.ranges = append(c.ranges, ranges...)
+ c.canonicalize()
+}
+
+// Merges everything but the new ranges into our own
+func (c *CharSet) addNegativeRanges(ranges []singleRange) {
+ if c.anything {
+ return
+ }
+
+ var hi rune
+
+ // convert incoming ranges into opposites, assume they are in order
+ for _, r := range ranges {
+ if hi < r.first {
+ c.ranges = append(c.ranges, singleRange{hi, r.first - 1})
+ }
+ hi = r.last + 1
+ }
+
+ if hi < utf8.MaxRune {
+ c.ranges = append(c.ranges, singleRange{hi, utf8.MaxRune})
+ }
+
+ c.canonicalize()
+}
+
+func isValidUnicodeCat(catName string) bool {
+ _, ok := unicodeCategories[catName]
+ return ok
+}
+
+func (c *CharSet) addCategory(categoryName string, negate, caseInsensitive bool, pattern string) {
+ if !isValidUnicodeCat(categoryName) {
+ // unknown unicode category, script, or property "blah"
+ panic(fmt.Errorf("Unknown unicode category, script, or property '%v'", categoryName))
+
+ }
+
+ if caseInsensitive && (categoryName == "Ll" || categoryName == "Lu" || categoryName == "Lt") {
+ // when RegexOptions.IgnoreCase is specified then {Ll} {Lu} and {Lt} cases should all match
+ c.addCategories(
+ category{cat: "Ll", negate: negate},
+ category{cat: "Lu", negate: negate},
+ category{cat: "Lt", negate: negate})
+ }
+ c.addCategories(category{cat: categoryName, negate: negate})
+}
+
+func (c *CharSet) addSubtraction(sub *CharSet) {
+ c.sub = sub
+}
+
+func (c *CharSet) addRange(chMin, chMax rune) {
+ c.ranges = append(c.ranges, singleRange{first: chMin, last: chMax})
+ c.canonicalize()
+}
+
+func (c *CharSet) addNamedASCII(name string, negate bool) bool {
+ var rs []singleRange
+
+ switch name {
+ case "alnum":
+ rs = []singleRange{singleRange{'0', '9'}, singleRange{'A', 'Z'}, singleRange{'a', 'z'}}
+ case "alpha":
+ rs = []singleRange{singleRange{'A', 'Z'}, singleRange{'a', 'z'}}
+ case "ascii":
+ rs = []singleRange{singleRange{0, 0x7f}}
+ case "blank":
+ rs = []singleRange{singleRange{'\t', '\t'}, singleRange{' ', ' '}}
+ case "cntrl":
+ rs = []singleRange{singleRange{0, 0x1f}, singleRange{0x7f, 0x7f}}
+ case "digit":
+ c.addDigit(false, negate, "")
+ case "graph":
+ rs = []singleRange{singleRange{'!', '~'}}
+ case "lower":
+ rs = []singleRange{singleRange{'a', 'z'}}
+ case "print":
+ rs = []singleRange{singleRange{' ', '~'}}
+ case "punct": //[!-/:-@[-`{-~]
+ rs = []singleRange{singleRange{'!', '/'}, singleRange{':', '@'}, singleRange{'[', '`'}, singleRange{'{', '~'}}
+ case "space":
+ c.addSpace(true, negate)
+ case "upper":
+ rs = []singleRange{singleRange{'A', 'Z'}}
+ case "word":
+ c.addWord(true, negate)
+ case "xdigit":
+ rs = []singleRange{singleRange{'0', '9'}, singleRange{'A', 'F'}, singleRange{'a', 'f'}}
+ default:
+ return false
+ }
+
+ if len(rs) > 0 {
+ if negate {
+ c.addNegativeRanges(rs)
+ } else {
+ c.addRanges(rs)
+ }
+ }
+
+ return true
+}
+
+type singleRangeSorter []singleRange
+
+func (p singleRangeSorter) Len() int { return len(p) }
+func (p singleRangeSorter) Less(i, j int) bool { return p[i].first < p[j].first }
+func (p singleRangeSorter) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+
+// Logic to reduce a character class to a unique, sorted form.
+func (c *CharSet) canonicalize() {
+ var i, j int
+ var last rune
+
+ //
+ // Find and eliminate overlapping or abutting ranges
+ //
+
+ if len(c.ranges) > 1 {
+ sort.Sort(singleRangeSorter(c.ranges))
+
+ done := false
+
+ for i, j = 1, 0; ; i++ {
+ for last = c.ranges[j].last; ; i++ {
+ if i == len(c.ranges) || last == utf8.MaxRune {
+ done = true
+ break
+ }
+
+ CurrentRange := c.ranges[i]
+ if CurrentRange.first > last+1 {
+ break
+ }
+
+ if last < CurrentRange.last {
+ last = CurrentRange.last
+ }
+ }
+
+ c.ranges[j] = singleRange{first: c.ranges[j].first, last: last}
+
+ j++
+
+ if done {
+ break
+ }
+
+ if j < i {
+ c.ranges[j] = c.ranges[i]
+ }
+ }
+
+ c.ranges = append(c.ranges[:j], c.ranges[len(c.ranges):]...)
+ }
+}
+
+// Adds to the class any lowercase versions of characters already
+// in the class. Used for case-insensitivity.
+func (c *CharSet) addLowercase() {
+ if c.anything {
+ return
+ }
+ toAdd := []singleRange{}
+ for i := 0; i < len(c.ranges); i++ {
+ r := c.ranges[i]
+ if r.first == r.last {
+ lower := unicode.ToLower(r.first)
+ c.ranges[i] = singleRange{first: lower, last: lower}
+ } else {
+ toAdd = append(toAdd, r)
+ }
+ }
+
+ for _, r := range toAdd {
+ c.addLowercaseRange(r.first, r.last)
+ }
+ c.canonicalize()
+}
+
+/**************************************************************************
+ Let U be the set of Unicode character values and let L be the lowercase
+ function, mapping from U to U. To perform case insensitive matching of
+ character sets, we need to be able to map an interval I in U, say
+
+ I = [chMin, chMax] = { ch : chMin <= ch <= chMax }
+
+ to a set A such that A contains L(I) and A is contained in the union of
+ I and L(I).
+
+ The table below partitions U into intervals on which L is non-decreasing.
+ Thus, for any interval J = [a, b] contained in one of these intervals,
+ L(J) is contained in [L(a), L(b)].
+
+ It is also true that for any such J, [L(a), L(b)] is contained in the
+ union of J and L(J). This does not follow from L being non-decreasing on
+ these intervals. It follows from the nature of the L on each interval.
+ On each interval, L has one of the following forms:
+
+ (1) L(ch) = constant (LowercaseSet)
+ (2) L(ch) = ch + offset (LowercaseAdd)
+ (3) L(ch) = ch | 1 (LowercaseBor)
+ (4) L(ch) = ch + (ch & 1) (LowercaseBad)
+
+ It is easy to verify that for any of these forms [L(a), L(b)] is
+ contained in the union of [a, b] and L([a, b]).
+***************************************************************************/
+
+const (
+ LowercaseSet = 0 // Set to arg.
+ LowercaseAdd = 1 // Add arg.
+ LowercaseBor = 2 // Bitwise or with 1.
+ LowercaseBad = 3 // Bitwise and with 1 and add original.
+)
+
+type lcMap struct {
+ chMin, chMax rune
+ op, data int32
+}
+
+var lcTable = []lcMap{
+ lcMap{'\u0041', '\u005A', LowercaseAdd, 32},
+ lcMap{'\u00C0', '\u00DE', LowercaseAdd, 32},
+ lcMap{'\u0100', '\u012E', LowercaseBor, 0},
+ lcMap{'\u0130', '\u0130', LowercaseSet, 0x0069},
+ lcMap{'\u0132', '\u0136', LowercaseBor, 0},
+ lcMap{'\u0139', '\u0147', LowercaseBad, 0},
+ lcMap{'\u014A', '\u0176', LowercaseBor, 0},
+ lcMap{'\u0178', '\u0178', LowercaseSet, 0x00FF},
+ lcMap{'\u0179', '\u017D', LowercaseBad, 0},
+ lcMap{'\u0181', '\u0181', LowercaseSet, 0x0253},
+ lcMap{'\u0182', '\u0184', LowercaseBor, 0},
+ lcMap{'\u0186', '\u0186', LowercaseSet, 0x0254},
+ lcMap{'\u0187', '\u0187', LowercaseSet, 0x0188},
+ lcMap{'\u0189', '\u018A', LowercaseAdd, 205},
+ lcMap{'\u018B', '\u018B', LowercaseSet, 0x018C},
+ lcMap{'\u018E', '\u018E', LowercaseSet, 0x01DD},
+ lcMap{'\u018F', '\u018F', LowercaseSet, 0x0259},
+ lcMap{'\u0190', '\u0190', LowercaseSet, 0x025B},
+ lcMap{'\u0191', '\u0191', LowercaseSet, 0x0192},
+ lcMap{'\u0193', '\u0193', LowercaseSet, 0x0260},
+ lcMap{'\u0194', '\u0194', LowercaseSet, 0x0263},
+ lcMap{'\u0196', '\u0196', LowercaseSet, 0x0269},
+ lcMap{'\u0197', '\u0197', LowercaseSet, 0x0268},
+ lcMap{'\u0198', '\u0198', LowercaseSet, 0x0199},
+ lcMap{'\u019C', '\u019C', LowercaseSet, 0x026F},
+ lcMap{'\u019D', '\u019D', LowercaseSet, 0x0272},
+ lcMap{'\u019F', '\u019F', LowercaseSet, 0x0275},
+ lcMap{'\u01A0', '\u01A4', LowercaseBor, 0},
+ lcMap{'\u01A7', '\u01A7', LowercaseSet, 0x01A8},
+ lcMap{'\u01A9', '\u01A9', LowercaseSet, 0x0283},
+ lcMap{'\u01AC', '\u01AC', LowercaseSet, 0x01AD},
+ lcMap{'\u01AE', '\u01AE', LowercaseSet, 0x0288},
+ lcMap{'\u01AF', '\u01AF', LowercaseSet, 0x01B0},
+ lcMap{'\u01B1', '\u01B2', LowercaseAdd, 217},
+ lcMap{'\u01B3', '\u01B5', LowercaseBad, 0},
+ lcMap{'\u01B7', '\u01B7', LowercaseSet, 0x0292},
+ lcMap{'\u01B8', '\u01B8', LowercaseSet, 0x01B9},
+ lcMap{'\u01BC', '\u01BC', LowercaseSet, 0x01BD},
+ lcMap{'\u01C4', '\u01C5', LowercaseSet, 0x01C6},
+ lcMap{'\u01C7', '\u01C8', LowercaseSet, 0x01C9},
+ lcMap{'\u01CA', '\u01CB', LowercaseSet, 0x01CC},
+ lcMap{'\u01CD', '\u01DB', LowercaseBad, 0},
+ lcMap{'\u01DE', '\u01EE', LowercaseBor, 0},
+ lcMap{'\u01F1', '\u01F2', LowercaseSet, 0x01F3},
+ lcMap{'\u01F4', '\u01F4', LowercaseSet, 0x01F5},
+ lcMap{'\u01FA', '\u0216', LowercaseBor, 0},
+ lcMap{'\u0386', '\u0386', LowercaseSet, 0x03AC},
+ lcMap{'\u0388', '\u038A', LowercaseAdd, 37},
+ lcMap{'\u038C', '\u038C', LowercaseSet, 0x03CC},
+ lcMap{'\u038E', '\u038F', LowercaseAdd, 63},
+ lcMap{'\u0391', '\u03AB', LowercaseAdd, 32},
+ lcMap{'\u03E2', '\u03EE', LowercaseBor, 0},
+ lcMap{'\u0401', '\u040F', LowercaseAdd, 80},
+ lcMap{'\u0410', '\u042F', LowercaseAdd, 32},
+ lcMap{'\u0460', '\u0480', LowercaseBor, 0},
+ lcMap{'\u0490', '\u04BE', LowercaseBor, 0},
+ lcMap{'\u04C1', '\u04C3', LowercaseBad, 0},
+ lcMap{'\u04C7', '\u04C7', LowercaseSet, 0x04C8},
+ lcMap{'\u04CB', '\u04CB', LowercaseSet, 0x04CC},
+ lcMap{'\u04D0', '\u04EA', LowercaseBor, 0},
+ lcMap{'\u04EE', '\u04F4', LowercaseBor, 0},
+ lcMap{'\u04F8', '\u04F8', LowercaseSet, 0x04F9},
+ lcMap{'\u0531', '\u0556', LowercaseAdd, 48},
+ lcMap{'\u10A0', '\u10C5', LowercaseAdd, 48},
+ lcMap{'\u1E00', '\u1EF8', LowercaseBor, 0},
+ lcMap{'\u1F08', '\u1F0F', LowercaseAdd, -8},
+ lcMap{'\u1F18', '\u1F1F', LowercaseAdd, -8},
+ lcMap{'\u1F28', '\u1F2F', LowercaseAdd, -8},
+ lcMap{'\u1F38', '\u1F3F', LowercaseAdd, -8},
+ lcMap{'\u1F48', '\u1F4D', LowercaseAdd, -8},
+ lcMap{'\u1F59', '\u1F59', LowercaseSet, 0x1F51},
+ lcMap{'\u1F5B', '\u1F5B', LowercaseSet, 0x1F53},
+ lcMap{'\u1F5D', '\u1F5D', LowercaseSet, 0x1F55},
+ lcMap{'\u1F5F', '\u1F5F', LowercaseSet, 0x1F57},
+ lcMap{'\u1F68', '\u1F6F', LowercaseAdd, -8},
+ lcMap{'\u1F88', '\u1F8F', LowercaseAdd, -8},
+ lcMap{'\u1F98', '\u1F9F', LowercaseAdd, -8},
+ lcMap{'\u1FA8', '\u1FAF', LowercaseAdd, -8},
+ lcMap{'\u1FB8', '\u1FB9', LowercaseAdd, -8},
+ lcMap{'\u1FBA', '\u1FBB', LowercaseAdd, -74},
+ lcMap{'\u1FBC', '\u1FBC', LowercaseSet, 0x1FB3},
+ lcMap{'\u1FC8', '\u1FCB', LowercaseAdd, -86},
+ lcMap{'\u1FCC', '\u1FCC', LowercaseSet, 0x1FC3},
+ lcMap{'\u1FD8', '\u1FD9', LowercaseAdd, -8},
+ lcMap{'\u1FDA', '\u1FDB', LowercaseAdd, -100},
+ lcMap{'\u1FE8', '\u1FE9', LowercaseAdd, -8},
+ lcMap{'\u1FEA', '\u1FEB', LowercaseAdd, -112},
+ lcMap{'\u1FEC', '\u1FEC', LowercaseSet, 0x1FE5},
+ lcMap{'\u1FF8', '\u1FF9', LowercaseAdd, -128},
+ lcMap{'\u1FFA', '\u1FFB', LowercaseAdd, -126},
+ lcMap{'\u1FFC', '\u1FFC', LowercaseSet, 0x1FF3},
+ lcMap{'\u2160', '\u216F', LowercaseAdd, 16},
+ lcMap{'\u24B6', '\u24D0', LowercaseAdd, 26},
+ lcMap{'\uFF21', '\uFF3A', LowercaseAdd, 32},
+}
+
+func (c *CharSet) addLowercaseRange(chMin, chMax rune) {
+ var i, iMax, iMid int
+ var chMinT, chMaxT rune
+ var lc lcMap
+
+ for i, iMax = 0, len(lcTable); i < iMax; {
+ iMid = (i + iMax) / 2
+ if lcTable[iMid].chMax < chMin {
+ i = iMid + 1
+ } else {
+ iMax = iMid
+ }
+ }
+
+ for ; i < len(lcTable); i++ {
+ lc = lcTable[i]
+ if lc.chMin > chMax {
+ return
+ }
+ chMinT = lc.chMin
+ if chMinT < chMin {
+ chMinT = chMin
+ }
+
+ chMaxT = lc.chMax
+ if chMaxT > chMax {
+ chMaxT = chMax
+ }
+
+ switch lc.op {
+ case LowercaseSet:
+ chMinT = rune(lc.data)
+ chMaxT = rune(lc.data)
+ break
+ case LowercaseAdd:
+ chMinT += lc.data
+ chMaxT += lc.data
+ break
+ case LowercaseBor:
+ chMinT |= 1
+ chMaxT |= 1
+ break
+ case LowercaseBad:
+ chMinT += (chMinT & 1)
+ chMaxT += (chMaxT & 1)
+ break
+ }
+
+ if chMinT < chMin || chMaxT > chMax {
+ c.addRange(chMinT, chMaxT)
+ }
+ }
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/code.go b/vendor/github.com/dlclark/regexp2/syntax/code.go
new file mode 100644
index 0000000..686e822
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/code.go
@@ -0,0 +1,274 @@
+package syntax
+
+import (
+ "bytes"
+ "fmt"
+ "math"
+)
+
+// similar to prog.go in the go regex package...also with comment 'may not belong in this package'
+
+// File provides operator constants for use by the Builder and the Machine.
+
+// Implementation notes:
+//
+// Regexps are built into RegexCodes, which contain an operation array,
+// a string table, and some constants.
+//
+// Each operation is one of the codes below, followed by the integer
+// operands specified for each op.
+//
+// Strings and sets are indices into a string table.
+
+type InstOp int
+
+const (
+ // lef/back operands description
+
+ Onerep InstOp = 0 // lef,back char,min,max a {n}
+ Notonerep = 1 // lef,back char,min,max .{n}
+ Setrep = 2 // lef,back set,min,max [\d]{n}
+
+ Oneloop = 3 // lef,back char,min,max a {,n}
+ Notoneloop = 4 // lef,back char,min,max .{,n}
+ Setloop = 5 // lef,back set,min,max [\d]{,n}
+
+ Onelazy = 6 // lef,back char,min,max a {,n}?
+ Notonelazy = 7 // lef,back char,min,max .{,n}?
+ Setlazy = 8 // lef,back set,min,max [\d]{,n}?
+
+ One = 9 // lef char a
+ Notone = 10 // lef char [^a]
+ Set = 11 // lef set [a-z\s] \w \s \d
+
+ Multi = 12 // lef string abcd
+ Ref = 13 // lef group \#
+
+ Bol = 14 // ^
+ Eol = 15 // $
+ Boundary = 16 // \b
+ Nonboundary = 17 // \B
+ Beginning = 18 // \A
+ Start = 19 // \G
+ EndZ = 20 // \Z
+ End = 21 // \Z
+
+ Nothing = 22 // Reject!
+
+ // Primitive control structures
+
+ Lazybranch = 23 // back jump straight first
+ Branchmark = 24 // back jump branch first for loop
+ Lazybranchmark = 25 // back jump straight first for loop
+ Nullcount = 26 // back val set counter, null mark
+ Setcount = 27 // back val set counter, make mark
+ Branchcount = 28 // back jump,limit branch++ if zero<=c impl group slots
+ Capsize int // number of impl group slots
+ FcPrefix *Prefix // the set of candidate first characters (may be null)
+ BmPrefix *BmPrefix // the fixed prefix string as a Boyer-Moore machine (may be null)
+ Anchors AnchorLoc // the set of zero-length start anchors (RegexFCD.Bol, etc)
+ RightToLeft bool // true if right to left
+}
+
+func opcodeBacktracks(op InstOp) bool {
+ op &= Mask
+
+ switch op {
+ case Oneloop, Notoneloop, Setloop, Onelazy, Notonelazy, Setlazy, Lazybranch, Branchmark, Lazybranchmark,
+ Nullcount, Setcount, Branchcount, Lazybranchcount, Setmark, Capturemark, Getmark, Setjump, Backjump,
+ Forejump, Goto:
+ return true
+
+ default:
+ return false
+ }
+}
+
+func opcodeSize(op InstOp) int {
+ op &= Mask
+
+ switch op {
+ case Nothing, Bol, Eol, Boundary, Nonboundary, ECMABoundary, NonECMABoundary, Beginning, Start, EndZ,
+ End, Nullmark, Setmark, Getmark, Setjump, Backjump, Forejump, Stop:
+ return 1
+
+ case One, Notone, Multi, Ref, Testref, Goto, Nullcount, Setcount, Lazybranch, Branchmark, Lazybranchmark,
+ Prune, Set:
+ return 2
+
+ case Capturemark, Branchcount, Lazybranchcount, Onerep, Notonerep, Oneloop, Notoneloop, Onelazy, Notonelazy,
+ Setlazy, Setrep, Setloop:
+ return 3
+
+ default:
+ panic(fmt.Errorf("Unexpected op code: %v", op))
+ }
+}
+
+var codeStr = []string{
+ "Onerep", "Notonerep", "Setrep",
+ "Oneloop", "Notoneloop", "Setloop",
+ "Onelazy", "Notonelazy", "Setlazy",
+ "One", "Notone", "Set",
+ "Multi", "Ref",
+ "Bol", "Eol", "Boundary", "Nonboundary", "Beginning", "Start", "EndZ", "End",
+ "Nothing",
+ "Lazybranch", "Branchmark", "Lazybranchmark",
+ "Nullcount", "Setcount", "Branchcount", "Lazybranchcount",
+ "Nullmark", "Setmark", "Capturemark", "Getmark",
+ "Setjump", "Backjump", "Forejump", "Testref", "Goto",
+ "Prune", "Stop",
+ "ECMABoundary", "NonECMABoundary",
+}
+
+func operatorDescription(op InstOp) string {
+ desc := codeStr[op&Mask]
+ if (op & Ci) != 0 {
+ desc += "-Ci"
+ }
+ if (op & Rtl) != 0 {
+ desc += "-Rtl"
+ }
+ if (op & Back) != 0 {
+ desc += "-Back"
+ }
+ if (op & Back2) != 0 {
+ desc += "-Back2"
+ }
+
+ return desc
+}
+
+// OpcodeDescription is a humman readable string of the specific offset
+func (c *Code) OpcodeDescription(offset int) string {
+ buf := &bytes.Buffer{}
+
+ op := InstOp(c.Codes[offset])
+ fmt.Fprintf(buf, "%06d ", offset)
+
+ if opcodeBacktracks(op & Mask) {
+ buf.WriteString("*")
+ } else {
+ buf.WriteString(" ")
+ }
+ buf.WriteString(operatorDescription(op))
+ buf.WriteString("(")
+ op &= Mask
+
+ switch op {
+ case One, Notone, Onerep, Notonerep, Oneloop, Notoneloop, Onelazy, Notonelazy:
+ buf.WriteString("Ch = ")
+ buf.WriteString(CharDescription(rune(c.Codes[offset+1])))
+
+ case Set, Setrep, Setloop, Setlazy:
+ buf.WriteString("Set = ")
+ buf.WriteString(c.Sets[c.Codes[offset+1]].String())
+
+ case Multi:
+ fmt.Fprintf(buf, "String = %s", string(c.Strings[c.Codes[offset+1]]))
+
+ case Ref, Testref:
+ fmt.Fprintf(buf, "Index = %d", c.Codes[offset+1])
+
+ case Capturemark:
+ fmt.Fprintf(buf, "Index = %d", c.Codes[offset+1])
+ if c.Codes[offset+2] != -1 {
+ fmt.Fprintf(buf, ", Unindex = %d", c.Codes[offset+2])
+ }
+
+ case Nullcount, Setcount:
+ fmt.Fprintf(buf, "Value = %d", c.Codes[offset+1])
+
+ case Goto, Lazybranch, Branchmark, Lazybranchmark, Branchcount, Lazybranchcount:
+ fmt.Fprintf(buf, "Addr = %d", c.Codes[offset+1])
+ }
+
+ switch op {
+ case Onerep, Notonerep, Oneloop, Notoneloop, Onelazy, Notonelazy, Setrep, Setloop, Setlazy:
+ buf.WriteString(", Rep = ")
+ if c.Codes[offset+2] == math.MaxInt32 {
+ buf.WriteString("inf")
+ } else {
+ fmt.Fprintf(buf, "%d", c.Codes[offset+2])
+ }
+
+ case Branchcount, Lazybranchcount:
+ buf.WriteString(", Limit = ")
+ if c.Codes[offset+2] == math.MaxInt32 {
+ buf.WriteString("inf")
+ } else {
+ fmt.Fprintf(buf, "%d", c.Codes[offset+2])
+ }
+
+ }
+
+ buf.WriteString(")")
+
+ return buf.String()
+}
+
+func (c *Code) Dump() string {
+ buf := &bytes.Buffer{}
+
+ if c.RightToLeft {
+ fmt.Fprintln(buf, "Direction: right-to-left")
+ } else {
+ fmt.Fprintln(buf, "Direction: left-to-right")
+ }
+ if c.FcPrefix == nil {
+ fmt.Fprintln(buf, "Firstchars: n/a")
+ } else {
+ fmt.Fprintf(buf, "Firstchars: %v\n", c.FcPrefix.PrefixSet.String())
+ }
+
+ if c.BmPrefix == nil {
+ fmt.Fprintln(buf, "Prefix: n/a")
+ } else {
+ fmt.Fprintf(buf, "Prefix: %v\n", Escape(c.BmPrefix.String()))
+ }
+
+ fmt.Fprintf(buf, "Anchors: %v\n", c.Anchors)
+ fmt.Fprintln(buf)
+
+ if c.BmPrefix != nil {
+ fmt.Fprintln(buf, "BoyerMoore:")
+ fmt.Fprintln(buf, c.BmPrefix.Dump(" "))
+ }
+ for i := 0; i < len(c.Codes); i += opcodeSize(InstOp(c.Codes[i])) {
+ fmt.Fprintln(buf, c.OpcodeDescription(i))
+ }
+
+ return buf.String()
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/escape.go b/vendor/github.com/dlclark/regexp2/syntax/escape.go
new file mode 100644
index 0000000..609df10
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/escape.go
@@ -0,0 +1,94 @@
+package syntax
+
+import (
+ "bytes"
+ "strconv"
+ "strings"
+ "unicode"
+)
+
+func Escape(input string) string {
+ b := &bytes.Buffer{}
+ for _, r := range input {
+ escape(b, r, false)
+ }
+ return b.String()
+}
+
+const meta = `\.+*?()|[]{}^$# `
+
+func escape(b *bytes.Buffer, r rune, force bool) {
+ if unicode.IsPrint(r) {
+ if strings.IndexRune(meta, r) >= 0 || force {
+ b.WriteRune('\\')
+ }
+ b.WriteRune(r)
+ return
+ }
+
+ switch r {
+ case '\a':
+ b.WriteString(`\a`)
+ case '\f':
+ b.WriteString(`\f`)
+ case '\n':
+ b.WriteString(`\n`)
+ case '\r':
+ b.WriteString(`\r`)
+ case '\t':
+ b.WriteString(`\t`)
+ case '\v':
+ b.WriteString(`\v`)
+ default:
+ if r < 0x100 {
+ b.WriteString(`\x`)
+ s := strconv.FormatInt(int64(r), 16)
+ if len(s) == 1 {
+ b.WriteRune('0')
+ }
+ b.WriteString(s)
+ break
+ }
+ b.WriteString(`\u`)
+ b.WriteString(strconv.FormatInt(int64(r), 16))
+ }
+}
+
+func Unescape(input string) (string, error) {
+ idx := strings.IndexRune(input, '\\')
+ // no slashes means no unescape needed
+ if idx == -1 {
+ return input, nil
+ }
+
+ buf := bytes.NewBufferString(input[:idx])
+ // get the runes for the rest of the string -- we're going full parser scan on this
+
+ p := parser{}
+ p.setPattern(input[idx+1:])
+ for {
+ if p.rightMost() {
+ return "", p.getErr(ErrIllegalEndEscape)
+ }
+ r, err := p.scanCharEscape()
+ if err != nil {
+ return "", err
+ }
+ buf.WriteRune(r)
+ // are we done?
+ if p.rightMost() {
+ return buf.String(), nil
+ }
+
+ r = p.moveRightGetChar()
+ for r != '\\' {
+ buf.WriteRune(r)
+ if p.rightMost() {
+ // we're done, no more slashes
+ return buf.String(), nil
+ }
+ // keep scanning until we get another slash
+ r = p.moveRightGetChar()
+ }
+ }
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/fuzz.go b/vendor/github.com/dlclark/regexp2/syntax/fuzz.go
new file mode 100644
index 0000000..ee86386
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/fuzz.go
@@ -0,0 +1,20 @@
+// +build gofuzz
+
+package syntax
+
+// Fuzz is the input point for go-fuzz
+func Fuzz(data []byte) int {
+ sdata := string(data)
+ tree, err := Parse(sdata, RegexOptions(0))
+ if err != nil {
+ return 0
+ }
+
+ // translate it to code
+ _, err = Write(tree)
+ if err != nil {
+ panic(err)
+ }
+
+ return 1
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/parser.go b/vendor/github.com/dlclark/regexp2/syntax/parser.go
new file mode 100644
index 0000000..da14f98
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/parser.go
@@ -0,0 +1,2213 @@
+package syntax
+
+import (
+ "fmt"
+ "math"
+ "os"
+ "sort"
+ "strconv"
+ "unicode"
+)
+
+type RegexOptions int32
+
+const (
+ IgnoreCase RegexOptions = 0x0001 // "i"
+ Multiline = 0x0002 // "m"
+ ExplicitCapture = 0x0004 // "n"
+ Compiled = 0x0008 // "c"
+ Singleline = 0x0010 // "s"
+ IgnorePatternWhitespace = 0x0020 // "x"
+ RightToLeft = 0x0040 // "r"
+ Debug = 0x0080 // "d"
+ ECMAScript = 0x0100 // "e"
+ RE2 = 0x0200 // RE2 compat mode
+)
+
+func optionFromCode(ch rune) RegexOptions {
+ // case-insensitive
+ switch ch {
+ case 'i', 'I':
+ return IgnoreCase
+ case 'r', 'R':
+ return RightToLeft
+ case 'm', 'M':
+ return Multiline
+ case 'n', 'N':
+ return ExplicitCapture
+ case 's', 'S':
+ return Singleline
+ case 'x', 'X':
+ return IgnorePatternWhitespace
+ case 'd', 'D':
+ return Debug
+ case 'e', 'E':
+ return ECMAScript
+ default:
+ return 0
+ }
+}
+
+// An Error describes a failure to parse a regular expression
+// and gives the offending expression.
+type Error struct {
+ Code ErrorCode
+ Expr string
+ Args []interface{}
+}
+
+func (e *Error) Error() string {
+ if len(e.Args) == 0 {
+ return "error parsing regexp: " + e.Code.String() + " in `" + e.Expr + "`"
+ }
+ return "error parsing regexp: " + fmt.Sprintf(e.Code.String(), e.Args...) + " in `" + e.Expr + "`"
+}
+
+// An ErrorCode describes a failure to parse a regular expression.
+type ErrorCode string
+
+const (
+ // internal issue
+ ErrInternalError ErrorCode = "regexp/syntax: internal error"
+ // Parser errors
+ ErrUnterminatedComment = "unterminated comment"
+ ErrInvalidCharRange = "invalid character class range"
+ ErrInvalidRepeatSize = "invalid repeat count"
+ ErrInvalidUTF8 = "invalid UTF-8"
+ ErrCaptureGroupOutOfRange = "capture group number out of range"
+ ErrUnexpectedParen = "unexpected )"
+ ErrMissingParen = "missing closing )"
+ ErrMissingBrace = "missing closing }"
+ ErrInvalidRepeatOp = "invalid nested repetition operator"
+ ErrMissingRepeatArgument = "missing argument to repetition operator"
+ ErrConditionalExpression = "illegal conditional (?(...)) expression"
+ ErrTooManyAlternates = "too many | in (?()|)"
+ ErrUnrecognizedGrouping = "unrecognized grouping construct: (%v"
+ ErrInvalidGroupName = "invalid group name: group names must begin with a word character and have a matching terminator"
+ ErrCapNumNotZero = "capture number cannot be zero"
+ ErrUndefinedBackRef = "reference to undefined group number %v"
+ ErrUndefinedNameRef = "reference to undefined group name %v"
+ ErrAlternationCantCapture = "alternation conditions do not capture and cannot be named"
+ ErrAlternationCantHaveComment = "alternation conditions cannot be comments"
+ ErrMalformedReference = "(?(%v) ) malformed"
+ ErrUndefinedReference = "(?(%v) ) reference to undefined group"
+ ErrIllegalEndEscape = "illegal \\ at end of pattern"
+ ErrMalformedSlashP = "malformed \\p{X} character escape"
+ ErrIncompleteSlashP = "incomplete \\p{X} character escape"
+ ErrUnknownSlashP = "unknown unicode category, script, or property '%v'"
+ ErrUnrecognizedEscape = "unrecognized escape sequence \\%v"
+ ErrMissingControl = "missing control character"
+ ErrUnrecognizedControl = "unrecognized control character"
+ ErrTooFewHex = "insufficient hexadecimal digits"
+ ErrInvalidHex = "hex values may not be larger than 0x10FFFF"
+ ErrMalformedNameRef = "malformed \\k<...> named back reference"
+ ErrBadClassInCharRange = "cannot include class \\%v in character range"
+ ErrUnterminatedBracket = "unterminated [] set"
+ ErrSubtractionMustBeLast = "a subtraction must be the last element in a character class"
+ ErrReversedCharRange = "[x-y] range in reverse order"
+)
+
+func (e ErrorCode) String() string {
+ return string(e)
+}
+
+type parser struct {
+ stack *regexNode
+ group *regexNode
+ alternation *regexNode
+ concatenation *regexNode
+ unit *regexNode
+
+ patternRaw string
+ pattern []rune
+
+ currentPos int
+ specialCase *unicode.SpecialCase
+
+ autocap int
+ capcount int
+ captop int
+ capsize int
+
+ caps map[int]int
+ capnames map[string]int
+
+ capnumlist []int
+ capnamelist []string
+
+ options RegexOptions
+ optionsStack []RegexOptions
+ ignoreNextParen bool
+}
+
+const (
+ maxValueDiv10 int = math.MaxInt32 / 10
+ maxValueMod10 = math.MaxInt32 % 10
+)
+
+// Parse converts a regex string into a parse tree
+func Parse(re string, op RegexOptions) (*RegexTree, error) {
+ p := parser{
+ options: op,
+ caps: make(map[int]int),
+ }
+ p.setPattern(re)
+
+ if err := p.countCaptures(); err != nil {
+ return nil, err
+ }
+
+ p.reset(op)
+ root, err := p.scanRegex()
+
+ if err != nil {
+ return nil, err
+ }
+ tree := &RegexTree{
+ root: root,
+ caps: p.caps,
+ capnumlist: p.capnumlist,
+ captop: p.captop,
+ Capnames: p.capnames,
+ Caplist: p.capnamelist,
+ options: op,
+ }
+
+ if tree.options&Debug > 0 {
+ os.Stdout.WriteString(tree.Dump())
+ }
+
+ return tree, nil
+}
+
+func (p *parser) setPattern(pattern string) {
+ p.patternRaw = pattern
+ p.pattern = make([]rune, 0, len(pattern))
+
+ //populate our rune array to handle utf8 encoding
+ for _, r := range pattern {
+ p.pattern = append(p.pattern, r)
+ }
+}
+func (p *parser) getErr(code ErrorCode, args ...interface{}) error {
+ return &Error{Code: code, Expr: p.patternRaw, Args: args}
+}
+
+func (p *parser) noteCaptureSlot(i, pos int) {
+ if _, ok := p.caps[i]; !ok {
+ // the rhs of the hashtable isn't used in the parser
+ p.caps[i] = pos
+ p.capcount++
+
+ if p.captop <= i {
+ if i == math.MaxInt32 {
+ p.captop = i
+ } else {
+ p.captop = i + 1
+ }
+ }
+ }
+}
+
+func (p *parser) noteCaptureName(name string, pos int) {
+ if p.capnames == nil {
+ p.capnames = make(map[string]int)
+ }
+
+ if _, ok := p.capnames[name]; !ok {
+ p.capnames[name] = pos
+ p.capnamelist = append(p.capnamelist, name)
+ }
+}
+
+func (p *parser) assignNameSlots() {
+ if p.capnames != nil {
+ for _, name := range p.capnamelist {
+ for p.isCaptureSlot(p.autocap) {
+ p.autocap++
+ }
+ pos := p.capnames[name]
+ p.capnames[name] = p.autocap
+ p.noteCaptureSlot(p.autocap, pos)
+
+ p.autocap++
+ }
+ }
+
+ // if the caps array has at least one gap, construct the list of used slots
+ if p.capcount < p.captop {
+ p.capnumlist = make([]int, p.capcount)
+ i := 0
+
+ for k := range p.caps {
+ p.capnumlist[i] = k
+ i++
+ }
+
+ sort.Ints(p.capnumlist)
+ }
+
+ // merge capsnumlist into capnamelist
+ if p.capnames != nil || p.capnumlist != nil {
+ var oldcapnamelist []string
+ var next int
+ var k int
+
+ if p.capnames == nil {
+ oldcapnamelist = nil
+ p.capnames = make(map[string]int)
+ p.capnamelist = []string{}
+ next = -1
+ } else {
+ oldcapnamelist = p.capnamelist
+ p.capnamelist = []string{}
+ next = p.capnames[oldcapnamelist[0]]
+ }
+
+ for i := 0; i < p.capcount; i++ {
+ j := i
+ if p.capnumlist != nil {
+ j = p.capnumlist[i]
+ }
+
+ if next == j {
+ p.capnamelist = append(p.capnamelist, oldcapnamelist[k])
+ k++
+
+ if k == len(oldcapnamelist) {
+ next = -1
+ } else {
+ next = p.capnames[oldcapnamelist[k]]
+ }
+
+ } else {
+ //feature: culture?
+ str := strconv.Itoa(j)
+ p.capnamelist = append(p.capnamelist, str)
+ p.capnames[str] = j
+ }
+ }
+ }
+}
+
+func (p *parser) consumeAutocap() int {
+ r := p.autocap
+ p.autocap++
+ return r
+}
+
+// CountCaptures is a prescanner for deducing the slots used for
+// captures by doing a partial tokenization of the pattern.
+func (p *parser) countCaptures() error {
+ var ch rune
+
+ p.noteCaptureSlot(0, 0)
+
+ p.autocap = 1
+
+ for p.charsRight() > 0 {
+ pos := p.textpos()
+ ch = p.moveRightGetChar()
+ switch ch {
+ case '\\':
+ if p.charsRight() > 0 {
+ p.scanBackslash(true)
+ }
+
+ case '#':
+ if p.useOptionX() {
+ p.moveLeft()
+ p.scanBlank()
+ }
+
+ case '[':
+ p.scanCharSet(false, true)
+
+ case ')':
+ if !p.emptyOptionsStack() {
+ p.popOptions()
+ }
+
+ case '(':
+ if p.charsRight() >= 2 && p.rightChar(1) == '#' && p.rightChar(0) == '?' {
+ p.moveLeft()
+ p.scanBlank()
+ } else {
+ p.pushOptions()
+ if p.charsRight() > 0 && p.rightChar(0) == '?' {
+ // we have (?...
+ p.moveRight(1)
+
+ if p.charsRight() > 1 && (p.rightChar(0) == '<' || p.rightChar(0) == '\'') {
+ // named group: (?<... or (?'...
+
+ p.moveRight(1)
+ ch = p.rightChar(0)
+
+ if ch != '0' && IsWordChar(ch) {
+ if ch >= '1' && ch <= '9' {
+ dec, err := p.scanDecimal()
+ if err != nil {
+ return err
+ }
+ p.noteCaptureSlot(dec, pos)
+ } else {
+ p.noteCaptureName(p.scanCapname(), pos)
+ }
+ }
+ } else if p.useRE2() && p.charsRight() > 2 && (p.rightChar(0) == 'P' && p.rightChar(1) == '<') {
+ // RE2-compat (?P<)
+ p.moveRight(2)
+ ch = p.rightChar(0)
+ if IsWordChar(ch) {
+ p.noteCaptureName(p.scanCapname(), pos)
+ }
+
+ } else {
+ // (?...
+
+ // get the options if it's an option construct (?cimsx-cimsx...)
+ p.scanOptions()
+
+ if p.charsRight() > 0 {
+ if p.rightChar(0) == ')' {
+ // (?cimsx-cimsx)
+ p.moveRight(1)
+ p.popKeepOptions()
+ } else if p.rightChar(0) == '(' {
+ // alternation construct: (?(foo)yes|no)
+ // ignore the next paren so we don't capture the condition
+ p.ignoreNextParen = true
+
+ // break from here so we don't reset ignoreNextParen
+ continue
+ }
+ }
+ }
+ } else {
+ if !p.useOptionN() && !p.ignoreNextParen {
+ p.noteCaptureSlot(p.consumeAutocap(), pos)
+ }
+ }
+ }
+
+ p.ignoreNextParen = false
+
+ }
+ }
+
+ p.assignNameSlots()
+ return nil
+}
+
+func (p *parser) reset(topopts RegexOptions) {
+ p.currentPos = 0
+ p.autocap = 1
+ p.ignoreNextParen = false
+
+ if len(p.optionsStack) > 0 {
+ p.optionsStack = p.optionsStack[:0]
+ }
+
+ p.options = topopts
+ p.stack = nil
+}
+
+func (p *parser) scanRegex() (*regexNode, error) {
+ ch := '@' // nonspecial ch, means at beginning
+ isQuant := false
+
+ p.startGroup(newRegexNodeMN(ntCapture, p.options, 0, -1))
+
+ for p.charsRight() > 0 {
+ wasPrevQuantifier := isQuant
+ isQuant = false
+
+ if err := p.scanBlank(); err != nil {
+ return nil, err
+ }
+
+ startpos := p.textpos()
+
+ // move past all of the normal characters. We'll stop when we hit some kind of control character,
+ // or if IgnorePatternWhiteSpace is on, we'll stop when we see some whitespace.
+ if p.useOptionX() {
+ for p.charsRight() > 0 {
+ ch = p.rightChar(0)
+ //UGLY: clean up, this is ugly
+ if !(!isStopperX(ch) || (ch == '{' && !p.isTrueQuantifier())) {
+ break
+ }
+ p.moveRight(1)
+ }
+ } else {
+ for p.charsRight() > 0 {
+ ch = p.rightChar(0)
+ if !(!isSpecial(ch) || ch == '{' && !p.isTrueQuantifier()) {
+ break
+ }
+ p.moveRight(1)
+ }
+ }
+
+ endpos := p.textpos()
+
+ p.scanBlank()
+
+ if p.charsRight() == 0 {
+ ch = '!' // nonspecial, means at end
+ } else if ch = p.rightChar(0); isSpecial(ch) {
+ isQuant = isQuantifier(ch)
+ p.moveRight(1)
+ } else {
+ ch = ' ' // nonspecial, means at ordinary char
+ }
+
+ if startpos < endpos {
+ cchUnquantified := endpos - startpos
+ if isQuant {
+ cchUnquantified--
+ }
+ wasPrevQuantifier = false
+
+ if cchUnquantified > 0 {
+ p.addToConcatenate(startpos, cchUnquantified, false)
+ }
+
+ if isQuant {
+ p.addUnitOne(p.charAt(endpos - 1))
+ }
+ }
+
+ switch ch {
+ case '!':
+ goto BreakOuterScan
+
+ case ' ':
+ goto ContinueOuterScan
+
+ case '[':
+ cc, err := p.scanCharSet(p.useOptionI(), false)
+ if err != nil {
+ return nil, err
+ }
+ p.addUnitSet(cc)
+
+ case '(':
+ p.pushOptions()
+
+ if grouper, err := p.scanGroupOpen(); err != nil {
+ return nil, err
+ } else if grouper == nil {
+ p.popKeepOptions()
+ } else {
+ p.pushGroup()
+ p.startGroup(grouper)
+ }
+
+ continue
+
+ case '|':
+ p.addAlternate()
+ goto ContinueOuterScan
+
+ case ')':
+ if p.emptyStack() {
+ return nil, p.getErr(ErrUnexpectedParen)
+ }
+
+ if err := p.addGroup(); err != nil {
+ return nil, err
+ }
+ if err := p.popGroup(); err != nil {
+ return nil, err
+ }
+ p.popOptions()
+
+ if p.unit == nil {
+ goto ContinueOuterScan
+ }
+
+ case '\\':
+ n, err := p.scanBackslash(false)
+ if err != nil {
+ return nil, err
+ }
+ p.addUnitNode(n)
+
+ case '^':
+ if p.useOptionM() {
+ p.addUnitType(ntBol)
+ } else {
+ p.addUnitType(ntBeginning)
+ }
+
+ case '$':
+ if p.useOptionM() {
+ p.addUnitType(ntEol)
+ } else {
+ p.addUnitType(ntEndZ)
+ }
+
+ case '.':
+ if p.useOptionE() {
+ p.addUnitSet(ECMAAnyClass())
+ } else if p.useOptionS() {
+ p.addUnitSet(AnyClass())
+ } else {
+ p.addUnitNotone('\n')
+ }
+
+ case '{', '*', '+', '?':
+ if p.unit == nil {
+ if wasPrevQuantifier {
+ return nil, p.getErr(ErrInvalidRepeatOp)
+ } else {
+ return nil, p.getErr(ErrMissingRepeatArgument)
+ }
+ }
+ p.moveLeft()
+
+ default:
+ return nil, p.getErr(ErrInternalError)
+ }
+
+ if err := p.scanBlank(); err != nil {
+ return nil, err
+ }
+
+ if p.charsRight() > 0 {
+ isQuant = p.isTrueQuantifier()
+ }
+ if p.charsRight() == 0 || !isQuant {
+ //maintain odd C# assignment order -- not sure if required, could clean up?
+ p.addConcatenate()
+ goto ContinueOuterScan
+ }
+
+ ch = p.moveRightGetChar()
+
+ // Handle quantifiers
+ for p.unit != nil {
+ var min, max int
+ var lazy bool
+
+ switch ch {
+ case '*':
+ min = 0
+ max = math.MaxInt32
+
+ case '?':
+ min = 0
+ max = 1
+
+ case '+':
+ min = 1
+ max = math.MaxInt32
+
+ case '{':
+ {
+ var err error
+ startpos = p.textpos()
+ if min, err = p.scanDecimal(); err != nil {
+ return nil, err
+ }
+ max = min
+ if startpos < p.textpos() {
+ if p.charsRight() > 0 && p.rightChar(0) == ',' {
+ p.moveRight(1)
+ if p.charsRight() == 0 || p.rightChar(0) == '}' {
+ max = math.MaxInt32
+ } else {
+ if max, err = p.scanDecimal(); err != nil {
+ return nil, err
+ }
+ }
+ }
+ }
+
+ if startpos == p.textpos() || p.charsRight() == 0 || p.moveRightGetChar() != '}' {
+ p.addConcatenate()
+ p.textto(startpos - 1)
+ goto ContinueOuterScan
+ }
+ }
+
+ default:
+ return nil, p.getErr(ErrInternalError)
+ }
+
+ if err := p.scanBlank(); err != nil {
+ return nil, err
+ }
+
+ if p.charsRight() == 0 || p.rightChar(0) != '?' {
+ lazy = false
+ } else {
+ p.moveRight(1)
+ lazy = true
+ }
+
+ if min > max {
+ return nil, p.getErr(ErrInvalidRepeatSize)
+ }
+
+ p.addConcatenate3(lazy, min, max)
+ }
+
+ ContinueOuterScan:
+ }
+
+BreakOuterScan:
+ ;
+
+ if !p.emptyStack() {
+ return nil, p.getErr(ErrMissingParen)
+ }
+
+ if err := p.addGroup(); err != nil {
+ return nil, err
+ }
+
+ return p.unit, nil
+
+}
+
+/*
+ * Simple parsing for replacement patterns
+ */
+func (p *parser) scanReplacement() (*regexNode, error) {
+ var c, startpos int
+
+ p.concatenation = newRegexNode(ntConcatenate, p.options)
+
+ for {
+ c = p.charsRight()
+ if c == 0 {
+ break
+ }
+
+ startpos = p.textpos()
+
+ for c > 0 && p.rightChar(0) != '$' {
+ p.moveRight(1)
+ c--
+ }
+
+ p.addToConcatenate(startpos, p.textpos()-startpos, true)
+
+ if c > 0 {
+ if p.moveRightGetChar() == '$' {
+ n, err := p.scanDollar()
+ if err != nil {
+ return nil, err
+ }
+ p.addUnitNode(n)
+ }
+ p.addConcatenate()
+ }
+ }
+
+ return p.concatenation, nil
+}
+
+/*
+ * Scans $ patterns recognized within replacement patterns
+ */
+func (p *parser) scanDollar() (*regexNode, error) {
+ if p.charsRight() == 0 {
+ return newRegexNodeCh(ntOne, p.options, '$'), nil
+ }
+
+ ch := p.rightChar(0)
+ angled := false
+ backpos := p.textpos()
+ lastEndPos := backpos
+
+ // Note angle
+
+ if ch == '{' && p.charsRight() > 1 {
+ angled = true
+ p.moveRight(1)
+ ch = p.rightChar(0)
+ }
+
+ // Try to parse backreference: \1 or \{1} or \{cap}
+
+ if ch >= '0' && ch <= '9' {
+ if !angled && p.useOptionE() {
+ capnum := -1
+ newcapnum := int(ch - '0')
+ p.moveRight(1)
+ if p.isCaptureSlot(newcapnum) {
+ capnum = newcapnum
+ lastEndPos = p.textpos()
+ }
+
+ for p.charsRight() > 0 {
+ ch = p.rightChar(0)
+ if ch < '0' || ch > '9' {
+ break
+ }
+ digit := int(ch - '0')
+ if newcapnum > maxValueDiv10 || (newcapnum == maxValueDiv10 && digit > maxValueMod10) {
+ return nil, p.getErr(ErrCaptureGroupOutOfRange)
+ }
+
+ newcapnum = newcapnum*10 + digit
+
+ p.moveRight(1)
+ if p.isCaptureSlot(newcapnum) {
+ capnum = newcapnum
+ lastEndPos = p.textpos()
+ }
+ }
+ p.textto(lastEndPos)
+ if capnum >= 0 {
+ return newRegexNodeM(ntRef, p.options, capnum), nil
+ }
+ } else {
+ capnum, err := p.scanDecimal()
+ if err != nil {
+ return nil, err
+ }
+ if !angled || p.charsRight() > 0 && p.moveRightGetChar() == '}' {
+ if p.isCaptureSlot(capnum) {
+ return newRegexNodeM(ntRef, p.options, capnum), nil
+ }
+ }
+ }
+ } else if angled && IsWordChar(ch) {
+ capname := p.scanCapname()
+
+ if p.charsRight() > 0 && p.moveRightGetChar() == '}' {
+ if p.isCaptureName(capname) {
+ return newRegexNodeM(ntRef, p.options, p.captureSlotFromName(capname)), nil
+ }
+ }
+ } else if !angled {
+ capnum := 1
+
+ switch ch {
+ case '$':
+ p.moveRight(1)
+ return newRegexNodeCh(ntOne, p.options, '$'), nil
+ case '&':
+ capnum = 0
+ case '`':
+ capnum = replaceLeftPortion
+ case '\'':
+ capnum = replaceRightPortion
+ case '+':
+ capnum = replaceLastGroup
+ case '_':
+ capnum = replaceWholeString
+ }
+
+ if capnum != 1 {
+ p.moveRight(1)
+ return newRegexNodeM(ntRef, p.options, capnum), nil
+ }
+ }
+
+ // unrecognized $: literalize
+
+ p.textto(backpos)
+ return newRegexNodeCh(ntOne, p.options, '$'), nil
+}
+
+// scanGroupOpen scans chars following a '(' (not counting the '('), and returns
+// a RegexNode for the type of group scanned, or nil if the group
+// simply changed options (?cimsx-cimsx) or was a comment (#...).
+func (p *parser) scanGroupOpen() (*regexNode, error) {
+ var ch rune
+ var nt nodeType
+ var err error
+ close := '>'
+ start := p.textpos()
+
+ // just return a RegexNode if we have:
+ // 1. "(" followed by nothing
+ // 2. "(x" where x != ?
+ // 3. "(?)"
+ if p.charsRight() == 0 || p.rightChar(0) != '?' || (p.rightChar(0) == '?' && (p.charsRight() > 1 && p.rightChar(1) == ')')) {
+ if p.useOptionN() || p.ignoreNextParen {
+ p.ignoreNextParen = false
+ return newRegexNode(ntGroup, p.options), nil
+ }
+ return newRegexNodeMN(ntCapture, p.options, p.consumeAutocap(), -1), nil
+ }
+
+ p.moveRight(1)
+
+ for {
+ if p.charsRight() == 0 {
+ break
+ }
+
+ switch ch = p.moveRightGetChar(); ch {
+ case ':':
+ nt = ntGroup
+
+ case '=':
+ p.options &= ^RightToLeft
+ nt = ntRequire
+
+ case '!':
+ p.options &= ^RightToLeft
+ nt = ntPrevent
+
+ case '>':
+ nt = ntGreedy
+
+ case '\'':
+ close = '\''
+ fallthrough
+
+ case '<':
+ if p.charsRight() == 0 {
+ goto BreakRecognize
+ }
+
+ switch ch = p.moveRightGetChar(); ch {
+ case '=':
+ if close == '\'' {
+ goto BreakRecognize
+ }
+
+ p.options |= RightToLeft
+ nt = ntRequire
+
+ case '!':
+ if close == '\'' {
+ goto BreakRecognize
+ }
+
+ p.options |= RightToLeft
+ nt = ntPrevent
+
+ default:
+ p.moveLeft()
+ capnum := -1
+ uncapnum := -1
+ proceed := false
+
+ // grab part before -
+
+ if ch >= '0' && ch <= '9' {
+ if capnum, err = p.scanDecimal(); err != nil {
+ return nil, err
+ }
+
+ if !p.isCaptureSlot(capnum) {
+ capnum = -1
+ }
+
+ // check if we have bogus characters after the number
+ if p.charsRight() > 0 && !(p.rightChar(0) == close || p.rightChar(0) == '-') {
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+ if capnum == 0 {
+ return nil, p.getErr(ErrCapNumNotZero)
+ }
+ } else if IsWordChar(ch) {
+ capname := p.scanCapname()
+
+ if p.isCaptureName(capname) {
+ capnum = p.captureSlotFromName(capname)
+ }
+
+ // check if we have bogus character after the name
+ if p.charsRight() > 0 && !(p.rightChar(0) == close || p.rightChar(0) == '-') {
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+ } else if ch == '-' {
+ proceed = true
+ } else {
+ // bad group name - starts with something other than a word character and isn't a number
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+
+ // grab part after - if any
+
+ if (capnum != -1 || proceed == true) && p.charsRight() > 0 && p.rightChar(0) == '-' {
+ p.moveRight(1)
+
+ //no more chars left, no closing char, etc
+ if p.charsRight() == 0 {
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+
+ ch = p.rightChar(0)
+ if ch >= '0' && ch <= '9' {
+ if uncapnum, err = p.scanDecimal(); err != nil {
+ return nil, err
+ }
+
+ if !p.isCaptureSlot(uncapnum) {
+ return nil, p.getErr(ErrUndefinedBackRef, uncapnum)
+ }
+
+ // check if we have bogus characters after the number
+ if p.charsRight() > 0 && p.rightChar(0) != close {
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+ } else if IsWordChar(ch) {
+ uncapname := p.scanCapname()
+
+ if !p.isCaptureName(uncapname) {
+ return nil, p.getErr(ErrUndefinedNameRef, uncapname)
+ }
+ uncapnum = p.captureSlotFromName(uncapname)
+
+ // check if we have bogus character after the name
+ if p.charsRight() > 0 && p.rightChar(0) != close {
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+ } else {
+ // bad group name - starts with something other than a word character and isn't a number
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+ }
+
+ // actually make the node
+
+ if (capnum != -1 || uncapnum != -1) && p.charsRight() > 0 && p.moveRightGetChar() == close {
+ return newRegexNodeMN(ntCapture, p.options, capnum, uncapnum), nil
+ }
+ goto BreakRecognize
+ }
+
+ case '(':
+ // alternation construct (?(...) | )
+
+ parenPos := p.textpos()
+ if p.charsRight() > 0 {
+ ch = p.rightChar(0)
+
+ // check if the alternation condition is a backref
+ if ch >= '0' && ch <= '9' {
+ var capnum int
+ if capnum, err = p.scanDecimal(); err != nil {
+ return nil, err
+ }
+ if p.charsRight() > 0 && p.moveRightGetChar() == ')' {
+ if p.isCaptureSlot(capnum) {
+ return newRegexNodeM(ntTestref, p.options, capnum), nil
+ }
+ return nil, p.getErr(ErrUndefinedReference, capnum)
+ }
+
+ return nil, p.getErr(ErrMalformedReference, capnum)
+
+ } else if IsWordChar(ch) {
+ capname := p.scanCapname()
+
+ if p.isCaptureName(capname) && p.charsRight() > 0 && p.moveRightGetChar() == ')' {
+ return newRegexNodeM(ntTestref, p.options, p.captureSlotFromName(capname)), nil
+ }
+ }
+ }
+ // not a backref
+ nt = ntTestgroup
+ p.textto(parenPos - 1) // jump to the start of the parentheses
+ p.ignoreNextParen = true // but make sure we don't try to capture the insides
+
+ charsRight := p.charsRight()
+ if charsRight >= 3 && p.rightChar(1) == '?' {
+ rightchar2 := p.rightChar(2)
+ // disallow comments in the condition
+ if rightchar2 == '#' {
+ return nil, p.getErr(ErrAlternationCantHaveComment)
+ }
+
+ // disallow named capture group (?<..>..) in the condition
+ if rightchar2 == '\'' {
+ return nil, p.getErr(ErrAlternationCantCapture)
+ }
+
+ if charsRight >= 4 && (rightchar2 == '<' && p.rightChar(3) != '!' && p.rightChar(3) != '=') {
+ return nil, p.getErr(ErrAlternationCantCapture)
+ }
+ }
+
+ case 'P':
+ if p.useRE2() {
+ // support for P syntax
+ if p.charsRight() < 3 {
+ goto BreakRecognize
+ }
+
+ ch = p.moveRightGetChar()
+ if ch != '<' {
+ goto BreakRecognize
+ }
+
+ ch = p.moveRightGetChar()
+ p.moveLeft()
+
+ if IsWordChar(ch) {
+ capnum := -1
+ capname := p.scanCapname()
+
+ if p.isCaptureName(capname) {
+ capnum = p.captureSlotFromName(capname)
+ }
+
+ // check if we have bogus character after the name
+ if p.charsRight() > 0 && p.rightChar(0) != '>' {
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+
+ // actually make the node
+
+ if capnum != -1 && p.charsRight() > 0 && p.moveRightGetChar() == '>' {
+ return newRegexNodeMN(ntCapture, p.options, capnum, -1), nil
+ }
+ goto BreakRecognize
+
+ } else {
+ // bad group name - starts with something other than a word character and isn't a number
+ return nil, p.getErr(ErrInvalidGroupName)
+ }
+ }
+ // if we're not using RE2 compat mode then
+ // we just behave like normal
+ fallthrough
+
+ default:
+ p.moveLeft()
+
+ nt = ntGroup
+ // disallow options in the children of a testgroup node
+ if p.group.t != ntTestgroup {
+ p.scanOptions()
+ }
+ if p.charsRight() == 0 {
+ goto BreakRecognize
+ }
+
+ if ch = p.moveRightGetChar(); ch == ')' {
+ return nil, nil
+ }
+
+ if ch != ':' {
+ goto BreakRecognize
+ }
+
+ }
+
+ return newRegexNode(nt, p.options), nil
+ }
+
+BreakRecognize:
+
+ // break Recognize comes here
+
+ return nil, p.getErr(ErrUnrecognizedGrouping, string(p.pattern[start:p.textpos()]))
+}
+
+// scans backslash specials and basics
+func (p *parser) scanBackslash(scanOnly bool) (*regexNode, error) {
+
+ if p.charsRight() == 0 {
+ return nil, p.getErr(ErrIllegalEndEscape)
+ }
+
+ switch ch := p.rightChar(0); ch {
+ case 'b', 'B', 'A', 'G', 'Z', 'z':
+ p.moveRight(1)
+ return newRegexNode(p.typeFromCode(ch), p.options), nil
+
+ case 'w':
+ p.moveRight(1)
+ if p.useOptionE() {
+ return newRegexNodeSet(ntSet, p.options, ECMAWordClass()), nil
+ }
+ return newRegexNodeSet(ntSet, p.options, WordClass()), nil
+
+ case 'W':
+ p.moveRight(1)
+ if p.useOptionE() {
+ return newRegexNodeSet(ntSet, p.options, NotECMAWordClass()), nil
+ }
+ return newRegexNodeSet(ntSet, p.options, NotWordClass()), nil
+
+ case 's':
+ p.moveRight(1)
+ if p.useOptionE() {
+ return newRegexNodeSet(ntSet, p.options, ECMASpaceClass()), nil
+ }
+ return newRegexNodeSet(ntSet, p.options, SpaceClass()), nil
+
+ case 'S':
+ p.moveRight(1)
+ if p.useOptionE() {
+ return newRegexNodeSet(ntSet, p.options, NotECMASpaceClass()), nil
+ }
+ return newRegexNodeSet(ntSet, p.options, NotSpaceClass()), nil
+
+ case 'd':
+ p.moveRight(1)
+ if p.useOptionE() {
+ return newRegexNodeSet(ntSet, p.options, ECMADigitClass()), nil
+ }
+ return newRegexNodeSet(ntSet, p.options, DigitClass()), nil
+
+ case 'D':
+ p.moveRight(1)
+ if p.useOptionE() {
+ return newRegexNodeSet(ntSet, p.options, NotECMADigitClass()), nil
+ }
+ return newRegexNodeSet(ntSet, p.options, NotDigitClass()), nil
+
+ case 'p', 'P':
+ p.moveRight(1)
+ prop, err := p.parseProperty()
+ if err != nil {
+ return nil, err
+ }
+ cc := &CharSet{}
+ cc.addCategory(prop, (ch != 'p'), p.useOptionI(), p.patternRaw)
+ if p.useOptionI() {
+ cc.addLowercase()
+ }
+
+ return newRegexNodeSet(ntSet, p.options, cc), nil
+
+ default:
+ return p.scanBasicBackslash(scanOnly)
+ }
+}
+
+// Scans \-style backreferences and character escapes
+func (p *parser) scanBasicBackslash(scanOnly bool) (*regexNode, error) {
+ if p.charsRight() == 0 {
+ return nil, p.getErr(ErrIllegalEndEscape)
+ }
+ angled := false
+ close := '\x00'
+
+ backpos := p.textpos()
+ ch := p.rightChar(0)
+
+ // allow \k instead of \, which is now deprecated
+
+ if ch == 'k' {
+ if p.charsRight() >= 2 {
+ p.moveRight(1)
+ ch = p.moveRightGetChar()
+
+ if ch == '<' || ch == '\'' {
+ angled = true
+ if ch == '\'' {
+ close = '\''
+ } else {
+ close = '>'
+ }
+ }
+ }
+
+ if !angled || p.charsRight() <= 0 {
+ return nil, p.getErr(ErrMalformedNameRef)
+ }
+
+ ch = p.rightChar(0)
+
+ } else if (ch == '<' || ch == '\'') && p.charsRight() > 1 { // Note angle without \g
+ angled = true
+ if ch == '\'' {
+ close = '\''
+ } else {
+ close = '>'
+ }
+
+ p.moveRight(1)
+ ch = p.rightChar(0)
+ }
+
+ // Try to parse backreference: \<1> or \
+
+ if angled && ch >= '0' && ch <= '9' {
+ capnum, err := p.scanDecimal()
+ if err != nil {
+ return nil, err
+ }
+
+ if p.charsRight() > 0 && p.moveRightGetChar() == close {
+ if p.isCaptureSlot(capnum) {
+ return newRegexNodeM(ntRef, p.options, capnum), nil
+ }
+ return nil, p.getErr(ErrUndefinedBackRef, capnum)
+ }
+ } else if !angled && ch >= '1' && ch <= '9' { // Try to parse backreference or octal: \1
+ capnum, err := p.scanDecimal()
+ if err != nil {
+ return nil, err
+ }
+
+ if scanOnly {
+ return nil, nil
+ }
+
+ if p.isCaptureSlot(capnum) {
+ return newRegexNodeM(ntRef, p.options, capnum), nil
+ }
+ if capnum <= 9 && !p.useOptionE() {
+ return nil, p.getErr(ErrUndefinedBackRef, capnum)
+ }
+
+ } else if angled && IsWordChar(ch) {
+ capname := p.scanCapname()
+
+ if p.charsRight() > 0 && p.moveRightGetChar() == close {
+ if p.isCaptureName(capname) {
+ return newRegexNodeM(ntRef, p.options, p.captureSlotFromName(capname)), nil
+ }
+ return nil, p.getErr(ErrUndefinedNameRef, capname)
+ }
+ }
+
+ // Not backreference: must be char code
+
+ p.textto(backpos)
+ ch, err := p.scanCharEscape()
+ if err != nil {
+ return nil, err
+ }
+
+ if p.useOptionI() {
+ ch = unicode.ToLower(ch)
+ }
+
+ return newRegexNodeCh(ntOne, p.options, ch), nil
+}
+
+// Scans X for \p{X} or \P{X}
+func (p *parser) parseProperty() (string, error) {
+ if p.charsRight() < 3 {
+ return "", p.getErr(ErrIncompleteSlashP)
+ }
+ ch := p.moveRightGetChar()
+ if ch != '{' {
+ return "", p.getErr(ErrMalformedSlashP)
+ }
+
+ startpos := p.textpos()
+ for p.charsRight() > 0 {
+ ch = p.moveRightGetChar()
+ if !(IsWordChar(ch) || ch == '-') {
+ p.moveLeft()
+ break
+ }
+ }
+ capname := string(p.pattern[startpos:p.textpos()])
+
+ if p.charsRight() == 0 || p.moveRightGetChar() != '}' {
+ return "", p.getErr(ErrIncompleteSlashP)
+ }
+
+ if !isValidUnicodeCat(capname) {
+ return "", p.getErr(ErrUnknownSlashP, capname)
+ }
+
+ return capname, nil
+}
+
+// Returns ReNode type for zero-length assertions with a \ code.
+func (p *parser) typeFromCode(ch rune) nodeType {
+ switch ch {
+ case 'b':
+ if p.useOptionE() {
+ return ntECMABoundary
+ }
+ return ntBoundary
+ case 'B':
+ if p.useOptionE() {
+ return ntNonECMABoundary
+ }
+ return ntNonboundary
+ case 'A':
+ return ntBeginning
+ case 'G':
+ return ntStart
+ case 'Z':
+ return ntEndZ
+ case 'z':
+ return ntEnd
+ default:
+ return ntNothing
+ }
+}
+
+// Scans whitespace or x-mode comments.
+func (p *parser) scanBlank() error {
+ if p.useOptionX() {
+ for {
+ for p.charsRight() > 0 && isSpace(p.rightChar(0)) {
+ p.moveRight(1)
+ }
+
+ if p.charsRight() == 0 {
+ break
+ }
+
+ if p.rightChar(0) == '#' {
+ for p.charsRight() > 0 && p.rightChar(0) != '\n' {
+ p.moveRight(1)
+ }
+ } else if p.charsRight() >= 3 && p.rightChar(2) == '#' &&
+ p.rightChar(1) == '?' && p.rightChar(0) == '(' {
+ for p.charsRight() > 0 && p.rightChar(0) != ')' {
+ p.moveRight(1)
+ }
+ if p.charsRight() == 0 {
+ return p.getErr(ErrUnterminatedComment)
+ }
+ p.moveRight(1)
+ } else {
+ break
+ }
+ }
+ } else {
+ for {
+ if p.charsRight() < 3 || p.rightChar(2) != '#' ||
+ p.rightChar(1) != '?' || p.rightChar(0) != '(' {
+ return nil
+ }
+
+ for p.charsRight() > 0 && p.rightChar(0) != ')' {
+ p.moveRight(1)
+ }
+ if p.charsRight() == 0 {
+ return p.getErr(ErrUnterminatedComment)
+ }
+ p.moveRight(1)
+ }
+ }
+ return nil
+}
+
+func (p *parser) scanCapname() string {
+ startpos := p.textpos()
+
+ for p.charsRight() > 0 {
+ if !IsWordChar(p.moveRightGetChar()) {
+ p.moveLeft()
+ break
+ }
+ }
+
+ return string(p.pattern[startpos:p.textpos()])
+}
+
+//Scans contents of [] (not including []'s), and converts to a set.
+func (p *parser) scanCharSet(caseInsensitive, scanOnly bool) (*CharSet, error) {
+ ch := '\x00'
+ chPrev := '\x00'
+ inRange := false
+ firstChar := true
+ closed := false
+
+ var cc *CharSet
+ if !scanOnly {
+ cc = &CharSet{}
+ }
+
+ if p.charsRight() > 0 && p.rightChar(0) == '^' {
+ p.moveRight(1)
+ if !scanOnly {
+ cc.negate = true
+ }
+ }
+
+ for ; p.charsRight() > 0; firstChar = false {
+ fTranslatedChar := false
+ ch = p.moveRightGetChar()
+ if ch == ']' {
+ if !firstChar {
+ closed = true
+ break
+ } else if p.useOptionE() {
+ if !scanOnly {
+ cc.addRanges(NoneClass().ranges)
+ }
+ closed = true
+ break
+ }
+
+ } else if ch == '\\' && p.charsRight() > 0 {
+ switch ch = p.moveRightGetChar(); ch {
+ case 'D', 'd':
+ if !scanOnly {
+ if inRange {
+ return nil, p.getErr(ErrBadClassInCharRange, ch)
+ }
+ cc.addDigit(p.useOptionE(), ch == 'D', p.patternRaw)
+ }
+ continue
+
+ case 'S', 's':
+ if !scanOnly {
+ if inRange {
+ return nil, p.getErr(ErrBadClassInCharRange, ch)
+ }
+ cc.addSpace(p.useOptionE(), ch == 'S')
+ }
+ continue
+
+ case 'W', 'w':
+ if !scanOnly {
+ if inRange {
+ return nil, p.getErr(ErrBadClassInCharRange, ch)
+ }
+
+ cc.addWord(p.useOptionE(), ch == 'W')
+ }
+ continue
+
+ case 'p', 'P':
+ if !scanOnly {
+ if inRange {
+ return nil, p.getErr(ErrBadClassInCharRange, ch)
+ }
+ prop, err := p.parseProperty()
+ if err != nil {
+ return nil, err
+ }
+ cc.addCategory(prop, (ch != 'p'), caseInsensitive, p.patternRaw)
+ } else {
+ p.parseProperty()
+ }
+
+ continue
+
+ case '-':
+ if !scanOnly {
+ cc.addRange(ch, ch)
+ }
+ continue
+
+ default:
+ p.moveLeft()
+ var err error
+ ch, err = p.scanCharEscape() // non-literal character
+ if err != nil {
+ return nil, err
+ }
+ fTranslatedChar = true
+ break // this break will only break out of the switch
+ }
+ } else if ch == '[' {
+ // This is code for Posix style properties - [:Ll:] or [:IsTibetan:].
+ // It currently doesn't do anything other than skip the whole thing!
+ if p.charsRight() > 0 && p.rightChar(0) == ':' && !inRange {
+ savePos := p.textpos()
+
+ p.moveRight(1)
+ negate := false
+ if p.charsRight() > 1 && p.rightChar(0) == '^' {
+ negate = true
+ p.moveRight(1)
+ }
+
+ nm := p.scanCapname() // snag the name
+ if !scanOnly && p.useRE2() {
+ // look up the name since these are valid for RE2
+ // add the group based on the name
+ if ok := cc.addNamedASCII(nm, negate); !ok {
+ return nil, p.getErr(ErrInvalidCharRange)
+ }
+ }
+ if p.charsRight() < 2 || p.moveRightGetChar() != ':' || p.moveRightGetChar() != ']' {
+ p.textto(savePos)
+ } else if p.useRE2() {
+ // move on
+ continue
+ }
+ }
+ }
+
+ if inRange {
+ inRange = false
+ if !scanOnly {
+ if ch == '[' && !fTranslatedChar && !firstChar {
+ // We thought we were in a range, but we're actually starting a subtraction.
+ // In that case, we'll add chPrev to our char class, skip the opening [, and
+ // scan the new character class recursively.
+ cc.addChar(chPrev)
+ sub, err := p.scanCharSet(caseInsensitive, false)
+ if err != nil {
+ return nil, err
+ }
+ cc.addSubtraction(sub)
+
+ if p.charsRight() > 0 && p.rightChar(0) != ']' {
+ return nil, p.getErr(ErrSubtractionMustBeLast)
+ }
+ } else {
+ // a regular range, like a-z
+ if chPrev > ch {
+ return nil, p.getErr(ErrReversedCharRange)
+ }
+ cc.addRange(chPrev, ch)
+ }
+ }
+ } else if p.charsRight() >= 2 && p.rightChar(0) == '-' && p.rightChar(1) != ']' {
+ // this could be the start of a range
+ chPrev = ch
+ inRange = true
+ p.moveRight(1)
+ } else if p.charsRight() >= 1 && ch == '-' && !fTranslatedChar && p.rightChar(0) == '[' && !firstChar {
+ // we aren't in a range, and now there is a subtraction. Usually this happens
+ // only when a subtraction follows a range, like [a-z-[b]]
+ if !scanOnly {
+ p.moveRight(1)
+ sub, err := p.scanCharSet(caseInsensitive, false)
+ if err != nil {
+ return nil, err
+ }
+ cc.addSubtraction(sub)
+
+ if p.charsRight() > 0 && p.rightChar(0) != ']' {
+ return nil, p.getErr(ErrSubtractionMustBeLast)
+ }
+ } else {
+ p.moveRight(1)
+ p.scanCharSet(caseInsensitive, true)
+ }
+ } else {
+ if !scanOnly {
+ cc.addRange(ch, ch)
+ }
+ }
+ }
+
+ if !closed {
+ return nil, p.getErr(ErrUnterminatedBracket)
+ }
+
+ if !scanOnly && caseInsensitive {
+ cc.addLowercase()
+ }
+
+ return cc, nil
+}
+
+// Scans any number of decimal digits (pegs value at 2^31-1 if too large)
+func (p *parser) scanDecimal() (int, error) {
+ i := 0
+ var d int
+
+ for p.charsRight() > 0 {
+ d = int(p.rightChar(0) - '0')
+ if d < 0 || d > 9 {
+ break
+ }
+ p.moveRight(1)
+
+ if i > maxValueDiv10 || (i == maxValueDiv10 && d > maxValueMod10) {
+ return 0, p.getErr(ErrCaptureGroupOutOfRange)
+ }
+
+ i *= 10
+ i += d
+ }
+
+ return int(i), nil
+}
+
+// Returns true for options allowed only at the top level
+func isOnlyTopOption(option RegexOptions) bool {
+ return option == RightToLeft || option == ECMAScript || option == RE2
+}
+
+// Scans cimsx-cimsx option string, stops at the first unrecognized char.
+func (p *parser) scanOptions() {
+
+ for off := false; p.charsRight() > 0; p.moveRight(1) {
+ ch := p.rightChar(0)
+
+ if ch == '-' {
+ off = true
+ } else if ch == '+' {
+ off = false
+ } else {
+ option := optionFromCode(ch)
+ if option == 0 || isOnlyTopOption(option) {
+ return
+ }
+
+ if off {
+ p.options &= ^option
+ } else {
+ p.options |= option
+ }
+ }
+ }
+}
+
+// Scans \ code for escape codes that map to single unicode chars.
+func (p *parser) scanCharEscape() (r rune, err error) {
+
+ ch := p.moveRightGetChar()
+
+ if ch >= '0' && ch <= '7' {
+ p.moveLeft()
+ return p.scanOctal(), nil
+ }
+
+ pos := p.textpos()
+
+ switch ch {
+ case 'x':
+ // support for \x{HEX} syntax from Perl and PCRE
+ if p.charsRight() > 0 && p.rightChar(0) == '{' {
+ if p.useOptionE() {
+ return ch, nil
+ }
+ p.moveRight(1)
+ return p.scanHexUntilBrace()
+ } else {
+ r, err = p.scanHex(2)
+ }
+ case 'u':
+ r, err = p.scanHex(4)
+ case 'a':
+ return '\u0007', nil
+ case 'b':
+ return '\b', nil
+ case 'e':
+ return '\u001B', nil
+ case 'f':
+ return '\f', nil
+ case 'n':
+ return '\n', nil
+ case 'r':
+ return '\r', nil
+ case 't':
+ return '\t', nil
+ case 'v':
+ return '\u000B', nil
+ case 'c':
+ r, err = p.scanControl()
+ default:
+ if !p.useOptionE() && IsWordChar(ch) {
+ return 0, p.getErr(ErrUnrecognizedEscape, string(ch))
+ }
+ return ch, nil
+ }
+ if err != nil && p.useOptionE() {
+ p.textto(pos)
+ return ch, nil
+ }
+ return
+}
+
+// Grabs and converts an ascii control character
+func (p *parser) scanControl() (rune, error) {
+ if p.charsRight() <= 0 {
+ return 0, p.getErr(ErrMissingControl)
+ }
+
+ ch := p.moveRightGetChar()
+
+ // \ca interpreted as \cA
+
+ if ch >= 'a' && ch <= 'z' {
+ ch = (ch - ('a' - 'A'))
+ }
+ ch = (ch - '@')
+ if ch >= 0 && ch < ' ' {
+ return ch, nil
+ }
+
+ return 0, p.getErr(ErrUnrecognizedControl)
+
+}
+
+// Scan hex digits until we hit a closing brace.
+// Non-hex digits, hex value too large for UTF-8, or running out of chars are errors
+func (p *parser) scanHexUntilBrace() (rune, error) {
+ // PCRE spec reads like unlimited hex digits are allowed, but unicode has a limit
+ // so we can enforce that
+ i := 0
+ hasContent := false
+
+ for p.charsRight() > 0 {
+ ch := p.moveRightGetChar()
+ if ch == '}' {
+ // hit our close brace, we're done here
+ // prevent \x{}
+ if !hasContent {
+ return 0, p.getErr(ErrTooFewHex)
+ }
+ return rune(i), nil
+ }
+ hasContent = true
+ // no brace needs to be hex digit
+ d := hexDigit(ch)
+ if d < 0 {
+ return 0, p.getErr(ErrMissingBrace)
+ }
+
+ i *= 0x10
+ i += d
+
+ if i > unicode.MaxRune {
+ return 0, p.getErr(ErrInvalidHex)
+ }
+ }
+
+ // we only make it here if we run out of digits without finding the brace
+ return 0, p.getErr(ErrMissingBrace)
+}
+
+// Scans exactly c hex digits (c=2 for \xFF, c=4 for \uFFFF)
+func (p *parser) scanHex(c int) (rune, error) {
+
+ i := 0
+
+ if p.charsRight() >= c {
+ for c > 0 {
+ d := hexDigit(p.moveRightGetChar())
+ if d < 0 {
+ break
+ }
+ i *= 0x10
+ i += d
+ c--
+ }
+ }
+
+ if c > 0 {
+ return 0, p.getErr(ErrTooFewHex)
+ }
+
+ return rune(i), nil
+}
+
+// Returns n <= 0xF for a hex digit.
+func hexDigit(ch rune) int {
+
+ if d := uint(ch - '0'); d <= 9 {
+ return int(d)
+ }
+
+ if d := uint(ch - 'a'); d <= 5 {
+ return int(d + 0xa)
+ }
+
+ if d := uint(ch - 'A'); d <= 5 {
+ return int(d + 0xa)
+ }
+
+ return -1
+}
+
+// Scans up to three octal digits (stops before exceeding 0377).
+func (p *parser) scanOctal() rune {
+ // Consume octal chars only up to 3 digits and value 0377
+
+ c := 3
+
+ if c > p.charsRight() {
+ c = p.charsRight()
+ }
+
+ //we know the first char is good because the caller had to check
+ i := 0
+ d := int(p.rightChar(0) - '0')
+ for c > 0 && d <= 7 && d >= 0 {
+ if i >= 0x20 && p.useOptionE() {
+ break
+ }
+ i *= 8
+ i += d
+ c--
+
+ p.moveRight(1)
+ if !p.rightMost() {
+ d = int(p.rightChar(0) - '0')
+ }
+ }
+
+ // Octal codes only go up to 255. Any larger and the behavior that Perl follows
+ // is simply to truncate the high bits.
+ i &= 0xFF
+
+ return rune(i)
+}
+
+// Returns the current parsing position.
+func (p *parser) textpos() int {
+ return p.currentPos
+}
+
+// Zaps to a specific parsing position.
+func (p *parser) textto(pos int) {
+ p.currentPos = pos
+}
+
+// Returns the char at the right of the current parsing position and advances to the right.
+func (p *parser) moveRightGetChar() rune {
+ ch := p.pattern[p.currentPos]
+ p.currentPos++
+ return ch
+}
+
+// Moves the current position to the right.
+func (p *parser) moveRight(i int) {
+ // default would be 1
+ p.currentPos += i
+}
+
+// Moves the current parsing position one to the left.
+func (p *parser) moveLeft() {
+ p.currentPos--
+}
+
+// Returns the char left of the current parsing position.
+func (p *parser) charAt(i int) rune {
+ return p.pattern[i]
+}
+
+// Returns the char i chars right of the current parsing position.
+func (p *parser) rightChar(i int) rune {
+ // default would be 0
+ return p.pattern[p.currentPos+i]
+}
+
+// Number of characters to the right of the current parsing position.
+func (p *parser) charsRight() int {
+ return len(p.pattern) - p.currentPos
+}
+
+func (p *parser) rightMost() bool {
+ return p.currentPos == len(p.pattern)
+}
+
+// Looks up the slot number for a given name
+func (p *parser) captureSlotFromName(capname string) int {
+ return p.capnames[capname]
+}
+
+// True if the capture slot was noted
+func (p *parser) isCaptureSlot(i int) bool {
+ if p.caps != nil {
+ _, ok := p.caps[i]
+ return ok
+ }
+
+ return (i >= 0 && i < p.capsize)
+}
+
+// Looks up the slot number for a given name
+func (p *parser) isCaptureName(capname string) bool {
+ if p.capnames == nil {
+ return false
+ }
+
+ _, ok := p.capnames[capname]
+ return ok
+}
+
+// option shortcuts
+
+// True if N option disabling '(' autocapture is on.
+func (p *parser) useOptionN() bool {
+ return (p.options & ExplicitCapture) != 0
+}
+
+// True if I option enabling case-insensitivity is on.
+func (p *parser) useOptionI() bool {
+ return (p.options & IgnoreCase) != 0
+}
+
+// True if M option altering meaning of $ and ^ is on.
+func (p *parser) useOptionM() bool {
+ return (p.options & Multiline) != 0
+}
+
+// True if S option altering meaning of . is on.
+func (p *parser) useOptionS() bool {
+ return (p.options & Singleline) != 0
+}
+
+// True if X option enabling whitespace/comment mode is on.
+func (p *parser) useOptionX() bool {
+ return (p.options & IgnorePatternWhitespace) != 0
+}
+
+// True if E option enabling ECMAScript behavior on.
+func (p *parser) useOptionE() bool {
+ return (p.options & ECMAScript) != 0
+}
+
+// true to use RE2 compatibility parsing behavior.
+func (p *parser) useRE2() bool {
+ return (p.options & RE2) != 0
+}
+
+// True if options stack is empty.
+func (p *parser) emptyOptionsStack() bool {
+ return len(p.optionsStack) == 0
+}
+
+// Finish the current quantifiable (when a quantifier is not found or is not possible)
+func (p *parser) addConcatenate() {
+ // The first (| inside a Testgroup group goes directly to the group
+ p.concatenation.addChild(p.unit)
+ p.unit = nil
+}
+
+// Finish the current quantifiable (when a quantifier is found)
+func (p *parser) addConcatenate3(lazy bool, min, max int) {
+ p.concatenation.addChild(p.unit.makeQuantifier(lazy, min, max))
+ p.unit = nil
+}
+
+// Sets the current unit to a single char node
+func (p *parser) addUnitOne(ch rune) {
+ if p.useOptionI() {
+ ch = unicode.ToLower(ch)
+ }
+
+ p.unit = newRegexNodeCh(ntOne, p.options, ch)
+}
+
+// Sets the current unit to a single inverse-char node
+func (p *parser) addUnitNotone(ch rune) {
+ if p.useOptionI() {
+ ch = unicode.ToLower(ch)
+ }
+
+ p.unit = newRegexNodeCh(ntNotone, p.options, ch)
+}
+
+// Sets the current unit to a single set node
+func (p *parser) addUnitSet(set *CharSet) {
+ p.unit = newRegexNodeSet(ntSet, p.options, set)
+}
+
+// Sets the current unit to a subtree
+func (p *parser) addUnitNode(node *regexNode) {
+ p.unit = node
+}
+
+// Sets the current unit to an assertion of the specified type
+func (p *parser) addUnitType(t nodeType) {
+ p.unit = newRegexNode(t, p.options)
+}
+
+// Finish the current group (in response to a ')' or end)
+func (p *parser) addGroup() error {
+ if p.group.t == ntTestgroup || p.group.t == ntTestref {
+ p.group.addChild(p.concatenation.reverseLeft())
+ if (p.group.t == ntTestref && len(p.group.children) > 2) || len(p.group.children) > 3 {
+ return p.getErr(ErrTooManyAlternates)
+ }
+ } else {
+ p.alternation.addChild(p.concatenation.reverseLeft())
+ p.group.addChild(p.alternation)
+ }
+
+ p.unit = p.group
+ return nil
+}
+
+// Pops the option stack, but keeps the current options unchanged.
+func (p *parser) popKeepOptions() {
+ lastIdx := len(p.optionsStack) - 1
+ p.optionsStack = p.optionsStack[:lastIdx]
+}
+
+// Recalls options from the stack.
+func (p *parser) popOptions() {
+ lastIdx := len(p.optionsStack) - 1
+ // get the last item on the stack and then remove it by reslicing
+ p.options = p.optionsStack[lastIdx]
+ p.optionsStack = p.optionsStack[:lastIdx]
+}
+
+// Saves options on a stack.
+func (p *parser) pushOptions() {
+ p.optionsStack = append(p.optionsStack, p.options)
+}
+
+// Add a string to the last concatenate.
+func (p *parser) addToConcatenate(pos, cch int, isReplacement bool) {
+ var node *regexNode
+
+ if cch == 0 {
+ return
+ }
+
+ if cch > 1 {
+ str := p.pattern[pos : pos+cch]
+
+ if p.useOptionI() && !isReplacement {
+ // We do the ToLower character by character for consistency. With surrogate chars, doing
+ // a ToLower on the entire string could actually change the surrogate pair. This is more correct
+ // linguistically, but since Regex doesn't support surrogates, it's more important to be
+ // consistent.
+ for i := 0; i < len(str); i++ {
+ str[i] = unicode.ToLower(str[i])
+ }
+ }
+
+ node = newRegexNodeStr(ntMulti, p.options, str)
+ } else {
+ ch := p.charAt(pos)
+
+ if p.useOptionI() && !isReplacement {
+ ch = unicode.ToLower(ch)
+ }
+
+ node = newRegexNodeCh(ntOne, p.options, ch)
+ }
+
+ p.concatenation.addChild(node)
+}
+
+// Push the parser state (in response to an open paren)
+func (p *parser) pushGroup() {
+ p.group.next = p.stack
+ p.alternation.next = p.group
+ p.concatenation.next = p.alternation
+ p.stack = p.concatenation
+}
+
+// Remember the pushed state (in response to a ')')
+func (p *parser) popGroup() error {
+ p.concatenation = p.stack
+ p.alternation = p.concatenation.next
+ p.group = p.alternation.next
+ p.stack = p.group.next
+
+ // The first () inside a Testgroup group goes directly to the group
+ if p.group.t == ntTestgroup && len(p.group.children) == 0 {
+ if p.unit == nil {
+ return p.getErr(ErrConditionalExpression)
+ }
+
+ p.group.addChild(p.unit)
+ p.unit = nil
+ }
+ return nil
+}
+
+// True if the group stack is empty.
+func (p *parser) emptyStack() bool {
+ return p.stack == nil
+}
+
+// Start a new round for the parser state (in response to an open paren or string start)
+func (p *parser) startGroup(openGroup *regexNode) {
+ p.group = openGroup
+ p.alternation = newRegexNode(ntAlternate, p.options)
+ p.concatenation = newRegexNode(ntConcatenate, p.options)
+}
+
+// Finish the current concatenation (in response to a |)
+func (p *parser) addAlternate() {
+ // The | parts inside a Testgroup group go directly to the group
+
+ if p.group.t == ntTestgroup || p.group.t == ntTestref {
+ p.group.addChild(p.concatenation.reverseLeft())
+ } else {
+ p.alternation.addChild(p.concatenation.reverseLeft())
+ }
+
+ p.concatenation = newRegexNode(ntConcatenate, p.options)
+}
+
+// For categorizing ascii characters.
+
+const (
+ Q byte = 5 // quantifier
+ S = 4 // ordinary stopper
+ Z = 3 // ScanBlank stopper
+ X = 2 // whitespace
+ E = 1 // should be escaped
+)
+
+var _category = []byte{
+ //01 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, X, X, X, X, X, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ // ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
+ X, 0, 0, Z, S, 0, 0, 0, S, S, Q, Q, 0, 0, S, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Q,
+ //@A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, S, S, 0, S, 0,
+ //'a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Q, S, 0, 0, 0,
+}
+
+func isSpace(ch rune) bool {
+ return (ch <= ' ' && _category[ch] == X)
+}
+
+// Returns true for those characters that terminate a string of ordinary chars.
+func isSpecial(ch rune) bool {
+ return (ch <= '|' && _category[ch] >= S)
+}
+
+// Returns true for those characters that terminate a string of ordinary chars.
+func isStopperX(ch rune) bool {
+ return (ch <= '|' && _category[ch] >= X)
+}
+
+// Returns true for those characters that begin a quantifier.
+func isQuantifier(ch rune) bool {
+ return (ch <= '{' && _category[ch] >= Q)
+}
+
+func (p *parser) isTrueQuantifier() bool {
+ nChars := p.charsRight()
+ if nChars == 0 {
+ return false
+ }
+
+ startpos := p.textpos()
+ ch := p.charAt(startpos)
+ if ch != '{' {
+ return ch <= '{' && _category[ch] >= Q
+ }
+
+ //UGLY: this is ugly -- the original code was ugly too
+ pos := startpos
+ for {
+ nChars--
+ if nChars <= 0 {
+ break
+ }
+ pos++
+ ch = p.charAt(pos)
+ if ch < '0' || ch > '9' {
+ break
+ }
+ }
+
+ if nChars == 0 || pos-startpos == 1 {
+ return false
+ }
+ if ch == '}' {
+ return true
+ }
+ if ch != ',' {
+ return false
+ }
+ for {
+ nChars--
+ if nChars <= 0 {
+ break
+ }
+ pos++
+ ch = p.charAt(pos)
+ if ch < '0' || ch > '9' {
+ break
+ }
+ }
+
+ return nChars > 0 && ch == '}'
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/prefix.go b/vendor/github.com/dlclark/regexp2/syntax/prefix.go
new file mode 100644
index 0000000..011ef0b
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/prefix.go
@@ -0,0 +1,896 @@
+package syntax
+
+import (
+ "bytes"
+ "fmt"
+ "strconv"
+ "unicode"
+ "unicode/utf8"
+)
+
+type Prefix struct {
+ PrefixStr []rune
+ PrefixSet CharSet
+ CaseInsensitive bool
+}
+
+// It takes a RegexTree and computes the set of chars that can start it.
+func getFirstCharsPrefix(tree *RegexTree) *Prefix {
+ s := regexFcd{
+ fcStack: make([]regexFc, 32),
+ intStack: make([]int, 32),
+ }
+ fc := s.regexFCFromRegexTree(tree)
+
+ if fc == nil || fc.nullable || fc.cc.IsEmpty() {
+ return nil
+ }
+ fcSet := fc.getFirstChars()
+ return &Prefix{PrefixSet: fcSet, CaseInsensitive: fc.caseInsensitive}
+}
+
+type regexFcd struct {
+ intStack []int
+ intDepth int
+ fcStack []regexFc
+ fcDepth int
+ skipAllChildren bool // don't process any more children at the current level
+ skipchild bool // don't process the current child.
+ failed bool
+}
+
+/*
+ * The main FC computation. It does a shortcutted depth-first walk
+ * through the tree and calls CalculateFC to emits code before
+ * and after each child of an interior node, and at each leaf.
+ */
+func (s *regexFcd) regexFCFromRegexTree(tree *RegexTree) *regexFc {
+ curNode := tree.root
+ curChild := 0
+
+ for {
+ if len(curNode.children) == 0 {
+ // This is a leaf node
+ s.calculateFC(curNode.t, curNode, 0)
+ } else if curChild < len(curNode.children) && !s.skipAllChildren {
+ // This is an interior node, and we have more children to analyze
+ s.calculateFC(curNode.t|beforeChild, curNode, curChild)
+
+ if !s.skipchild {
+ curNode = curNode.children[curChild]
+ // this stack is how we get a depth first walk of the tree.
+ s.pushInt(curChild)
+ curChild = 0
+ } else {
+ curChild++
+ s.skipchild = false
+ }
+ continue
+ }
+
+ // This is an interior node where we've finished analyzing all the children, or
+ // the end of a leaf node.
+ s.skipAllChildren = false
+
+ if s.intIsEmpty() {
+ break
+ }
+
+ curChild = s.popInt()
+ curNode = curNode.next
+
+ s.calculateFC(curNode.t|afterChild, curNode, curChild)
+ if s.failed {
+ return nil
+ }
+
+ curChild++
+ }
+
+ if s.fcIsEmpty() {
+ return nil
+ }
+
+ return s.popFC()
+}
+
+// To avoid recursion, we use a simple integer stack.
+// This is the push.
+func (s *regexFcd) pushInt(I int) {
+ if s.intDepth >= len(s.intStack) {
+ expanded := make([]int, s.intDepth*2)
+ copy(expanded, s.intStack)
+ s.intStack = expanded
+ }
+
+ s.intStack[s.intDepth] = I
+ s.intDepth++
+}
+
+// True if the stack is empty.
+func (s *regexFcd) intIsEmpty() bool {
+ return s.intDepth == 0
+}
+
+// This is the pop.
+func (s *regexFcd) popInt() int {
+ s.intDepth--
+ return s.intStack[s.intDepth]
+}
+
+// We also use a stack of RegexFC objects.
+// This is the push.
+func (s *regexFcd) pushFC(fc regexFc) {
+ if s.fcDepth >= len(s.fcStack) {
+ expanded := make([]regexFc, s.fcDepth*2)
+ copy(expanded, s.fcStack)
+ s.fcStack = expanded
+ }
+
+ s.fcStack[s.fcDepth] = fc
+ s.fcDepth++
+}
+
+// True if the stack is empty.
+func (s *regexFcd) fcIsEmpty() bool {
+ return s.fcDepth == 0
+}
+
+// This is the pop.
+func (s *regexFcd) popFC() *regexFc {
+ s.fcDepth--
+ return &s.fcStack[s.fcDepth]
+}
+
+// This is the top.
+func (s *regexFcd) topFC() *regexFc {
+ return &s.fcStack[s.fcDepth-1]
+}
+
+// Called in Beforechild to prevent further processing of the current child
+func (s *regexFcd) skipChild() {
+ s.skipchild = true
+}
+
+// FC computation and shortcut cases for each node type
+func (s *regexFcd) calculateFC(nt nodeType, node *regexNode, CurIndex int) {
+ //fmt.Printf("NodeType: %v, CurIndex: %v, Desc: %v\n", nt, CurIndex, node.description())
+ ci := false
+ rtl := false
+
+ if nt <= ntRef {
+ if (node.options & IgnoreCase) != 0 {
+ ci = true
+ }
+ if (node.options & RightToLeft) != 0 {
+ rtl = true
+ }
+ }
+
+ switch nt {
+ case ntConcatenate | beforeChild, ntAlternate | beforeChild, ntTestref | beforeChild, ntLoop | beforeChild, ntLazyloop | beforeChild:
+ break
+
+ case ntTestgroup | beforeChild:
+ if CurIndex == 0 {
+ s.skipChild()
+ }
+ break
+
+ case ntEmpty:
+ s.pushFC(regexFc{nullable: true})
+ break
+
+ case ntConcatenate | afterChild:
+ if CurIndex != 0 {
+ child := s.popFC()
+ cumul := s.topFC()
+
+ s.failed = !cumul.addFC(*child, true)
+ }
+
+ fc := s.topFC()
+ if !fc.nullable {
+ s.skipAllChildren = true
+ }
+ break
+
+ case ntTestgroup | afterChild:
+ if CurIndex > 1 {
+ child := s.popFC()
+ cumul := s.topFC()
+
+ s.failed = !cumul.addFC(*child, false)
+ }
+ break
+
+ case ntAlternate | afterChild, ntTestref | afterChild:
+ if CurIndex != 0 {
+ child := s.popFC()
+ cumul := s.topFC()
+
+ s.failed = !cumul.addFC(*child, false)
+ }
+ break
+
+ case ntLoop | afterChild, ntLazyloop | afterChild:
+ if node.m == 0 {
+ fc := s.topFC()
+ fc.nullable = true
+ }
+ break
+
+ case ntGroup | beforeChild, ntGroup | afterChild, ntCapture | beforeChild, ntCapture | afterChild, ntGreedy | beforeChild, ntGreedy | afterChild:
+ break
+
+ case ntRequire | beforeChild, ntPrevent | beforeChild:
+ s.skipChild()
+ s.pushFC(regexFc{nullable: true})
+ break
+
+ case ntRequire | afterChild, ntPrevent | afterChild:
+ break
+
+ case ntOne, ntNotone:
+ s.pushFC(newRegexFc(node.ch, nt == ntNotone, false, ci))
+ break
+
+ case ntOneloop, ntOnelazy:
+ s.pushFC(newRegexFc(node.ch, false, node.m == 0, ci))
+ break
+
+ case ntNotoneloop, ntNotonelazy:
+ s.pushFC(newRegexFc(node.ch, true, node.m == 0, ci))
+ break
+
+ case ntMulti:
+ if len(node.str) == 0 {
+ s.pushFC(regexFc{nullable: true})
+ } else if !rtl {
+ s.pushFC(newRegexFc(node.str[0], false, false, ci))
+ } else {
+ s.pushFC(newRegexFc(node.str[len(node.str)-1], false, false, ci))
+ }
+ break
+
+ case ntSet:
+ s.pushFC(regexFc{cc: node.set.Copy(), nullable: false, caseInsensitive: ci})
+ break
+
+ case ntSetloop, ntSetlazy:
+ s.pushFC(regexFc{cc: node.set.Copy(), nullable: node.m == 0, caseInsensitive: ci})
+ break
+
+ case ntRef:
+ s.pushFC(regexFc{cc: *AnyClass(), nullable: true, caseInsensitive: false})
+ break
+
+ case ntNothing, ntBol, ntEol, ntBoundary, ntNonboundary, ntECMABoundary, ntNonECMABoundary, ntBeginning, ntStart, ntEndZ, ntEnd:
+ s.pushFC(regexFc{nullable: true})
+ break
+
+ default:
+ panic(fmt.Sprintf("unexpected op code: %v", nt))
+ }
+}
+
+type regexFc struct {
+ cc CharSet
+ nullable bool
+ caseInsensitive bool
+}
+
+func newRegexFc(ch rune, not, nullable, caseInsensitive bool) regexFc {
+ r := regexFc{
+ caseInsensitive: caseInsensitive,
+ nullable: nullable,
+ }
+ if not {
+ if ch > 0 {
+ r.cc.addRange('\x00', ch-1)
+ }
+ if ch < 0xFFFF {
+ r.cc.addRange(ch+1, utf8.MaxRune)
+ }
+ } else {
+ r.cc.addRange(ch, ch)
+ }
+ return r
+}
+
+func (r *regexFc) getFirstChars() CharSet {
+ if r.caseInsensitive {
+ r.cc.addLowercase()
+ }
+
+ return r.cc
+}
+
+func (r *regexFc) addFC(fc regexFc, concatenate bool) bool {
+ if !r.cc.IsMergeable() || !fc.cc.IsMergeable() {
+ return false
+ }
+
+ if concatenate {
+ if !r.nullable {
+ return true
+ }
+
+ if !fc.nullable {
+ r.nullable = false
+ }
+ } else {
+ if fc.nullable {
+ r.nullable = true
+ }
+ }
+
+ r.caseInsensitive = r.caseInsensitive || fc.caseInsensitive
+ r.cc.addSet(fc.cc)
+
+ return true
+}
+
+// This is a related computation: it takes a RegexTree and computes the
+// leading substring if it sees one. It's quite trivial and gives up easily.
+func getPrefix(tree *RegexTree) *Prefix {
+ var concatNode *regexNode
+ nextChild := 0
+
+ curNode := tree.root
+
+ for {
+ switch curNode.t {
+ case ntConcatenate:
+ if len(curNode.children) > 0 {
+ concatNode = curNode
+ nextChild = 0
+ }
+
+ case ntGreedy, ntCapture:
+ curNode = curNode.children[0]
+ concatNode = nil
+ continue
+
+ case ntOneloop, ntOnelazy:
+ if curNode.m > 0 {
+ return &Prefix{
+ PrefixStr: repeat(curNode.ch, curNode.m),
+ CaseInsensitive: (curNode.options & IgnoreCase) != 0,
+ }
+ }
+ return nil
+
+ case ntOne:
+ return &Prefix{
+ PrefixStr: []rune{curNode.ch},
+ CaseInsensitive: (curNode.options & IgnoreCase) != 0,
+ }
+
+ case ntMulti:
+ return &Prefix{
+ PrefixStr: curNode.str,
+ CaseInsensitive: (curNode.options & IgnoreCase) != 0,
+ }
+
+ case ntBol, ntEol, ntBoundary, ntECMABoundary, ntBeginning, ntStart,
+ ntEndZ, ntEnd, ntEmpty, ntRequire, ntPrevent:
+
+ default:
+ return nil
+ }
+
+ if concatNode == nil || nextChild >= len(concatNode.children) {
+ return nil
+ }
+
+ curNode = concatNode.children[nextChild]
+ nextChild++
+ }
+}
+
+// repeat the rune r, c times... up to the max of MaxPrefixSize
+func repeat(r rune, c int) []rune {
+ if c > MaxPrefixSize {
+ c = MaxPrefixSize
+ }
+
+ ret := make([]rune, c)
+
+ // binary growth using copy for speed
+ ret[0] = r
+ bp := 1
+ for bp < len(ret) {
+ copy(ret[bp:], ret[:bp])
+ bp *= 2
+ }
+
+ return ret
+}
+
+// BmPrefix precomputes the Boyer-Moore
+// tables for fast string scanning. These tables allow
+// you to scan for the first occurrence of a string within
+// a large body of text without examining every character.
+// The performance of the heuristic depends on the actual
+// string and the text being searched, but usually, the longer
+// the string that is being searched for, the fewer characters
+// need to be examined.
+type BmPrefix struct {
+ positive []int
+ negativeASCII []int
+ negativeUnicode [][]int
+ pattern []rune
+ lowASCII rune
+ highASCII rune
+ rightToLeft bool
+ caseInsensitive bool
+}
+
+func newBmPrefix(pattern []rune, caseInsensitive, rightToLeft bool) *BmPrefix {
+
+ b := &BmPrefix{
+ rightToLeft: rightToLeft,
+ caseInsensitive: caseInsensitive,
+ pattern: pattern,
+ }
+
+ if caseInsensitive {
+ for i := 0; i < len(b.pattern); i++ {
+ // We do the ToLower character by character for consistency. With surrogate chars, doing
+ // a ToLower on the entire string could actually change the surrogate pair. This is more correct
+ // linguistically, but since Regex doesn't support surrogates, it's more important to be
+ // consistent.
+
+ b.pattern[i] = unicode.ToLower(b.pattern[i])
+ }
+ }
+
+ var beforefirst, last, bump int
+ var scan, match int
+
+ if !rightToLeft {
+ beforefirst = -1
+ last = len(b.pattern) - 1
+ bump = 1
+ } else {
+ beforefirst = len(b.pattern)
+ last = 0
+ bump = -1
+ }
+
+ // PART I - the good-suffix shift table
+ //
+ // compute the positive requirement:
+ // if char "i" is the first one from the right that doesn't match,
+ // then we know the matcher can advance by _positive[i].
+ //
+ // This algorithm is a simplified variant of the standard
+ // Boyer-Moore good suffix calculation.
+
+ b.positive = make([]int, len(b.pattern))
+
+ examine := last
+ ch := b.pattern[examine]
+ b.positive[examine] = bump
+ examine -= bump
+
+Outerloop:
+ for {
+ // find an internal char (examine) that matches the tail
+
+ for {
+ if examine == beforefirst {
+ break Outerloop
+ }
+ if b.pattern[examine] == ch {
+ break
+ }
+ examine -= bump
+ }
+
+ match = last
+ scan = examine
+
+ // find the length of the match
+ for {
+ if scan == beforefirst || b.pattern[match] != b.pattern[scan] {
+ // at the end of the match, note the difference in _positive
+ // this is not the length of the match, but the distance from the internal match
+ // to the tail suffix.
+ if b.positive[match] == 0 {
+ b.positive[match] = match - scan
+ }
+
+ // System.Diagnostics.Debug.WriteLine("Set positive[" + match + "] to " + (match - scan));
+
+ break
+ }
+
+ scan -= bump
+ match -= bump
+ }
+
+ examine -= bump
+ }
+
+ match = last - bump
+
+ // scan for the chars for which there are no shifts that yield a different candidate
+
+ // The inside of the if statement used to say
+ // "_positive[match] = last - beforefirst;"
+ // This is slightly less aggressive in how much we skip, but at worst it
+ // should mean a little more work rather than skipping a potential match.
+ for match != beforefirst {
+ if b.positive[match] == 0 {
+ b.positive[match] = bump
+ }
+
+ match -= bump
+ }
+
+ // PART II - the bad-character shift table
+ //
+ // compute the negative requirement:
+ // if char "ch" is the reject character when testing position "i",
+ // we can slide up by _negative[ch];
+ // (_negative[ch] = str.Length - 1 - str.LastIndexOf(ch))
+ //
+ // the lookup table is divided into ASCII and Unicode portions;
+ // only those parts of the Unicode 16-bit code set that actually
+ // appear in the string are in the table. (Maximum size with
+ // Unicode is 65K; ASCII only case is 512 bytes.)
+
+ b.negativeASCII = make([]int, 128)
+
+ for i := 0; i < len(b.negativeASCII); i++ {
+ b.negativeASCII[i] = last - beforefirst
+ }
+
+ b.lowASCII = 127
+ b.highASCII = 0
+
+ for examine = last; examine != beforefirst; examine -= bump {
+ ch = b.pattern[examine]
+
+ switch {
+ case ch < 128:
+ if b.lowASCII > ch {
+ b.lowASCII = ch
+ }
+
+ if b.highASCII < ch {
+ b.highASCII = ch
+ }
+
+ if b.negativeASCII[ch] == last-beforefirst {
+ b.negativeASCII[ch] = last - examine
+ }
+ case ch <= 0xffff:
+ i, j := ch>>8, ch&0xFF
+
+ if b.negativeUnicode == nil {
+ b.negativeUnicode = make([][]int, 256)
+ }
+
+ if b.negativeUnicode[i] == nil {
+ newarray := make([]int, 256)
+
+ for k := 0; k < len(newarray); k++ {
+ newarray[k] = last - beforefirst
+ }
+
+ if i == 0 {
+ copy(newarray, b.negativeASCII)
+ //TODO: this line needed?
+ b.negativeASCII = newarray
+ }
+
+ b.negativeUnicode[i] = newarray
+ }
+
+ if b.negativeUnicode[i][j] == last-beforefirst {
+ b.negativeUnicode[i][j] = last - examine
+ }
+ default:
+ // we can't do the filter because this algo doesn't support
+ // unicode chars >0xffff
+ return nil
+ }
+ }
+
+ return b
+}
+
+func (b *BmPrefix) String() string {
+ return string(b.pattern)
+}
+
+// Dump returns the contents of the filter as a human readable string
+func (b *BmPrefix) Dump(indent string) string {
+ buf := &bytes.Buffer{}
+
+ fmt.Fprintf(buf, "%sBM Pattern: %s\n%sPositive: ", indent, string(b.pattern), indent)
+ for i := 0; i < len(b.positive); i++ {
+ buf.WriteString(strconv.Itoa(b.positive[i]))
+ buf.WriteRune(' ')
+ }
+ buf.WriteRune('\n')
+
+ if b.negativeASCII != nil {
+ buf.WriteString(indent)
+ buf.WriteString("Negative table\n")
+ for i := 0; i < len(b.negativeASCII); i++ {
+ if b.negativeASCII[i] != len(b.pattern) {
+ fmt.Fprintf(buf, "%s %s %s\n", indent, Escape(string(rune(i))), strconv.Itoa(b.negativeASCII[i]))
+ }
+ }
+ }
+
+ return buf.String()
+}
+
+// Scan uses the Boyer-Moore algorithm to find the first occurrence
+// of the specified string within text, beginning at index, and
+// constrained within beglimit and endlimit.
+//
+// The direction and case-sensitivity of the match is determined
+// by the arguments to the RegexBoyerMoore constructor.
+func (b *BmPrefix) Scan(text []rune, index, beglimit, endlimit int) int {
+ var (
+ defadv, test, test2 int
+ match, startmatch, endmatch int
+ bump, advance int
+ chTest rune
+ unicodeLookup []int
+ )
+
+ if !b.rightToLeft {
+ defadv = len(b.pattern)
+ startmatch = len(b.pattern) - 1
+ endmatch = 0
+ test = index + defadv - 1
+ bump = 1
+ } else {
+ defadv = -len(b.pattern)
+ startmatch = 0
+ endmatch = -defadv - 1
+ test = index + defadv
+ bump = -1
+ }
+
+ chMatch := b.pattern[startmatch]
+
+ for {
+ if test >= endlimit || test < beglimit {
+ return -1
+ }
+
+ chTest = text[test]
+
+ if b.caseInsensitive {
+ chTest = unicode.ToLower(chTest)
+ }
+
+ if chTest != chMatch {
+ if chTest < 128 {
+ advance = b.negativeASCII[chTest]
+ } else if chTest < 0xffff && len(b.negativeUnicode) > 0 {
+ unicodeLookup = b.negativeUnicode[chTest>>8]
+ if len(unicodeLookup) > 0 {
+ advance = unicodeLookup[chTest&0xFF]
+ } else {
+ advance = defadv
+ }
+ } else {
+ advance = defadv
+ }
+
+ test += advance
+ } else { // if (chTest == chMatch)
+ test2 = test
+ match = startmatch
+
+ for {
+ if match == endmatch {
+ if b.rightToLeft {
+ return test2 + 1
+ } else {
+ return test2
+ }
+ }
+
+ match -= bump
+ test2 -= bump
+
+ chTest = text[test2]
+
+ if b.caseInsensitive {
+ chTest = unicode.ToLower(chTest)
+ }
+
+ if chTest != b.pattern[match] {
+ advance = b.positive[match]
+ if (chTest & 0xFF80) == 0 {
+ test2 = (match - startmatch) + b.negativeASCII[chTest]
+ } else if chTest < 0xffff && len(b.negativeUnicode) > 0 {
+ unicodeLookup = b.negativeUnicode[chTest>>8]
+ if len(unicodeLookup) > 0 {
+ test2 = (match - startmatch) + unicodeLookup[chTest&0xFF]
+ } else {
+ test += advance
+ break
+ }
+ } else {
+ test += advance
+ break
+ }
+
+ if b.rightToLeft {
+ if test2 < advance {
+ advance = test2
+ }
+ } else if test2 > advance {
+ advance = test2
+ }
+
+ test += advance
+ break
+ }
+ }
+ }
+ }
+}
+
+// When a regex is anchored, we can do a quick IsMatch test instead of a Scan
+func (b *BmPrefix) IsMatch(text []rune, index, beglimit, endlimit int) bool {
+ if !b.rightToLeft {
+ if index < beglimit || endlimit-index < len(b.pattern) {
+ return false
+ }
+
+ return b.matchPattern(text, index)
+ } else {
+ if index > endlimit || index-beglimit < len(b.pattern) {
+ return false
+ }
+
+ return b.matchPattern(text, index-len(b.pattern))
+ }
+}
+
+func (b *BmPrefix) matchPattern(text []rune, index int) bool {
+ if len(text)-index < len(b.pattern) {
+ return false
+ }
+
+ if b.caseInsensitive {
+ for i := 0; i < len(b.pattern); i++ {
+ //Debug.Assert(textinfo.ToLower(_pattern[i]) == _pattern[i], "pattern should be converted to lower case in constructor!");
+ if unicode.ToLower(text[index+i]) != b.pattern[i] {
+ return false
+ }
+ }
+ return true
+ } else {
+ for i := 0; i < len(b.pattern); i++ {
+ if text[index+i] != b.pattern[i] {
+ return false
+ }
+ }
+ return true
+ }
+}
+
+type AnchorLoc int16
+
+// where the regex can be pegged
+const (
+ AnchorBeginning AnchorLoc = 0x0001
+ AnchorBol = 0x0002
+ AnchorStart = 0x0004
+ AnchorEol = 0x0008
+ AnchorEndZ = 0x0010
+ AnchorEnd = 0x0020
+ AnchorBoundary = 0x0040
+ AnchorECMABoundary = 0x0080
+)
+
+func getAnchors(tree *RegexTree) AnchorLoc {
+
+ var concatNode *regexNode
+ nextChild, result := 0, AnchorLoc(0)
+
+ curNode := tree.root
+
+ for {
+ switch curNode.t {
+ case ntConcatenate:
+ if len(curNode.children) > 0 {
+ concatNode = curNode
+ nextChild = 0
+ }
+
+ case ntGreedy, ntCapture:
+ curNode = curNode.children[0]
+ concatNode = nil
+ continue
+
+ case ntBol, ntEol, ntBoundary, ntECMABoundary, ntBeginning,
+ ntStart, ntEndZ, ntEnd:
+ return result | anchorFromType(curNode.t)
+
+ case ntEmpty, ntRequire, ntPrevent:
+
+ default:
+ return result
+ }
+
+ if concatNode == nil || nextChild >= len(concatNode.children) {
+ return result
+ }
+
+ curNode = concatNode.children[nextChild]
+ nextChild++
+ }
+}
+
+func anchorFromType(t nodeType) AnchorLoc {
+ switch t {
+ case ntBol:
+ return AnchorBol
+ case ntEol:
+ return AnchorEol
+ case ntBoundary:
+ return AnchorBoundary
+ case ntECMABoundary:
+ return AnchorECMABoundary
+ case ntBeginning:
+ return AnchorBeginning
+ case ntStart:
+ return AnchorStart
+ case ntEndZ:
+ return AnchorEndZ
+ case ntEnd:
+ return AnchorEnd
+ default:
+ return 0
+ }
+}
+
+// anchorDescription returns a human-readable description of the anchors
+func (anchors AnchorLoc) String() string {
+ buf := &bytes.Buffer{}
+
+ if 0 != (anchors & AnchorBeginning) {
+ buf.WriteString(", Beginning")
+ }
+ if 0 != (anchors & AnchorStart) {
+ buf.WriteString(", Start")
+ }
+ if 0 != (anchors & AnchorBol) {
+ buf.WriteString(", Bol")
+ }
+ if 0 != (anchors & AnchorBoundary) {
+ buf.WriteString(", Boundary")
+ }
+ if 0 != (anchors & AnchorECMABoundary) {
+ buf.WriteString(", ECMABoundary")
+ }
+ if 0 != (anchors & AnchorEol) {
+ buf.WriteString(", Eol")
+ }
+ if 0 != (anchors & AnchorEnd) {
+ buf.WriteString(", End")
+ }
+ if 0 != (anchors & AnchorEndZ) {
+ buf.WriteString(", EndZ")
+ }
+
+ // trim off comma
+ if buf.Len() >= 2 {
+ return buf.String()[2:]
+ }
+ return "None"
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/replacerdata.go b/vendor/github.com/dlclark/regexp2/syntax/replacerdata.go
new file mode 100644
index 0000000..bcf4d3f
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/replacerdata.go
@@ -0,0 +1,87 @@
+package syntax
+
+import (
+ "bytes"
+ "errors"
+)
+
+type ReplacerData struct {
+ Rep string
+ Strings []string
+ Rules []int
+}
+
+const (
+ replaceSpecials = 4
+ replaceLeftPortion = -1
+ replaceRightPortion = -2
+ replaceLastGroup = -3
+ replaceWholeString = -4
+)
+
+//ErrReplacementError is a general error during parsing the replacement text
+var ErrReplacementError = errors.New("Replacement pattern error.")
+
+// NewReplacerData will populate a reusable replacer data struct based on the given replacement string
+// and the capture group data from a regexp
+func NewReplacerData(rep string, caps map[int]int, capsize int, capnames map[string]int, op RegexOptions) (*ReplacerData, error) {
+ p := parser{
+ options: op,
+ caps: caps,
+ capsize: capsize,
+ capnames: capnames,
+ }
+ p.setPattern(rep)
+ concat, err := p.scanReplacement()
+ if err != nil {
+ return nil, err
+ }
+
+ if concat.t != ntConcatenate {
+ panic(ErrReplacementError)
+ }
+
+ sb := &bytes.Buffer{}
+ var (
+ strings []string
+ rules []int
+ )
+
+ for _, child := range concat.children {
+ switch child.t {
+ case ntMulti:
+ child.writeStrToBuf(sb)
+
+ case ntOne:
+ sb.WriteRune(child.ch)
+
+ case ntRef:
+ if sb.Len() > 0 {
+ rules = append(rules, len(strings))
+ strings = append(strings, sb.String())
+ sb.Reset()
+ }
+ slot := child.m
+
+ if len(caps) > 0 && slot >= 0 {
+ slot = caps[slot]
+ }
+
+ rules = append(rules, -replaceSpecials-1-slot)
+
+ default:
+ panic(ErrReplacementError)
+ }
+ }
+
+ if sb.Len() > 0 {
+ rules = append(rules, len(strings))
+ strings = append(strings, sb.String())
+ }
+
+ return &ReplacerData{
+ Rep: rep,
+ Strings: strings,
+ Rules: rules,
+ }, nil
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/tree.go b/vendor/github.com/dlclark/regexp2/syntax/tree.go
new file mode 100644
index 0000000..ea28829
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/tree.go
@@ -0,0 +1,654 @@
+package syntax
+
+import (
+ "bytes"
+ "fmt"
+ "math"
+ "strconv"
+)
+
+type RegexTree struct {
+ root *regexNode
+ caps map[int]int
+ capnumlist []int
+ captop int
+ Capnames map[string]int
+ Caplist []string
+ options RegexOptions
+}
+
+// It is built into a parsed tree for a regular expression.
+
+// Implementation notes:
+//
+// Since the node tree is a temporary data structure only used
+// during compilation of the regexp to integer codes, it's
+// designed for clarity and convenience rather than
+// space efficiency.
+//
+// RegexNodes are built into a tree, linked by the n.children list.
+// Each node also has a n.parent and n.ichild member indicating
+// its parent and which child # it is in its parent's list.
+//
+// RegexNodes come in as many types as there are constructs in
+// a regular expression, for example, "concatenate", "alternate",
+// "one", "rept", "group". There are also node types for basic
+// peephole optimizations, e.g., "onerep", "notsetrep", etc.
+//
+// Because perl 5 allows "lookback" groups that scan backwards,
+// each node also gets a "direction". Normally the value of
+// boolean n.backward = false.
+//
+// During parsing, top-level nodes are also stacked onto a parse
+// stack (a stack of trees). For this purpose we have a n.next
+// pointer. [Note that to save a few bytes, we could overload the
+// n.parent pointer instead.]
+//
+// On the parse stack, each tree has a "role" - basically, the
+// nonterminal in the grammar that the parser has currently
+// assigned to the tree. That code is stored in n.role.
+//
+// Finally, some of the different kinds of nodes have data.
+// Two integers (for the looping constructs) are stored in
+// n.operands, an an object (either a string or a set)
+// is stored in n.data
+type regexNode struct {
+ t nodeType
+ children []*regexNode
+ str []rune
+ set *CharSet
+ ch rune
+ m int
+ n int
+ options RegexOptions
+ next *regexNode
+}
+
+type nodeType int32
+
+const (
+ // The following are leaves, and correspond to primitive operations
+
+ ntOnerep nodeType = 0 // lef,back char,min,max a {n}
+ ntNotonerep = 1 // lef,back char,min,max .{n}
+ ntSetrep = 2 // lef,back set,min,max [\d]{n}
+ ntOneloop = 3 // lef,back char,min,max a {,n}
+ ntNotoneloop = 4 // lef,back char,min,max .{,n}
+ ntSetloop = 5 // lef,back set,min,max [\d]{,n}
+ ntOnelazy = 6 // lef,back char,min,max a {,n}?
+ ntNotonelazy = 7 // lef,back char,min,max .{,n}?
+ ntSetlazy = 8 // lef,back set,min,max [\d]{,n}?
+ ntOne = 9 // lef char a
+ ntNotone = 10 // lef char [^a]
+ ntSet = 11 // lef set [a-z\s] \w \s \d
+ ntMulti = 12 // lef string abcd
+ ntRef = 13 // lef group \#
+ ntBol = 14 // ^
+ ntEol = 15 // $
+ ntBoundary = 16 // \b
+ ntNonboundary = 17 // \B
+ ntBeginning = 18 // \A
+ ntStart = 19 // \G
+ ntEndZ = 20 // \Z
+ ntEnd = 21 // \Z
+
+ // Interior nodes do not correspond to primitive operations, but
+ // control structures compositing other operations
+
+ // Concat and alternate take n children, and can run forward or backwards
+
+ ntNothing = 22 // []
+ ntEmpty = 23 // ()
+ ntAlternate = 24 // a|b
+ ntConcatenate = 25 // ab
+ ntLoop = 26 // m,x * + ? {,}
+ ntLazyloop = 27 // m,x *? +? ?? {,}?
+ ntCapture = 28 // n ()
+ ntGroup = 29 // (?:)
+ ntRequire = 30 // (?=) (?<=)
+ ntPrevent = 31 // (?!) (?) (?<)
+ ntTestref = 33 // (?(n) | )
+ ntTestgroup = 34 // (?(...) | )
+
+ ntECMABoundary = 41 // \b
+ ntNonECMABoundary = 42 // \B
+)
+
+func newRegexNode(t nodeType, opt RegexOptions) *regexNode {
+ return ®exNode{
+ t: t,
+ options: opt,
+ }
+}
+
+func newRegexNodeCh(t nodeType, opt RegexOptions, ch rune) *regexNode {
+ return ®exNode{
+ t: t,
+ options: opt,
+ ch: ch,
+ }
+}
+
+func newRegexNodeStr(t nodeType, opt RegexOptions, str []rune) *regexNode {
+ return ®exNode{
+ t: t,
+ options: opt,
+ str: str,
+ }
+}
+
+func newRegexNodeSet(t nodeType, opt RegexOptions, set *CharSet) *regexNode {
+ return ®exNode{
+ t: t,
+ options: opt,
+ set: set,
+ }
+}
+
+func newRegexNodeM(t nodeType, opt RegexOptions, m int) *regexNode {
+ return ®exNode{
+ t: t,
+ options: opt,
+ m: m,
+ }
+}
+func newRegexNodeMN(t nodeType, opt RegexOptions, m, n int) *regexNode {
+ return ®exNode{
+ t: t,
+ options: opt,
+ m: m,
+ n: n,
+ }
+}
+
+func (n *regexNode) writeStrToBuf(buf *bytes.Buffer) {
+ for i := 0; i < len(n.str); i++ {
+ buf.WriteRune(n.str[i])
+ }
+}
+
+func (n *regexNode) addChild(child *regexNode) {
+ reduced := child.reduce()
+ n.children = append(n.children, reduced)
+ reduced.next = n
+}
+
+func (n *regexNode) insertChildren(afterIndex int, nodes []*regexNode) {
+ newChildren := make([]*regexNode, 0, len(n.children)+len(nodes))
+ n.children = append(append(append(newChildren, n.children[:afterIndex]...), nodes...), n.children[afterIndex:]...)
+}
+
+// removes children including the start but not the end index
+func (n *regexNode) removeChildren(startIndex, endIndex int) {
+ n.children = append(n.children[:startIndex], n.children[endIndex:]...)
+}
+
+// Pass type as OneLazy or OneLoop
+func (n *regexNode) makeRep(t nodeType, min, max int) {
+ n.t += (t - ntOne)
+ n.m = min
+ n.n = max
+}
+
+func (n *regexNode) reduce() *regexNode {
+ switch n.t {
+ case ntAlternate:
+ return n.reduceAlternation()
+
+ case ntConcatenate:
+ return n.reduceConcatenation()
+
+ case ntLoop, ntLazyloop:
+ return n.reduceRep()
+
+ case ntGroup:
+ return n.reduceGroup()
+
+ case ntSet, ntSetloop:
+ return n.reduceSet()
+
+ default:
+ return n
+ }
+}
+
+// Basic optimization. Single-letter alternations can be replaced
+// by faster set specifications, and nested alternations with no
+// intervening operators can be flattened:
+//
+// a|b|c|def|g|h -> [a-c]|def|[gh]
+// apple|(?:orange|pear)|grape -> apple|orange|pear|grape
+func (n *regexNode) reduceAlternation() *regexNode {
+ if len(n.children) == 0 {
+ return newRegexNode(ntNothing, n.options)
+ }
+
+ wasLastSet := false
+ lastNodeCannotMerge := false
+ var optionsLast RegexOptions
+ var i, j int
+
+ for i, j = 0, 0; i < len(n.children); i, j = i+1, j+1 {
+ at := n.children[i]
+
+ if j < i {
+ n.children[j] = at
+ }
+
+ for {
+ if at.t == ntAlternate {
+ for k := 0; k < len(at.children); k++ {
+ at.children[k].next = n
+ }
+ n.insertChildren(i+1, at.children)
+
+ j--
+ } else if at.t == ntSet || at.t == ntOne {
+ // Cannot merge sets if L or I options differ, or if either are negated.
+ optionsAt := at.options & (RightToLeft | IgnoreCase)
+
+ if at.t == ntSet {
+ if !wasLastSet || optionsLast != optionsAt || lastNodeCannotMerge || !at.set.IsMergeable() {
+ wasLastSet = true
+ lastNodeCannotMerge = !at.set.IsMergeable()
+ optionsLast = optionsAt
+ break
+ }
+ } else if !wasLastSet || optionsLast != optionsAt || lastNodeCannotMerge {
+ wasLastSet = true
+ lastNodeCannotMerge = false
+ optionsLast = optionsAt
+ break
+ }
+
+ // The last node was a Set or a One, we're a Set or One and our options are the same.
+ // Merge the two nodes.
+ j--
+ prev := n.children[j]
+
+ var prevCharClass *CharSet
+ if prev.t == ntOne {
+ prevCharClass = &CharSet{}
+ prevCharClass.addChar(prev.ch)
+ } else {
+ prevCharClass = prev.set
+ }
+
+ if at.t == ntOne {
+ prevCharClass.addChar(at.ch)
+ } else {
+ prevCharClass.addSet(*at.set)
+ }
+
+ prev.t = ntSet
+ prev.set = prevCharClass
+ } else if at.t == ntNothing {
+ j--
+ } else {
+ wasLastSet = false
+ lastNodeCannotMerge = false
+ }
+ break
+ }
+ }
+
+ if j < i {
+ n.removeChildren(j, i)
+ }
+
+ return n.stripEnation(ntNothing)
+}
+
+// Basic optimization. Adjacent strings can be concatenated.
+//
+// (?:abc)(?:def) -> abcdef
+func (n *regexNode) reduceConcatenation() *regexNode {
+ // Eliminate empties and concat adjacent strings/chars
+
+ var optionsLast RegexOptions
+ var optionsAt RegexOptions
+ var i, j int
+
+ if len(n.children) == 0 {
+ return newRegexNode(ntEmpty, n.options)
+ }
+
+ wasLastString := false
+
+ for i, j = 0, 0; i < len(n.children); i, j = i+1, j+1 {
+ var at, prev *regexNode
+
+ at = n.children[i]
+
+ if j < i {
+ n.children[j] = at
+ }
+
+ if at.t == ntConcatenate &&
+ ((at.options & RightToLeft) == (n.options & RightToLeft)) {
+ for k := 0; k < len(at.children); k++ {
+ at.children[k].next = n
+ }
+
+ //insert at.children at i+1 index in n.children
+ n.insertChildren(i+1, at.children)
+
+ j--
+ } else if at.t == ntMulti || at.t == ntOne {
+ // Cannot merge strings if L or I options differ
+ optionsAt = at.options & (RightToLeft | IgnoreCase)
+
+ if !wasLastString || optionsLast != optionsAt {
+ wasLastString = true
+ optionsLast = optionsAt
+ continue
+ }
+
+ j--
+ prev = n.children[j]
+
+ if prev.t == ntOne {
+ prev.t = ntMulti
+ prev.str = []rune{prev.ch}
+ }
+
+ if (optionsAt & RightToLeft) == 0 {
+ if at.t == ntOne {
+ prev.str = append(prev.str, at.ch)
+ } else {
+ prev.str = append(prev.str, at.str...)
+ }
+ } else {
+ if at.t == ntOne {
+ // insert at the front by expanding our slice, copying the data over, and then setting the value
+ prev.str = append(prev.str, 0)
+ copy(prev.str[1:], prev.str)
+ prev.str[0] = at.ch
+ } else {
+ //insert at the front...this one we'll make a new slice and copy both into it
+ merge := make([]rune, len(prev.str)+len(at.str))
+ copy(merge, at.str)
+ copy(merge[len(at.str):], prev.str)
+ prev.str = merge
+ }
+ }
+ } else if at.t == ntEmpty {
+ j--
+ } else {
+ wasLastString = false
+ }
+ }
+
+ if j < i {
+ // remove indices j through i from the children
+ n.removeChildren(j, i)
+ }
+
+ return n.stripEnation(ntEmpty)
+}
+
+// Nested repeaters just get multiplied with each other if they're not
+// too lumpy
+func (n *regexNode) reduceRep() *regexNode {
+
+ u := n
+ t := n.t
+ min := n.m
+ max := n.n
+
+ for {
+ if len(u.children) == 0 {
+ break
+ }
+
+ child := u.children[0]
+
+ // multiply reps of the same type only
+ if child.t != t {
+ childType := child.t
+
+ if !(childType >= ntOneloop && childType <= ntSetloop && t == ntLoop ||
+ childType >= ntOnelazy && childType <= ntSetlazy && t == ntLazyloop) {
+ break
+ }
+ }
+
+ // child can be too lumpy to blur, e.g., (a {100,105}) {3} or (a {2,})?
+ // [but things like (a {2,})+ are not too lumpy...]
+ if u.m == 0 && child.m > 1 || child.n < child.m*2 {
+ break
+ }
+
+ u = child
+ if u.m > 0 {
+ if (math.MaxInt32-1)/u.m < min {
+ u.m = math.MaxInt32
+ } else {
+ u.m = u.m * min
+ }
+ }
+ if u.n > 0 {
+ if (math.MaxInt32-1)/u.n < max {
+ u.n = math.MaxInt32
+ } else {
+ u.n = u.n * max
+ }
+ }
+ }
+
+ if math.MaxInt32 == min {
+ return newRegexNode(ntNothing, n.options)
+ }
+ return u
+
+}
+
+// Simple optimization. If a concatenation or alternation has only
+// one child strip out the intermediate node. If it has zero children,
+// turn it into an empty.
+func (n *regexNode) stripEnation(emptyType nodeType) *regexNode {
+ switch len(n.children) {
+ case 0:
+ return newRegexNode(emptyType, n.options)
+ case 1:
+ return n.children[0]
+ default:
+ return n
+ }
+}
+
+func (n *regexNode) reduceGroup() *regexNode {
+ u := n
+
+ for u.t == ntGroup {
+ u = u.children[0]
+ }
+
+ return u
+}
+
+// Simple optimization. If a set is a singleton, an inverse singleton,
+// or empty, it's transformed accordingly.
+func (n *regexNode) reduceSet() *regexNode {
+ // Extract empty-set, one and not-one case as special
+
+ if n.set == nil {
+ n.t = ntNothing
+ } else if n.set.IsSingleton() {
+ n.ch = n.set.SingletonChar()
+ n.set = nil
+ n.t += (ntOne - ntSet)
+ } else if n.set.IsSingletonInverse() {
+ n.ch = n.set.SingletonChar()
+ n.set = nil
+ n.t += (ntNotone - ntSet)
+ }
+
+ return n
+}
+
+func (n *regexNode) reverseLeft() *regexNode {
+ if n.options&RightToLeft != 0 && n.t == ntConcatenate && len(n.children) > 0 {
+ //reverse children order
+ for left, right := 0, len(n.children)-1; left < right; left, right = left+1, right-1 {
+ n.children[left], n.children[right] = n.children[right], n.children[left]
+ }
+ }
+
+ return n
+}
+
+func (n *regexNode) makeQuantifier(lazy bool, min, max int) *regexNode {
+ if min == 0 && max == 0 {
+ return newRegexNode(ntEmpty, n.options)
+ }
+
+ if min == 1 && max == 1 {
+ return n
+ }
+
+ switch n.t {
+ case ntOne, ntNotone, ntSet:
+ if lazy {
+ n.makeRep(Onelazy, min, max)
+ } else {
+ n.makeRep(Oneloop, min, max)
+ }
+ return n
+
+ default:
+ var t nodeType
+ if lazy {
+ t = ntLazyloop
+ } else {
+ t = ntLoop
+ }
+ result := newRegexNodeMN(t, n.options, min, max)
+ result.addChild(n)
+ return result
+ }
+}
+
+// debug functions
+
+var typeStr = []string{
+ "Onerep", "Notonerep", "Setrep",
+ "Oneloop", "Notoneloop", "Setloop",
+ "Onelazy", "Notonelazy", "Setlazy",
+ "One", "Notone", "Set",
+ "Multi", "Ref",
+ "Bol", "Eol", "Boundary", "Nonboundary",
+ "Beginning", "Start", "EndZ", "End",
+ "Nothing", "Empty",
+ "Alternate", "Concatenate",
+ "Loop", "Lazyloop",
+ "Capture", "Group", "Require", "Prevent", "Greedy",
+ "Testref", "Testgroup",
+ "Unknown", "Unknown", "Unknown",
+ "Unknown", "Unknown", "Unknown",
+ "ECMABoundary", "NonECMABoundary",
+}
+
+func (n *regexNode) description() string {
+ buf := &bytes.Buffer{}
+
+ buf.WriteString(typeStr[n.t])
+
+ if (n.options & ExplicitCapture) != 0 {
+ buf.WriteString("-C")
+ }
+ if (n.options & IgnoreCase) != 0 {
+ buf.WriteString("-I")
+ }
+ if (n.options & RightToLeft) != 0 {
+ buf.WriteString("-L")
+ }
+ if (n.options & Multiline) != 0 {
+ buf.WriteString("-M")
+ }
+ if (n.options & Singleline) != 0 {
+ buf.WriteString("-S")
+ }
+ if (n.options & IgnorePatternWhitespace) != 0 {
+ buf.WriteString("-X")
+ }
+ if (n.options & ECMAScript) != 0 {
+ buf.WriteString("-E")
+ }
+
+ switch n.t {
+ case ntOneloop, ntNotoneloop, ntOnelazy, ntNotonelazy, ntOne, ntNotone:
+ buf.WriteString("(Ch = " + CharDescription(n.ch) + ")")
+ break
+ case ntCapture:
+ buf.WriteString("(index = " + strconv.Itoa(n.m) + ", unindex = " + strconv.Itoa(n.n) + ")")
+ break
+ case ntRef, ntTestref:
+ buf.WriteString("(index = " + strconv.Itoa(n.m) + ")")
+ break
+ case ntMulti:
+ fmt.Fprintf(buf, "(String = %s)", string(n.str))
+ break
+ case ntSet, ntSetloop, ntSetlazy:
+ buf.WriteString("(Set = " + n.set.String() + ")")
+ break
+ }
+
+ switch n.t {
+ case ntOneloop, ntNotoneloop, ntOnelazy, ntNotonelazy, ntSetloop, ntSetlazy, ntLoop, ntLazyloop:
+ buf.WriteString("(Min = ")
+ buf.WriteString(strconv.Itoa(n.m))
+ buf.WriteString(", Max = ")
+ if n.n == math.MaxInt32 {
+ buf.WriteString("inf")
+ } else {
+ buf.WriteString(strconv.Itoa(n.n))
+ }
+ buf.WriteString(")")
+
+ break
+ }
+
+ return buf.String()
+}
+
+var padSpace = []byte(" ")
+
+func (t *RegexTree) Dump() string {
+ return t.root.dump()
+}
+
+func (n *regexNode) dump() string {
+ var stack []int
+ CurNode := n
+ CurChild := 0
+
+ buf := bytes.NewBufferString(CurNode.description())
+ buf.WriteRune('\n')
+
+ for {
+ if CurNode.children != nil && CurChild < len(CurNode.children) {
+ stack = append(stack, CurChild+1)
+ CurNode = CurNode.children[CurChild]
+ CurChild = 0
+
+ Depth := len(stack)
+ if Depth > 32 {
+ Depth = 32
+ }
+ buf.Write(padSpace[:Depth])
+ buf.WriteString(CurNode.description())
+ buf.WriteRune('\n')
+ } else {
+ if len(stack) == 0 {
+ break
+ }
+
+ CurChild = stack[len(stack)-1]
+ stack = stack[:len(stack)-1]
+ CurNode = CurNode.next
+ }
+ }
+ return buf.String()
+}
diff --git a/vendor/github.com/dlclark/regexp2/syntax/writer.go b/vendor/github.com/dlclark/regexp2/syntax/writer.go
new file mode 100644
index 0000000..a5aa11c
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/syntax/writer.go
@@ -0,0 +1,500 @@
+package syntax
+
+import (
+ "bytes"
+ "fmt"
+ "math"
+ "os"
+)
+
+func Write(tree *RegexTree) (*Code, error) {
+ w := writer{
+ intStack: make([]int, 0, 32),
+ emitted: make([]int, 2),
+ stringhash: make(map[string]int),
+ sethash: make(map[string]int),
+ }
+
+ code, err := w.codeFromTree(tree)
+
+ if tree.options&Debug > 0 && code != nil {
+ os.Stdout.WriteString(code.Dump())
+ os.Stdout.WriteString("\n")
+ }
+
+ return code, err
+}
+
+type writer struct {
+ emitted []int
+
+ intStack []int
+ curpos int
+ stringhash map[string]int
+ stringtable [][]rune
+ sethash map[string]int
+ settable []*CharSet
+ counting bool
+ count int
+ trackcount int
+ caps map[int]int
+}
+
+const (
+ beforeChild nodeType = 64
+ afterChild = 128
+ //MaxPrefixSize is the largest number of runes we'll use for a BoyerMoyer prefix
+ MaxPrefixSize = 50
+)
+
+// The top level RegexCode generator. It does a depth-first walk
+// through the tree and calls EmitFragment to emits code before
+// and after each child of an interior node, and at each leaf.
+//
+// It runs two passes, first to count the size of the generated
+// code, and second to generate the code.
+//
+// We should time it against the alternative, which is
+// to just generate the code and grow the array as we go.
+func (w *writer) codeFromTree(tree *RegexTree) (*Code, error) {
+ var (
+ curNode *regexNode
+ curChild int
+ capsize int
+ )
+ // construct sparse capnum mapping if some numbers are unused
+
+ if tree.capnumlist == nil || tree.captop == len(tree.capnumlist) {
+ capsize = tree.captop
+ w.caps = nil
+ } else {
+ capsize = len(tree.capnumlist)
+ w.caps = tree.caps
+ for i := 0; i < len(tree.capnumlist); i++ {
+ w.caps[tree.capnumlist[i]] = i
+ }
+ }
+
+ w.counting = true
+
+ for {
+ if !w.counting {
+ w.emitted = make([]int, w.count)
+ }
+
+ curNode = tree.root
+ curChild = 0
+
+ w.emit1(Lazybranch, 0)
+
+ for {
+ if len(curNode.children) == 0 {
+ w.emitFragment(curNode.t, curNode, 0)
+ } else if curChild < len(curNode.children) {
+ w.emitFragment(curNode.t|beforeChild, curNode, curChild)
+
+ curNode = curNode.children[curChild]
+
+ w.pushInt(curChild)
+ curChild = 0
+ continue
+ }
+
+ if w.emptyStack() {
+ break
+ }
+
+ curChild = w.popInt()
+ curNode = curNode.next
+
+ w.emitFragment(curNode.t|afterChild, curNode, curChild)
+ curChild++
+ }
+
+ w.patchJump(0, w.curPos())
+ w.emit(Stop)
+
+ if !w.counting {
+ break
+ }
+
+ w.counting = false
+ }
+
+ fcPrefix := getFirstCharsPrefix(tree)
+ prefix := getPrefix(tree)
+ rtl := (tree.options & RightToLeft) != 0
+
+ var bmPrefix *BmPrefix
+ //TODO: benchmark string prefixes
+ if prefix != nil && len(prefix.PrefixStr) > 0 && MaxPrefixSize > 0 {
+ if len(prefix.PrefixStr) > MaxPrefixSize {
+ // limit prefix changes to 10k
+ prefix.PrefixStr = prefix.PrefixStr[:MaxPrefixSize]
+ }
+ bmPrefix = newBmPrefix(prefix.PrefixStr, prefix.CaseInsensitive, rtl)
+ } else {
+ bmPrefix = nil
+ }
+
+ return &Code{
+ Codes: w.emitted,
+ Strings: w.stringtable,
+ Sets: w.settable,
+ TrackCount: w.trackcount,
+ Caps: w.caps,
+ Capsize: capsize,
+ FcPrefix: fcPrefix,
+ BmPrefix: bmPrefix,
+ Anchors: getAnchors(tree),
+ RightToLeft: rtl,
+ }, nil
+}
+
+// The main RegexCode generator. It does a depth-first walk
+// through the tree and calls EmitFragment to emits code before
+// and after each child of an interior node, and at each leaf.
+func (w *writer) emitFragment(nodetype nodeType, node *regexNode, curIndex int) error {
+ bits := InstOp(0)
+
+ if nodetype <= ntRef {
+ if (node.options & RightToLeft) != 0 {
+ bits |= Rtl
+ }
+ if (node.options & IgnoreCase) != 0 {
+ bits |= Ci
+ }
+ }
+ ntBits := nodeType(bits)
+
+ switch nodetype {
+ case ntConcatenate | beforeChild, ntConcatenate | afterChild, ntEmpty:
+ break
+
+ case ntAlternate | beforeChild:
+ if curIndex < len(node.children)-1 {
+ w.pushInt(w.curPos())
+ w.emit1(Lazybranch, 0)
+ }
+
+ case ntAlternate | afterChild:
+ if curIndex < len(node.children)-1 {
+ lbPos := w.popInt()
+ w.pushInt(w.curPos())
+ w.emit1(Goto, 0)
+ w.patchJump(lbPos, w.curPos())
+ } else {
+ for i := 0; i < curIndex; i++ {
+ w.patchJump(w.popInt(), w.curPos())
+ }
+ }
+ break
+
+ case ntTestref | beforeChild:
+ if curIndex == 0 {
+ w.emit(Setjump)
+ w.pushInt(w.curPos())
+ w.emit1(Lazybranch, 0)
+ w.emit1(Testref, w.mapCapnum(node.m))
+ w.emit(Forejump)
+ }
+
+ case ntTestref | afterChild:
+ if curIndex == 0 {
+ branchpos := w.popInt()
+ w.pushInt(w.curPos())
+ w.emit1(Goto, 0)
+ w.patchJump(branchpos, w.curPos())
+ w.emit(Forejump)
+ if len(node.children) <= 1 {
+ w.patchJump(w.popInt(), w.curPos())
+ }
+ } else if curIndex == 1 {
+ w.patchJump(w.popInt(), w.curPos())
+ }
+
+ case ntTestgroup | beforeChild:
+ if curIndex == 0 {
+ w.emit(Setjump)
+ w.emit(Setmark)
+ w.pushInt(w.curPos())
+ w.emit1(Lazybranch, 0)
+ }
+
+ case ntTestgroup | afterChild:
+ if curIndex == 0 {
+ w.emit(Getmark)
+ w.emit(Forejump)
+ } else if curIndex == 1 {
+ Branchpos := w.popInt()
+ w.pushInt(w.curPos())
+ w.emit1(Goto, 0)
+ w.patchJump(Branchpos, w.curPos())
+ w.emit(Getmark)
+ w.emit(Forejump)
+ if len(node.children) <= 2 {
+ w.patchJump(w.popInt(), w.curPos())
+ }
+ } else if curIndex == 2 {
+ w.patchJump(w.popInt(), w.curPos())
+ }
+
+ case ntLoop | beforeChild, ntLazyloop | beforeChild:
+
+ if node.n < math.MaxInt32 || node.m > 1 {
+ if node.m == 0 {
+ w.emit1(Nullcount, 0)
+ } else {
+ w.emit1(Setcount, 1-node.m)
+ }
+ } else if node.m == 0 {
+ w.emit(Nullmark)
+ } else {
+ w.emit(Setmark)
+ }
+
+ if node.m == 0 {
+ w.pushInt(w.curPos())
+ w.emit1(Goto, 0)
+ }
+ w.pushInt(w.curPos())
+
+ case ntLoop | afterChild, ntLazyloop | afterChild:
+
+ startJumpPos := w.curPos()
+ lazy := (nodetype - (ntLoop | afterChild))
+
+ if node.n < math.MaxInt32 || node.m > 1 {
+ if node.n == math.MaxInt32 {
+ w.emit2(InstOp(Branchcount+lazy), w.popInt(), math.MaxInt32)
+ } else {
+ w.emit2(InstOp(Branchcount+lazy), w.popInt(), node.n-node.m)
+ }
+ } else {
+ w.emit1(InstOp(Branchmark+lazy), w.popInt())
+ }
+
+ if node.m == 0 {
+ w.patchJump(w.popInt(), startJumpPos)
+ }
+
+ case ntGroup | beforeChild, ntGroup | afterChild:
+
+ case ntCapture | beforeChild:
+ w.emit(Setmark)
+
+ case ntCapture | afterChild:
+ w.emit2(Capturemark, w.mapCapnum(node.m), w.mapCapnum(node.n))
+
+ case ntRequire | beforeChild:
+ // NOTE: the following line causes lookahead/lookbehind to be
+ // NON-BACKTRACKING. It can be commented out with (*)
+ w.emit(Setjump)
+
+ w.emit(Setmark)
+
+ case ntRequire | afterChild:
+ w.emit(Getmark)
+
+ // NOTE: the following line causes lookahead/lookbehind to be
+ // NON-BACKTRACKING. It can be commented out with (*)
+ w.emit(Forejump)
+
+ case ntPrevent | beforeChild:
+ w.emit(Setjump)
+ w.pushInt(w.curPos())
+ w.emit1(Lazybranch, 0)
+
+ case ntPrevent | afterChild:
+ w.emit(Backjump)
+ w.patchJump(w.popInt(), w.curPos())
+ w.emit(Forejump)
+
+ case ntGreedy | beforeChild:
+ w.emit(Setjump)
+
+ case ntGreedy | afterChild:
+ w.emit(Forejump)
+
+ case ntOne, ntNotone:
+ w.emit1(InstOp(node.t|ntBits), int(node.ch))
+
+ case ntNotoneloop, ntNotonelazy, ntOneloop, ntOnelazy:
+ if node.m > 0 {
+ if node.t == ntOneloop || node.t == ntOnelazy {
+ w.emit2(Onerep|bits, int(node.ch), node.m)
+ } else {
+ w.emit2(Notonerep|bits, int(node.ch), node.m)
+ }
+ }
+ if node.n > node.m {
+ if node.n == math.MaxInt32 {
+ w.emit2(InstOp(node.t|ntBits), int(node.ch), math.MaxInt32)
+ } else {
+ w.emit2(InstOp(node.t|ntBits), int(node.ch), node.n-node.m)
+ }
+ }
+
+ case ntSetloop, ntSetlazy:
+ if node.m > 0 {
+ w.emit2(Setrep|bits, w.setCode(node.set), node.m)
+ }
+ if node.n > node.m {
+ if node.n == math.MaxInt32 {
+ w.emit2(InstOp(node.t|ntBits), w.setCode(node.set), math.MaxInt32)
+ } else {
+ w.emit2(InstOp(node.t|ntBits), w.setCode(node.set), node.n-node.m)
+ }
+ }
+
+ case ntMulti:
+ w.emit1(InstOp(node.t|ntBits), w.stringCode(node.str))
+
+ case ntSet:
+ w.emit1(InstOp(node.t|ntBits), w.setCode(node.set))
+
+ case ntRef:
+ w.emit1(InstOp(node.t|ntBits), w.mapCapnum(node.m))
+
+ case ntNothing, ntBol, ntEol, ntBoundary, ntNonboundary, ntECMABoundary, ntNonECMABoundary, ntBeginning, ntStart, ntEndZ, ntEnd:
+ w.emit(InstOp(node.t))
+
+ default:
+ return fmt.Errorf("unexpected opcode in regular expression generation: %v", nodetype)
+ }
+
+ return nil
+}
+
+// To avoid recursion, we use a simple integer stack.
+// This is the push.
+func (w *writer) pushInt(i int) {
+ w.intStack = append(w.intStack, i)
+}
+
+// Returns true if the stack is empty.
+func (w *writer) emptyStack() bool {
+ return len(w.intStack) == 0
+}
+
+// This is the pop.
+func (w *writer) popInt() int {
+ //get our item
+ idx := len(w.intStack) - 1
+ i := w.intStack[idx]
+ //trim our slice
+ w.intStack = w.intStack[:idx]
+ return i
+}
+
+// Returns the current position in the emitted code.
+func (w *writer) curPos() int {
+ return w.curpos
+}
+
+// Fixes up a jump instruction at the specified offset
+// so that it jumps to the specified jumpDest.
+func (w *writer) patchJump(offset, jumpDest int) {
+ w.emitted[offset+1] = jumpDest
+}
+
+// Returns an index in the set table for a charset
+// uses a map to eliminate duplicates.
+func (w *writer) setCode(set *CharSet) int {
+ if w.counting {
+ return 0
+ }
+
+ buf := &bytes.Buffer{}
+
+ set.mapHashFill(buf)
+ hash := buf.String()
+ i, ok := w.sethash[hash]
+ if !ok {
+ i = len(w.sethash)
+ w.sethash[hash] = i
+ w.settable = append(w.settable, set)
+ }
+ return i
+}
+
+// Returns an index in the string table for a string.
+// uses a map to eliminate duplicates.
+func (w *writer) stringCode(str []rune) int {
+ if w.counting {
+ return 0
+ }
+
+ hash := string(str)
+ i, ok := w.stringhash[hash]
+ if !ok {
+ i = len(w.stringhash)
+ w.stringhash[hash] = i
+ w.stringtable = append(w.stringtable, str)
+ }
+
+ return i
+}
+
+// When generating code on a regex that uses a sparse set
+// of capture slots, we hash them to a dense set of indices
+// for an array of capture slots. Instead of doing the hash
+// at match time, it's done at compile time, here.
+func (w *writer) mapCapnum(capnum int) int {
+ if capnum == -1 {
+ return -1
+ }
+
+ if w.caps != nil {
+ return w.caps[capnum]
+ }
+
+ return capnum
+}
+
+// Emits a zero-argument operation. Note that the emit
+// functions all run in two modes: they can emit code, or
+// they can just count the size of the code.
+func (w *writer) emit(op InstOp) {
+ if w.counting {
+ w.count++
+ if opcodeBacktracks(op) {
+ w.trackcount++
+ }
+ return
+ }
+ w.emitted[w.curpos] = int(op)
+ w.curpos++
+}
+
+// Emits a one-argument operation.
+func (w *writer) emit1(op InstOp, opd1 int) {
+ if w.counting {
+ w.count += 2
+ if opcodeBacktracks(op) {
+ w.trackcount++
+ }
+ return
+ }
+ w.emitted[w.curpos] = int(op)
+ w.curpos++
+ w.emitted[w.curpos] = opd1
+ w.curpos++
+}
+
+// Emits a two-argument operation.
+func (w *writer) emit2(op InstOp, opd1, opd2 int) {
+ if w.counting {
+ w.count += 3
+ if opcodeBacktracks(op) {
+ w.trackcount++
+ }
+ return
+ }
+ w.emitted[w.curpos] = int(op)
+ w.curpos++
+ w.emitted[w.curpos] = opd1
+ w.curpos++
+ w.emitted[w.curpos] = opd2
+ w.curpos++
+}
diff --git a/vendor/github.com/dlclark/regexp2/testoutput1 b/vendor/github.com/dlclark/regexp2/testoutput1
new file mode 100644
index 0000000..fbf63fd
--- /dev/null
+++ b/vendor/github.com/dlclark/regexp2/testoutput1
@@ -0,0 +1,7061 @@
+# This set of tests is for features that are compatible with all versions of
+# Perl >= 5.10, in non-UTF mode. It should run clean for the 8-bit, 16-bit, and
+# 32-bit PCRE libraries, and also using the perltest.pl script.
+
+#forbid_utf
+#newline_default lf any anycrlf
+#perltest
+
+/the quick brown fox/
+ the quick brown fox
+ 0: the quick brown fox
+ What do you know about the quick brown fox?
+ 0: the quick brown fox
+\= Expect no match
+ The quick brown FOX
+No match
+ What do you know about THE QUICK BROWN FOX?
+No match
+
+/The quick brown fox/i
+ the quick brown fox
+ 0: the quick brown fox
+ The quick brown FOX
+ 0: The quick brown FOX
+ What do you know about the quick brown fox?
+ 0: the quick brown fox
+ What do you know about THE QUICK BROWN FOX?
+ 0: THE QUICK BROWN FOX
+
+/abcd\t\n\r\f\a\e\071\x3b\$\\\?caxyz/
+ abcd\t\n\r\f\a\e9;\$\\?caxyz
+ 0: abcd\x09\x0a\x0d\x0c\x07\x1b9;$\?caxyz
+
+/a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/
+ abxyzpqrrrabbxyyyypqAzz
+ 0: abxyzpqrrrabbxyyyypqAzz
+ abxyzpqrrrabbxyyyypqAzz
+ 0: abxyzpqrrrabbxyyyypqAzz
+ aabxyzpqrrrabbxyyyypqAzz
+ 0: aabxyzpqrrrabbxyyyypqAzz
+ aaabxyzpqrrrabbxyyyypqAzz
+ 0: aaabxyzpqrrrabbxyyyypqAzz
+ aaaabxyzpqrrrabbxyyyypqAzz
+ 0: aaaabxyzpqrrrabbxyyyypqAzz
+ abcxyzpqrrrabbxyyyypqAzz
+ 0: abcxyzpqrrrabbxyyyypqAzz
+ aabcxyzpqrrrabbxyyyypqAzz
+ 0: aabcxyzpqrrrabbxyyyypqAzz
+ aaabcxyzpqrrrabbxyyyypAzz
+ 0: aaabcxyzpqrrrabbxyyyypAzz
+ aaabcxyzpqrrrabbxyyyypqAzz
+ 0: aaabcxyzpqrrrabbxyyyypqAzz
+ aaabcxyzpqrrrabbxyyyypqqAzz
+ 0: aaabcxyzpqrrrabbxyyyypqqAzz
+ aaabcxyzpqrrrabbxyyyypqqqAzz
+ 0: aaabcxyzpqrrrabbxyyyypqqqAzz
+ aaabcxyzpqrrrabbxyyyypqqqqAzz
+ 0: aaabcxyzpqrrrabbxyyyypqqqqAzz
+ aaabcxyzpqrrrabbxyyyypqqqqqAzz
+ 0: aaabcxyzpqrrrabbxyyyypqqqqqAzz
+ aaabcxyzpqrrrabbxyyyypqqqqqqAzz
+ 0: aaabcxyzpqrrrabbxyyyypqqqqqqAzz
+ aaaabcxyzpqrrrabbxyyyypqAzz
+ 0: aaaabcxyzpqrrrabbxyyyypqAzz
+ abxyzzpqrrrabbxyyyypqAzz
+ 0: abxyzzpqrrrabbxyyyypqAzz
+ aabxyzzzpqrrrabbxyyyypqAzz
+ 0: aabxyzzzpqrrrabbxyyyypqAzz
+ aaabxyzzzzpqrrrabbxyyyypqAzz
+ 0: aaabxyzzzzpqrrrabbxyyyypqAzz
+ aaaabxyzzzzpqrrrabbxyyyypqAzz
+ 0: aaaabxyzzzzpqrrrabbxyyyypqAzz
+ abcxyzzpqrrrabbxyyyypqAzz
+ 0: abcxyzzpqrrrabbxyyyypqAzz
+ aabcxyzzzpqrrrabbxyyyypqAzz
+ 0: aabcxyzzzpqrrrabbxyyyypqAzz
+ aaabcxyzzzzpqrrrabbxyyyypqAzz
+ 0: aaabcxyzzzzpqrrrabbxyyyypqAzz
+ aaaabcxyzzzzpqrrrabbxyyyypqAzz
+ 0: aaaabcxyzzzzpqrrrabbxyyyypqAzz
+ aaaabcxyzzzzpqrrrabbbxyyyypqAzz
+ 0: aaaabcxyzzzzpqrrrabbbxyyyypqAzz
+ aaaabcxyzzzzpqrrrabbbxyyyyypqAzz
+ 0: aaaabcxyzzzzpqrrrabbbxyyyyypqAzz
+ aaabcxyzpqrrrabbxyyyypABzz
+ 0: aaabcxyzpqrrrabbxyyyypABzz
+ aaabcxyzpqrrrabbxyyyypABBzz
+ 0: aaabcxyzpqrrrabbxyyyypABBzz
+ >>>aaabxyzpqrrrabbxyyyypqAzz
+ 0: aaabxyzpqrrrabbxyyyypqAzz
+ >aaaabxyzpqrrrabbxyyyypqAzz
+ 0: aaaabxyzpqrrrabbxyyyypqAzz
+ >>>>abcxyzpqrrrabbxyyyypqAzz
+ 0: abcxyzpqrrrabbxyyyypqAzz
+\= Expect no match
+ abxyzpqrrabbxyyyypqAzz
+No match
+ abxyzpqrrrrabbxyyyypqAzz
+No match
+ abxyzpqrrrabxyyyypqAzz
+No match
+ aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz
+No match
+ aaaabcxyzzzzpqrrrabbbxyyypqAzz
+No match
+ aaabcxyzpqrrrabbxyyyypqqqqqqqAzz
+No match
+
+/^(abc){1,2}zz/
+ abczz
+ 0: abczz
+ 1: abc
+ abcabczz
+ 0: abcabczz
+ 1: abc
+\= Expect no match
+ zz
+No match
+ abcabcabczz
+No match
+ >>abczz
+No match
+
+/^(b+?|a){1,2}?c/
+ bc
+ 0: bc
+ 1: b
+ bbc
+ 0: bbc
+ 1: b
+ bbbc
+ 0: bbbc
+ 1: bb
+ bac
+ 0: bac
+ 1: a
+ bbac
+ 0: bbac
+ 1: a
+ aac
+ 0: aac
+ 1: a
+ abbbbbbbbbbbc
+ 0: abbbbbbbbbbbc
+ 1: bbbbbbbbbbb
+ bbbbbbbbbbbac
+ 0: bbbbbbbbbbbac
+ 1: a
+\= Expect no match
+ aaac
+No match
+ abbbbbbbbbbbac
+No match
+
+/^(b+|a){1,2}c/
+ bc
+ 0: bc
+ 1: b
+ bbc
+ 0: bbc
+ 1: bb
+ bbbc
+ 0: bbbc
+ 1: bbb
+ bac
+ 0: bac
+ 1: a
+ bbac
+ 0: bbac
+ 1: a
+ aac
+ 0: aac
+ 1: a
+ abbbbbbbbbbbc
+ 0: abbbbbbbbbbbc
+ 1: bbbbbbbbbbb
+ bbbbbbbbbbbac
+ 0: bbbbbbbbbbbac
+ 1: a
+\= Expect no match
+ aaac
+No match
+ abbbbbbbbbbbac
+No match
+
+/^(b+|a){1,2}?bc/
+ bbc
+ 0: bbc
+ 1: b
+
+/^(b*|ba){1,2}?bc/
+ babc
+ 0: babc
+ 1: ba
+ bbabc
+ 0: bbabc
+ 1: ba
+ bababc
+ 0: bababc
+ 1: ba
+\= Expect no match
+ bababbc
+No match
+ babababc
+No match
+
+/^(ba|b*){1,2}?bc/
+ babc
+ 0: babc
+ 1: ba
+ bbabc
+ 0: bbabc
+ 1: ba
+ bababc
+ 0: bababc
+ 1: ba
+\= Expect no match
+ bababbc
+No match
+ babababc
+No match
+
+#/^\ca\cA\c[;\c:/
+# \x01\x01\e;z
+# 0: \x01\x01\x1b;z
+
+/^[ab\]cde]/
+ athing
+ 0: a
+ bthing
+ 0: b
+ ]thing
+ 0: ]
+ cthing
+ 0: c
+ dthing
+ 0: d
+ ething
+ 0: e
+\= Expect no match
+ fthing
+No match
+ [thing
+No match
+ \\thing
+No match
+
+/^[]cde]/
+ ]thing
+ 0: ]
+ cthing
+ 0: c
+ dthing
+ 0: d
+ ething
+ 0: e
+\= Expect no match
+ athing
+No match
+ fthing
+No match
+
+/^[^ab\]cde]/
+ fthing
+ 0: f
+ [thing
+ 0: [
+ \\thing
+ 0: \
+\= Expect no match
+ athing
+No match
+ bthing
+No match
+ ]thing
+No match
+ cthing
+No match
+ dthing
+No match
+ ething
+No match
+
+/^[^]cde]/
+ athing
+ 0: a
+ fthing
+ 0: f
+\= Expect no match
+ ]thing
+No match
+ cthing
+No match
+ dthing
+No match
+ ething
+No match
+
+# DLC - I don't get this one
+#/^\/
+#
+# 0: \x81
+
+#updated to handle 16-bits utf8
+/^ÿ/
+ ÿ
+ 0: \xc3\xbf
+
+/^[0-9]+$/
+ 0
+ 0: 0
+ 1
+ 0: 1
+ 2
+ 0: 2
+ 3
+ 0: 3
+ 4
+ 0: 4
+ 5
+ 0: 5
+ 6
+ 0: 6
+ 7
+ 0: 7
+ 8
+ 0: 8
+ 9
+ 0: 9
+ 10
+ 0: 10
+ 100
+ 0: 100
+\= Expect no match
+ abc
+No match
+
+/^.*nter/
+ enter
+ 0: enter
+ inter
+ 0: inter
+ uponter
+ 0: uponter
+
+/^xxx[0-9]+$/
+ xxx0
+ 0: xxx0
+ xxx1234
+ 0: xxx1234
+\= Expect no match
+ xxx
+No match
+
+/^.+[0-9][0-9][0-9]$/
+ x123
+ 0: x123
+ x1234
+ 0: x1234
+ xx123
+ 0: xx123
+ 123456
+ 0: 123456
+\= Expect no match
+ 123
+No match
+
+/^.+?[0-9][0-9][0-9]$/
+ x123
+ 0: x123
+ x1234
+ 0: x1234
+ xx123
+ 0: xx123
+ 123456
+ 0: 123456
+\= Expect no match
+ 123
+No match
+
+/^([^!]+)!(.+)=apquxz\.ixr\.zzz\.ac\.uk$/
+ abc!pqr=apquxz.ixr.zzz.ac.uk
+ 0: abc!pqr=apquxz.ixr.zzz.ac.uk
+ 1: abc
+ 2: pqr
+\= Expect no match
+ !pqr=apquxz.ixr.zzz.ac.uk
+No match
+ abc!=apquxz.ixr.zzz.ac.uk
+No match
+ abc!pqr=apquxz:ixr.zzz.ac.uk
+No match
+ abc!pqr=apquxz.ixr.zzz.ac.ukk
+No match
+
+/:/
+ Well, we need a colon: somewhere
+ 0: :
+\= Expect no match
+ Fail without a colon
+No match
+
+/([\da-f:]+)$/i
+ 0abc
+ 0: 0abc
+ 1: 0abc
+ abc
+ 0: abc
+ 1: abc
+ fed
+ 0: fed
+ 1: fed
+ E
+ 0: E
+ 1: E
+ ::
+ 0: ::
+ 1: ::
+ 5f03:12C0::932e
+ 0: 5f03:12C0::932e
+ 1: 5f03:12C0::932e
+ fed def
+ 0: def
+ 1: def
+ Any old stuff
+ 0: ff
+ 1: ff
+\= Expect no match
+ 0zzz
+No match
+ gzzz
+No match
+ fed\x20
+No match
+ Any old rubbish
+No match
+
+/^.*\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
+ .1.2.3
+ 0: .1.2.3
+ 1: 1
+ 2: 2
+ 3: 3
+ A.12.123.0
+ 0: A.12.123.0
+ 1: 12
+ 2: 123
+ 3: 0
+\= Expect no match
+ .1.2.3333
+No match
+ 1.2.3
+No match
+ 1234.2.3
+No match
+
+/^(\d+)\s+IN\s+SOA\s+(\S+)\s+(\S+)\s*\(\s*$/
+ 1 IN SOA non-sp1 non-sp2(
+ 0: 1 IN SOA non-sp1 non-sp2(
+ 1: 1
+ 2: non-sp1
+ 3: non-sp2
+ 1 IN SOA non-sp1 non-sp2 (
+ 0: 1 IN SOA non-sp1 non-sp2 (
+ 1: 1
+ 2: non-sp1
+ 3: non-sp2
+\= Expect no match
+ 1IN SOA non-sp1 non-sp2(
+No match
+
+/^[a-zA-Z\d][a-zA-Z\d\-]*(\.[a-zA-Z\d][a-zA-z\d\-]*)*\.$/
+ a.
+ 0: a.
+ Z.
+ 0: Z.
+ 2.
+ 0: 2.
+ ab-c.pq-r.
+ 0: ab-c.pq-r.
+ 1: .pq-r
+ sxk.zzz.ac.uk.
+ 0: sxk.zzz.ac.uk.
+ 1: .uk
+ x-.y-.
+ 0: x-.y-.
+ 1: .y-
+\= Expect no match
+ -abc.peq.
+No match
+
+/^\*\.[a-z]([a-z\-\d]*[a-z\d]+)?(\.[a-z]([a-z\-\d]*[a-z\d]+)?)*$/
+ *.a
+ 0: *.a
+ *.b0-a
+ 0: *.b0-a
+ 1: 0-a
+ *.c3-b.c
+ 0: *.c3-b.c
+ 1: 3-b
+ 2: .c
+ *.c-a.b-c
+ 0: *.c-a.b-c
+ 1: -a
+ 2: .b-c
+ 3: -c
+\= Expect no match
+ *.0
+No match
+ *.a-
+No match
+ *.a-b.c-
+No match
+ *.c-a.0-c
+No match
+
+/^(?=ab(de))(abd)(e)/
+ abde
+ 0: abde
+ 1: de
+ 2: abd
+ 3: e
+
+/^(?!(ab)de|x)(abd)(f)/
+ abdf
+ 0: abdf
+ 1:
+ 2: abd
+ 3: f
+
+/^(?=(ab(cd)))(ab)/
+ abcd
+ 0: ab
+ 1: abcd
+ 2: cd
+ 3: ab
+
+/^[\da-f](\.[\da-f])*$/i
+ a.b.c.d
+ 0: a.b.c.d
+ 1: .d
+ A.B.C.D
+ 0: A.B.C.D
+ 1: .D
+ a.b.c.1.2.3.C
+ 0: a.b.c.1.2.3.C
+ 1: .C
+
+/^\".*\"\s*(;.*)?$/
+ \"1234\"
+ 0: "1234"
+ \"abcd\" ;
+ 0: "abcd" ;
+ 1: ;
+ \"\" ; rhubarb
+ 0: "" ; rhubarb
+ 1: ; rhubarb
+\= Expect no match
+ \"1234\" : things
+No match
+
+/^$/
+ \
+ 0:
+\= Expect no match
+ A non-empty line
+No match
+
+/ ^ a (?# begins with a) b\sc (?# then b c) $ (?# then end)/x
+ ab c
+ 0: ab c
+\= Expect no match
+ abc
+No match
+ ab cde
+No match
+
+/(?x) ^ a (?# begins with a) b\sc (?# then b c) $ (?# then end)/
+ ab c
+ 0: ab c
+\= Expect no match
+ abc
+No match
+ ab cde
+No match
+
+/^ a\ b[c ]d $/x
+ a bcd
+ 0: a bcd
+ a b d
+ 0: a b d
+\= Expect no match
+ abcd
+No match
+ ab d
+No match
+
+/^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$/
+ abcdefhijklm
+ 0: abcdefhijklm
+ 1: abc
+ 2: bc
+ 3: c
+ 4: def
+ 5: ef
+ 6: f
+ 7: hij
+ 8: ij
+ 9: j
+10: klm
+11: lm
+12: m
+
+/^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$/
+ abcdefhijklm
+ 0: abcdefhijklm
+ 1: bc
+ 2: c
+ 3: ef
+ 4: f
+ 5: ij
+ 6: j
+ 7: lm
+ 8: m
+
+#/^[\w][\W][\s][\S][\d][\D][\b][\n][\c]][\022]/
+# a+ Z0+\x08\n\x1d\x12
+# 0: a+ Z0+\x08\x0a\x1d\x12
+
+/^[.^$|()*+?{,}]+/
+ .^\$(*+)|{?,?}
+ 0: .^$(*+)|{?,?}
+
+/^a*\w/
+ z
+ 0: z
+ az
+ 0: az
+ aaaz
+ 0: aaaz
+ a
+ 0: a
+ aa
+ 0: aa
+ aaaa
+ 0: aaaa
+ a+
+ 0: a
+ aa+
+ 0: aa
+
+/^a*?\w/
+ z
+ 0: z
+ az
+ 0: a
+ aaaz
+ 0: a
+ a
+ 0: a
+ aa
+ 0: a
+ aaaa
+ 0: a
+ a+
+ 0: a
+ aa+
+ 0: a
+
+/^a+\w/
+ az
+ 0: az
+ aaaz
+ 0: aaaz
+ aa
+ 0: aa
+ aaaa
+ 0: aaaa
+ aa+
+ 0: aa
+
+/^a+?\w/
+ az
+ 0: az
+ aaaz
+ 0: aa
+ aa
+ 0: aa
+ aaaa
+ 0: aa
+ aa+
+ 0: aa
+
+/^\d{8}\w{2,}/
+ 1234567890
+ 0: 1234567890
+ 12345678ab
+ 0: 12345678ab
+ 12345678__
+ 0: 12345678__
+\= Expect no match
+ 1234567
+No match
+
+/^[aeiou\d]{4,5}$/
+ uoie
+ 0: uoie
+ 1234
+ 0: 1234
+ 12345
+ 0: 12345
+ aaaaa
+ 0: aaaaa
+\= Expect no match
+ 123456
+No match
+
+/^[aeiou\d]{4,5}?/
+ uoie
+ 0: uoie
+ 1234
+ 0: 1234
+ 12345
+ 0: 1234
+ aaaaa
+ 0: aaaa
+ 123456
+ 0: 1234
+
+/\A(abc|def)=(\1){2,3}\Z/
+ abc=abcabc
+ 0: abc=abcabc
+ 1: abc
+ 2: abc
+ def=defdefdef
+ 0: def=defdefdef
+ 1: def
+ 2: def
+\= Expect no match
+ abc=defdef
+No match
+
+/^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\11*(\3\4)\1(?#)2$/
+ abcdefghijkcda2
+ 0: abcdefghijkcda2
+ 1: a
+ 2: b
+ 3: c
+ 4: d
+ 5: e
+ 6: f
+ 7: g
+ 8: h
+ 9: i
+10: j
+11: k
+12: cd
+ abcdefghijkkkkcda2
+ 0: abcdefghijkkkkcda2
+ 1: a
+ 2: b
+ 3: c
+ 4: d
+ 5: e
+ 6: f
+ 7: g
+ 8: h
+ 9: i
+10: j
+11: k
+12: cd
+
+/(cat(a(ract|tonic)|erpillar)) \1()2(3)/
+ cataract cataract23
+ 0: cataract cataract23
+ 1: cataract
+ 2: aract
+ 3: ract
+ 4:
+ 5: 3
+ catatonic catatonic23
+ 0: catatonic catatonic23
+ 1: catatonic
+ 2: atonic
+ 3: tonic
+ 4:
+ 5: 3
+ caterpillar caterpillar23
+ 0: caterpillar caterpillar23
+ 1: caterpillar
+ 2: erpillar
+ 3:
+ 4:
+ 5: 3
+
+
+/^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]/
+ From abcd Mon Sep 01 12:33:02 1997
+ 0: From abcd Mon Sep 01 12:33
+ 1: abcd
+
+/^From\s+\S+\s+([a-zA-Z]{3}\s+){2}\d{1,2}\s+\d\d:\d\d/
+ From abcd Mon Sep 01 12:33:02 1997
+ 0: From abcd Mon Sep 01 12:33
+ 1: Sep
+ From abcd Mon Sep 1 12:33:02 1997
+ 0: From abcd Mon Sep 1 12:33
+ 1: Sep
+\= Expect no match
+ From abcd Sep 01 12:33:02 1997
+No match
+
+/^12.34/s
+ 12\n34
+ 0: 12\x0a34
+ 12\r34
+ 0: 12\x0d34
+
+/\w+(?=\t)/
+ the quick brown\t fox
+ 0: brown
+
+/foo(?!bar)(.*)/
+ foobar is foolish see?
+ 0: foolish see?
+ 1: lish see?
+
+/(?:(?!foo)...|^.{0,2})bar(.*)/
+ foobar crowbar etc
+ 0: rowbar etc
+ 1: etc
+ barrel
+ 0: barrel
+ 1: rel
+ 2barrel
+ 0: 2barrel
+ 1: rel
+ A barrel
+ 0: A barrel
+ 1: rel
+
+/^(\D*)(?=\d)(?!123)/
+ abc456
+ 0: abc
+ 1: abc
+\= Expect no match
+ abc123
+No match
+
+/^1234(?# test newlines
+ inside)/
+ 1234
+ 0: 1234
+
+/^1234 #comment in extended re
+ /x
+ 1234
+ 0: 1234
+
+/#rhubarb
+ abcd/x
+ abcd
+ 0: abcd
+
+/^abcd#rhubarb/x
+ abcd
+ 0: abcd
+
+/^(a)\1{2,3}(.)/
+ aaab
+ 0: aaab
+ 1: a
+ 2: b
+ aaaab
+ 0: aaaab
+ 1: a
+ 2: b
+ aaaaab
+ 0: aaaaa
+ 1: a
+ 2: a
+ aaaaaab
+ 0: aaaaa
+ 1: a
+ 2: a
+
+/(?!^)abc/
+ the abc
+ 0: abc
+\= Expect no match
+ abc
+No match
+
+/(?=^)abc/
+ abc
+ 0: abc
+\= Expect no match
+ the abc
+No match
+
+/^[ab]{1,3}(ab*|b)/
+ aabbbbb
+ 0: aabb
+ 1: b
+
+/^[ab]{1,3}?(ab*|b)/
+ aabbbbb
+ 0: aabbbbb
+ 1: abbbbb
+
+/^[ab]{1,3}?(ab*?|b)/
+ aabbbbb
+ 0: aa
+ 1: a
+
+/^[ab]{1,3}(ab*?|b)/
+ aabbbbb
+ 0: aabb
+ 1: b
+
+/ (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* # optional leading comment
+(?: (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?: # opening quote...
+[^\\\x80-\xff\n\015"] # Anything except backslash and quote
+| # or
+\\ [^\x80-\xff] # Escaped something (something != CR)
+)* " # closing quote
+) # initial word
+(?: (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* \. (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?: # opening quote...
+[^\\\x80-\xff\n\015"] # Anything except backslash and quote
+| # or
+\\ [^\x80-\xff] # Escaped something (something != CR)
+)* " # closing quote
+) )* # further okay, if led by a period
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* @ (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # initial subdomain
+(?: #
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* \. # if led by a period...
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # ...further okay
+)*
+# address
+| # or
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?: # opening quote...
+[^\\\x80-\xff\n\015"] # Anything except backslash and quote
+| # or
+\\ [^\x80-\xff] # Escaped something (something != CR)
+)* " # closing quote
+) # one word, optionally followed by....
+(?:
+[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] | # atom and space parts, or...
+\(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) | # comments, or...
+
+" (?: # opening quote...
+[^\\\x80-\xff\n\015"] # Anything except backslash and quote
+| # or
+\\ [^\x80-\xff] # Escaped something (something != CR)
+)* " # closing quote
+# quoted strings
+)*
+< (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* # leading <
+(?: @ (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # initial subdomain
+(?: #
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* \. # if led by a period...
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # ...further okay
+)*
+
+(?: (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* , (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* @ (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # initial subdomain
+(?: #
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* \. # if led by a period...
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # ...further okay
+)*
+)* # further okay, if led by comma
+: # closing colon
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* )? # optional route
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?: # opening quote...
+[^\\\x80-\xff\n\015"] # Anything except backslash and quote
+| # or
+\\ [^\x80-\xff] # Escaped something (something != CR)
+)* " # closing quote
+) # initial word
+(?: (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* \. (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?: # opening quote...
+[^\\\x80-\xff\n\015"] # Anything except backslash and quote
+| # or
+\\ [^\x80-\xff] # Escaped something (something != CR)
+)* " # closing quote
+) )* # further okay, if led by a period
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* @ (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # initial subdomain
+(?: #
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* \. # if led by a period...
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+| \[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+) # ...further okay
+)*
+# address spec
+(?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* > # trailing >
+# name and address
+) (?: [\040\t] | \(
+(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )*
+\) )* # optional trailing comment
+/x
+ Alan Other
+ 0: Alan Other
+
+ 0: user@dom.ain
+ user\@dom.ain
+ 0: user@dom.ain
+ \"A. Other\" (a comment)
+ 0: "A. Other" (a comment)
+ A. Other (a comment)
+ 0: Other (a comment)
+ \"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"\@x400-re.lay
+ 0: "/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/"@x400-re.lay
+ A missing angle @,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+| # or
+" # "
+[^\\\x80-\xff\n\015"] * # normal
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015"] * )* # ( special normal* )*
+" # "
+# Quoted string
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+\.
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+| # or
+" # "
+[^\\\x80-\xff\n\015"] * # normal
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015"] * )* # ( special normal* )*
+" # "
+# Quoted string
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+| # or
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+| # or
+" # "
+[^\\\x80-\xff\n\015"] * # normal
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015"] * )* # ( special normal* )*
+" # "
+# Quoted string
+)
+# leading word
+[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] * # "normal" atoms and or spaces
+(?:
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+|
+" # "
+[^\\\x80-\xff\n\015"] * # normal
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015"] * )* # ( special normal* )*
+" # "
+) # "special" comment or quoted string
+[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] * # more "normal"
+)*
+<
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# <
+(?:
+@
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+@
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)* # additional domains
+:
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+)? # optional route
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+| # or
+" # "
+[^\\\x80-\xff\n\015"] * # normal
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015"] * )* # ( special normal* )*
+" # "
+# Quoted string
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+\.
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+| # or
+" # "
+[^\\\x80-\xff\n\015"] * # normal
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015"] * )* # ( special normal* )*
+" # "
+# Quoted string
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[ # [
+(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff
+\] # ]
+)
+[\040\t]* # Nab whitespace.
+(?:
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: # (
+(?: \\ [^\x80-\xff] |
+\( # (
+[^\\\x80-\xff\n\015()] * # normal*
+(?: \\ [^\x80-\xff] [^\\\x80-\xff\n\015()] * )* # (special normal*)*
+\) # )
+) # special
+[^\\\x80-\xff\n\015()] * # normal*
+)* # )*
+\) # )
+[\040\t]* )* # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address spec
+> # >
+# name and address
+)
+/x
+ Alan Other
+ 0: Alan Other
+
+ 0: user@dom.ain
+ user\@dom.ain
+ 0: user@dom.ain
+ \"A. Other\" (a comment)
+ 0: "A. Other"
+ A. Other (a comment)
+ 0: Other
+ \"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"\@x400-re.lay
+ 0: "/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/"@x400-re.lay
+ A missing angle ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f
+
+/P[^*]TAIRE[^*]{1,6}?LL/
+ xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
+ 0: PSTAIREISLL
+
+/P[^*]TAIRE[^*]{1,}?LL/
+ xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
+ 0: PSTAIREISLL
+
+/(\.\d\d[1-9]?)\d+/
+ 1.230003938
+ 0: .230003938
+ 1: .23
+ 1.875000282
+ 0: .875000282
+ 1: .875
+ 1.235
+ 0: .235
+ 1: .23
+
+/(\.\d\d((?=0)|\d(?=\d)))/
+ 1.230003938
+ 0: .23
+ 1: .23
+ 2:
+ 1.875000282
+ 0: .875
+ 1: .875
+ 2: 5
+\= Expect no match
+ 1.235
+No match
+
+/\b(foo)\s+(\w+)/i
+ Food is on the foo table
+ 0: foo table
+ 1: foo
+ 2: table
+
+/foo(.*)bar/
+ The food is under the bar in the barn.
+ 0: food is under the bar in the bar
+ 1: d is under the bar in the
+
+/foo(.*?)bar/
+ The food is under the bar in the barn.
+ 0: food is under the bar
+ 1: d is under the
+
+/(.*)(\d*)/
+ I have 2 numbers: 53147
+ 0: I have 2 numbers: 53147
+ 1: I have 2 numbers: 53147
+ 2:
+
+/(.*)(\d+)/
+ I have 2 numbers: 53147
+ 0: I have 2 numbers: 53147
+ 1: I have 2 numbers: 5314
+ 2: 7
+
+/(.*?)(\d*)/
+ I have 2 numbers: 53147
+ 0:
+ 1:
+ 2:
+
+/(.*?)(\d+)/
+ I have 2 numbers: 53147
+ 0: I have 2
+ 1: I have
+ 2: 2
+
+/(.*)(\d+)$/
+ I have 2 numbers: 53147
+ 0: I have 2 numbers: 53147
+ 1: I have 2 numbers: 5314
+ 2: 7
+
+/(.*?)(\d+)$/
+ I have 2 numbers: 53147
+ 0: I have 2 numbers: 53147
+ 1: I have 2 numbers:
+ 2: 53147
+
+/(.*)\b(\d+)$/
+ I have 2 numbers: 53147
+ 0: I have 2 numbers: 53147
+ 1: I have 2 numbers:
+ 2: 53147
+
+/(.*\D)(\d+)$/
+ I have 2 numbers: 53147
+ 0: I have 2 numbers: 53147
+ 1: I have 2 numbers:
+ 2: 53147
+
+/^\D*(?!123)/
+ ABC123
+ 0: AB
+
+/^(\D*)(?=\d)(?!123)/
+ ABC445
+ 0: ABC
+ 1: ABC
+\= Expect no match
+ ABC123
+No match
+
+/^[W-]46]/
+ W46]789
+ 0: W46]
+ -46]789
+ 0: -46]
+\= Expect no match
+ Wall
+No match
+ Zebra
+No match
+ 42
+No match
+ [abcd]
+No match
+ ]abcd[
+No match
+
+/^[W-\]46]/
+ W46]789
+ 0: W
+ Wall
+ 0: W
+ Zebra
+ 0: Z
+ Xylophone
+ 0: X
+ 42
+ 0: 4
+ [abcd]
+ 0: [
+ ]abcd[
+ 0: ]
+ \\backslash
+ 0: \
+\= Expect no match
+ -46]789
+No match
+ well
+No match
+
+/\d\d\/\d\d\/\d\d\d\d/
+ 01/01/2000
+ 0: 01/01/2000
+
+/word (?:[a-zA-Z0-9]+ ){0,10}otherword/
+ word cat dog elephant mussel cow horse canary baboon snake shark otherword
+ 0: word cat dog elephant mussel cow horse canary baboon snake shark otherword
+\= Expect no match
+ word cat dog elephant mussel cow horse canary baboon snake shark
+No match
+
+/word (?:[a-zA-Z0-9]+ ){0,300}otherword/
+\= Expect no match
+ word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope
+No match
+
+/^(a){0,0}/
+ bcd
+ 0:
+ abc
+ 0:
+ aab
+ 0:
+
+/^(a){0,1}/
+ bcd
+ 0:
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: a
+ 1: a
+
+/^(a){0,2}/
+ bcd
+ 0:
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: aa
+ 1: a
+
+/^(a){0,3}/
+ bcd
+ 0:
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: aa
+ 1: a
+ aaa
+ 0: aaa
+ 1: a
+
+/^(a){0,}/
+ bcd
+ 0:
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: aa
+ 1: a
+ aaa
+ 0: aaa
+ 1: a
+ aaaaaaaa
+ 0: aaaaaaaa
+ 1: a
+
+/^(a){1,1}/
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: a
+ 1: a
+\= Expect no match
+ bcd
+No match
+
+/^(a){1,2}/
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: aa
+ 1: a
+\= Expect no match
+ bcd
+No match
+
+/^(a){1,3}/
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: aa
+ 1: a
+ aaa
+ 0: aaa
+ 1: a
+\= Expect no match
+ bcd
+No match
+
+/^(a){1,}/
+ abc
+ 0: a
+ 1: a
+ aab
+ 0: aa
+ 1: a
+ aaa
+ 0: aaa
+ 1: a
+ aaaaaaaa
+ 0: aaaaaaaa
+ 1: a
+\= Expect no match
+ bcd
+No match
+
+/.*\.gif/
+ borfle\nbib.gif\nno
+ 0: bib.gif
+
+/.{0,}\.gif/
+ borfle\nbib.gif\nno
+ 0: bib.gif
+
+/.*\.gif/m
+ borfle\nbib.gif\nno
+ 0: bib.gif
+
+/.*\.gif/s
+ borfle\nbib.gif\nno
+ 0: borfle\x0abib.gif
+
+/.*\.gif/ms
+ borfle\nbib.gif\nno
+ 0: borfle\x0abib.gif
+
+/.*$/
+ borfle\nbib.gif\nno
+ 0: no
+
+/.*$/m
+ borfle\nbib.gif\nno
+ 0: borfle
+
+/.*$/s
+ borfle\nbib.gif\nno
+ 0: borfle\x0abib.gif\x0ano
+
+/.*$/ms
+ borfle\nbib.gif\nno
+ 0: borfle\x0abib.gif\x0ano
+
+/.*$/
+ borfle\nbib.gif\nno\n
+ 0: no
+
+/.*$/m
+ borfle\nbib.gif\nno\n
+ 0: borfle
+
+/.*$/s
+ borfle\nbib.gif\nno\n
+ 0: borfle\x0abib.gif\x0ano\x0a
+
+/.*$/ms
+ borfle\nbib.gif\nno\n
+ 0: borfle\x0abib.gif\x0ano\x0a
+
+/(.*X|^B)/
+ abcde\n1234Xyz
+ 0: 1234X
+ 1: 1234X
+ BarFoo
+ 0: B
+ 1: B
+\= Expect no match
+ abcde\nBar
+No match
+
+/(.*X|^B)/m
+ abcde\n1234Xyz
+ 0: 1234X
+ 1: 1234X
+ BarFoo
+ 0: B
+ 1: B
+ abcde\nBar
+ 0: B
+ 1: B
+
+/(.*X|^B)/s
+ abcde\n1234Xyz
+ 0: abcde\x0a1234X
+ 1: abcde\x0a1234X
+ BarFoo
+ 0: B
+ 1: B
+\= Expect no match
+ abcde\nBar
+No match
+
+/(.*X|^B)/ms
+ abcde\n1234Xyz
+ 0: abcde\x0a1234X
+ 1: abcde\x0a1234X
+ BarFoo
+ 0: B
+ 1: B
+ abcde\nBar
+ 0: B
+ 1: B
+
+/(?s)(.*X|^B)/
+ abcde\n1234Xyz
+ 0: abcde\x0a1234X
+ 1: abcde\x0a1234X
+ BarFoo
+ 0: B
+ 1: B
+\= Expect no match
+ abcde\nBar
+No match
+
+/(?s:.*X|^B)/
+ abcde\n1234Xyz
+ 0: abcde\x0a1234X
+ BarFoo
+ 0: B
+\= Expect no match
+ abcde\nBar
+No match
+
+/^.*B/
+\= Expect no match
+ abc\nB
+No match
+
+/(?s)^.*B/
+ abc\nB
+ 0: abc\x0aB
+
+/(?m)^.*B/
+ abc\nB
+ 0: B
+
+/(?ms)^.*B/
+ abc\nB
+ 0: abc\x0aB
+
+/(?ms)^B/
+ abc\nB
+ 0: B
+
+/(?s)B$/
+ B\n
+ 0: B
+
+/^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/
+ 123456654321
+ 0: 123456654321
+
+/^\d\d\d\d\d\d\d\d\d\d\d\d/
+ 123456654321
+ 0: 123456654321
+
+/^[\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d]/
+ 123456654321
+ 0: 123456654321
+
+/^[abc]{12}/
+ abcabcabcabc
+ 0: abcabcabcabc
+
+/^[a-c]{12}/
+ abcabcabcabc
+ 0: abcabcabcabc
+
+/^(a|b|c){12}/
+ abcabcabcabc
+ 0: abcabcabcabc
+ 1: c
+
+/^[abcdefghijklmnopqrstuvwxy0123456789]/
+ n
+ 0: n
+\= Expect no match
+ z
+No match
+
+/abcde{0,0}/
+ abcd
+ 0: abcd
+\= Expect no match
+ abce
+No match
+
+/ab[cd]{0,0}e/
+ abe
+ 0: abe
+\= Expect no match
+ abcde
+No match
+
+/ab(c){0,0}d/
+ abd
+ 0: abd
+\= Expect no match
+ abcd
+No match
+
+/a(b*)/
+ a
+ 0: a
+ 1:
+ ab
+ 0: ab
+ 1: b
+ abbbb
+ 0: abbbb
+ 1: bbbb
+\= Expect no match
+ bbbbb
+No match
+
+/ab\d{0}e/
+ abe
+ 0: abe
+\= Expect no match
+ ab1e
+No match
+
+/"([^\\"]+|\\.)*"/
+ the \"quick\" brown fox
+ 0: "quick"
+ 1: quick
+ \"the \\\"quick\\\" brown fox\"
+ 0: "the \"quick\" brown fox"
+ 1: brown fox
+
+/]{0,})>]{0,})>([\d]{0,}\.)(.*)((
([\w\W\s\d][^<>]{0,})|[\s]{0,}))<\/a><\/TD> ]{0,})>([\w\W\s\d][^<>]{0,})<\/TD> ]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><\/TR>/is
+ 43.Word Processor
(N-1286) Lega lstaff.com CA - Statewide
+ 0: 43.Word Processor
(N-1286) Lega lstaff.com CA - Statewide
+ 1: BGCOLOR='#DBE9E9'
+ 2: align=left valign=top
+ 3: 43.
+ 4: Word Processor
(N-1286)
+ 5:
+ 6:
+ 7:
+ 8: align=left valign=top
+ 9: Lega lstaff.com
+10: align=left valign=top
+11: CA - Statewide
+
+/a[^a]b/
+ acb
+ 0: acb
+ a\nb
+ 0: a\x0ab
+
+/a.b/
+ acb
+ 0: acb
+\= Expect no match
+ a\nb
+No match
+
+/a[^a]b/s
+ acb
+ 0: acb
+ a\nb
+ 0: a\x0ab
+
+/a.b/s
+ acb
+ 0: acb
+ a\nb
+ 0: a\x0ab
+
+/^(b+?|a){1,2}?c/
+ bac
+ 0: bac
+ 1: a
+ bbac
+ 0: bbac
+ 1: a
+ bbbac
+ 0: bbbac
+ 1: a
+ bbbbac
+ 0: bbbbac
+ 1: a
+ bbbbbac
+ 0: bbbbbac
+ 1: a
+
+/^(b+|a){1,2}?c/
+ bac
+ 0: bac
+ 1: a
+ bbac
+ 0: bbac
+ 1: a
+ bbbac
+ 0: bbbac
+ 1: a
+ bbbbac
+ 0: bbbbac
+ 1: a
+ bbbbbac
+ 0: bbbbbac
+ 1: a
+
+/(?!\A)x/m
+ a\bx\n
+ 0: x
+ a\nx\n
+ 0: x
+\= Expect no match
+ x\nb\n
+No match
+
+/(A|B)*?CD/
+ CD
+ 0: CD
+
+/(A|B)*CD/
+ CD
+ 0: CD
+
+/(AB)*?\1/
+ ABABAB
+ 0: ABAB
+ 1: AB
+
+/(AB)*\1/
+ ABABAB
+ 0: ABABAB
+ 1: AB
+
+/(?.*/)foo"
+ /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo
+ 0: /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo
+\= Expect no match
+ /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/
+No match
+
+/(?>(\.\d\d[1-9]?))\d+/
+ 1.230003938
+ 0: .230003938
+ 1: .23
+ 1.875000282
+ 0: .875000282
+ 1: .875
+\= Expect no match
+ 1.235
+No match
+
+/^((?>\w+)|(?>\s+))*$/
+ now is the time for all good men to come to the aid of the party
+ 0: now is the time for all good men to come to the aid of the party
+ 1: party
+\= Expect no match
+ this is not a line with only words and spaces!
+No match
+
+/(\d+)(\w)/
+ 12345a
+ 0: 12345a
+ 1: 12345
+ 2: a
+ 12345+
+ 0: 12345
+ 1: 1234
+ 2: 5
+
+/((?>\d+))(\w)/
+ 12345a
+ 0: 12345a
+ 1: 12345
+ 2: a
+\= Expect no match
+ 12345+
+No match
+
+/(?>a+)b/
+ aaab
+ 0: aaab
+
+/((?>a+)b)/
+ aaab
+ 0: aaab
+ 1: aaab
+
+/(?>(a+))b/
+ aaab
+ 0: aaab
+ 1: aaa
+
+/(?>b)+/
+ aaabbbccc
+ 0: bbb
+
+/(?>a+|b+|c+)*c/
+ aaabbbbccccd
+ 0: aaabbbbc
+
+/((?>[^()]+)|\([^()]*\))+/
+ ((abc(ade)ufh()()x
+ 0: abc(ade)ufh()()x
+ 1: x
+
+/\(((?>[^()]+)|\([^()]+\))+\)/
+ (abc)
+ 0: (abc)
+ 1: abc
+ (abc(def)xyz)
+ 0: (abc(def)xyz)
+ 1: xyz
+\= Expect no match
+ ((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+No match
+
+/a(?-i)b/i
+ ab
+ 0: ab
+ Ab
+ 0: Ab
+\= Expect no match
+ aB
+No match
+ AB
+No match
+
+/(a (?x)b c)d e/
+ a bcd e
+ 0: a bcd e
+ 1: a bc
+\= Expect no match
+ a b cd e
+No match
+ abcd e
+No match
+ a bcde
+No match
+
+/(a b(?x)c d (?-x)e f)/
+ a bcde f
+ 0: a bcde f
+ 1: a bcde f
+\= Expect no match
+ abcdef
+No match
+
+/(a(?i)b)c/
+ abc
+ 0: abc
+ 1: ab
+ aBc
+ 0: aBc
+ 1: aB
+\= Expect no match
+ abC
+No match
+ aBC
+No match
+ Abc
+No match
+ ABc
+No match
+ ABC
+No match
+ AbC
+No match
+
+/a(?i:b)c/
+ abc
+ 0: abc
+ aBc
+ 0: aBc
+\= Expect no match
+ ABC
+No match
+ abC
+No match
+ aBC
+No match
+
+/a(?i:b)*c/
+ aBc
+ 0: aBc
+ aBBc
+ 0: aBBc
+\= Expect no match
+ aBC
+No match
+ aBBC
+No match
+
+/a(?=b(?i)c)\w\wd/
+ abcd
+ 0: abcd
+ abCd
+ 0: abCd
+\= Expect no match
+ aBCd
+No match
+ abcD
+No match
+
+/(?s-i:more.*than).*million/i
+ more than million
+ 0: more than million
+ more than MILLION
+ 0: more than MILLION
+ more \n than Million
+ 0: more \x0a than Million
+\= Expect no match
+ MORE THAN MILLION
+No match
+ more \n than \n million
+No match
+
+/(?:(?s-i)more.*than).*million/i
+ more than million
+ 0: more than million
+ more than MILLION
+ 0: more than MILLION
+ more \n than Million
+ 0: more \x0a than Million
+\= Expect no match
+ MORE THAN MILLION
+No match
+ more \n than \n million
+No match
+
+/(?>a(?i)b+)+c/
+ abc
+ 0: abc
+ aBbc
+ 0: aBbc
+ aBBc
+ 0: aBBc
+\= Expect no match
+ Abc
+No match
+ abAb
+No match
+ abbC
+No match
+
+/(?=a(?i)b)\w\wc/
+ abc
+ 0: abc
+ aBc
+ 0: aBc
+\= Expect no match
+ Ab
+No match
+ abC
+No match
+ aBC
+No match
+
+/(?<=a(?i)b)(\w\w)c/
+ abxxc
+ 0: xxc
+ 1: xx
+ aBxxc
+ 0: xxc
+ 1: xx
+\= Expect no match
+ Abxxc
+No match
+ ABxxc
+No match
+ abxxC
+No match
+
+/(?:(a)|b)(?(1)A|B)/
+ aA
+ 0: aA
+ 1: a
+ bB
+ 0: bB
+\= Expect no match
+ aB
+No match
+ bA
+No match
+
+/^(a)?(?(1)a|b)+$/
+ aa
+ 0: aa
+ 1: a
+ b
+ 0: b
+ bb
+ 0: bb
+\= Expect no match
+ ab
+No match
+
+# Perl gets this next one wrong if the pattern ends with $; in that case it
+# fails to match "12".
+
+/^(?(?=abc)\w{3}:|\d\d)/
+ abc:
+ 0: abc:
+ 12
+ 0: 12
+ 123
+ 0: 12
+\= Expect no match
+ xyz
+No match
+
+/^(?(?!abc)\d\d|\w{3}:)$/
+ abc:
+ 0: abc:
+ 12
+ 0: 12
+\= Expect no match
+ 123
+No match
+ xyz
+No match
+
+/(?(?<=foo)bar|cat)/
+ foobar
+ 0: bar
+ cat
+ 0: cat
+ fcat
+ 0: cat
+ focat
+ 0: cat
+\= Expect no match
+ foocat
+No match
+
+/(?(?a*)*/
+ a
+ 0: a
+ aa
+ 0: aa
+ aaaa
+ 0: aaaa
+
+/(abc|)+/
+ abc
+ 0: abc
+ 1:
+ abcabc
+ 0: abcabc
+ 1:
+ abcabcabc
+ 0: abcabcabc
+ 1:
+ xyz
+ 0:
+ 1:
+
+/([a]*)*/
+ a
+ 0: a
+ 1:
+ aaaaa
+ 0: aaaaa
+ 1:
+
+/([ab]*)*/
+ a
+ 0: a
+ 1:
+ b
+ 0: b
+ 1:
+ ababab
+ 0: ababab
+ 1:
+ aaaabcde
+ 0: aaaab
+ 1:
+ bbbb
+ 0: bbbb
+ 1:
+
+/([^a]*)*/
+ b
+ 0: b
+ 1:
+ bbbb
+ 0: bbbb
+ 1:
+ aaa
+ 0:
+ 1:
+
+/([^ab]*)*/
+ cccc
+ 0: cccc
+ 1:
+ abab
+ 0:
+ 1:
+
+/([a]*?)*/
+ a
+ 0:
+ 1:
+ aaaa
+ 0:
+ 1:
+
+/([ab]*?)*/
+ a
+ 0:
+ 1:
+ b
+ 0:
+ 1:
+ abab
+ 0:
+ 1:
+ baba
+ 0:
+ 1:
+
+/([^a]*?)*/
+ b
+ 0:
+ 1:
+ bbbb
+ 0:
+ 1:
+ aaa
+ 0:
+ 1:
+
+/([^ab]*?)*/
+ c
+ 0:
+ 1:
+ cccc
+ 0:
+ 1:
+ baba
+ 0:
+ 1:
+
+/(?>a*)*/
+ a
+ 0: a
+ aaabcde
+ 0: aaa
+
+/((?>a*))*/
+ aaaaa
+ 0: aaaaa
+ 1:
+ aabbaa
+ 0: aa
+ 1:
+
+/((?>a*?))*/
+ aaaaa
+ 0:
+ 1:
+ aabbaa
+ 0:
+ 1:
+
+/(?(?=[^a-z]+[a-z]) \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} ) /x
+ 12-sep-98
+ 0: 12-sep-98
+ 12-09-98
+ 0: 12-09-98
+\= Expect no match
+ sep-12-98
+No match
+
+/(?<=(foo))bar\1/
+ foobarfoo
+ 0: barfoo
+ 1: foo
+ foobarfootling
+ 0: barfoo
+ 1: foo
+\= Expect no match
+ foobar
+No match
+ barfoo
+No match
+
+/(?i:saturday|sunday)/
+ saturday
+ 0: saturday
+ sunday
+ 0: sunday
+ Saturday
+ 0: Saturday
+ Sunday
+ 0: Sunday
+ SATURDAY
+ 0: SATURDAY
+ SUNDAY
+ 0: SUNDAY
+ SunDay
+ 0: SunDay
+
+/(a(?i)bc|BB)x/
+ abcx
+ 0: abcx
+ 1: abc
+ aBCx
+ 0: aBCx
+ 1: aBC
+ bbx
+ 0: bbx
+ 1: bb
+ BBx
+ 0: BBx
+ 1: BB
+\= Expect no match
+ abcX
+No match
+ aBCX
+No match
+ bbX
+No match
+ BBX
+No match
+
+/^([ab](?i)[cd]|[ef])/
+ ac
+ 0: ac
+ 1: ac
+ aC
+ 0: aC
+ 1: aC
+ bD
+ 0: bD
+ 1: bD
+ elephant
+ 0: e
+ 1: e
+ Europe
+ 0: E
+ 1: E
+ frog
+ 0: f
+ 1: f
+ France
+ 0: F
+ 1: F
+\= Expect no match
+ Africa
+No match
+
+/^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/
+ ab
+ 0: ab
+ 1: ab
+ aBd
+ 0: aBd
+ 1: aBd
+ xy
+ 0: xy
+ 1: xy
+ xY
+ 0: xY
+ 1: xY
+ zebra
+ 0: z
+ 1: z
+ Zambesi
+ 0: Z
+ 1: Z
+\= Expect no match
+ aCD
+No match
+ XY
+No match
+
+/(?<=foo\n)^bar/m
+ foo\nbar
+ 0: bar
+\= Expect no match
+ bar
+No match
+ baz\nbar
+No match
+
+/(?<=(?]&/
+ <&OUT
+ 0: <&
+
+/^(a\1?){4}$/
+ aaaaaaaaaa
+ 0: aaaaaaaaaa
+ 1: aaaa
+\= Expect no match
+ AB
+No match
+ aaaaaaaaa
+No match
+ aaaaaaaaaaa
+No match
+
+/^(a(?(1)\1)){4}$/
+ aaaaaaaaaa
+ 0: aaaaaaaaaa
+ 1: aaaa
+\= Expect no match
+ aaaaaaaaa
+No match
+ aaaaaaaaaaa
+No match
+
+/(?:(f)(o)(o)|(b)(a)(r))*/
+ foobar
+ 0: foobar
+ 1: f
+ 2: o
+ 3: o
+ 4: b
+ 5: a
+ 6: r
+
+/(?<=a)b/
+ ab
+ 0: b
+\= Expect no match
+ cb
+No match
+ b
+No match
+
+/(?
+ 2: abcd
+ xy:z:::abcd
+ 0: xy:z:::abcd
+ 1: xy:z:::
+ 2: abcd
+
+/^[^bcd]*(c+)/
+ aexycd
+ 0: aexyc
+ 1: c
+
+/(a*)b+/
+ caab
+ 0: aab
+ 1: aa
+
+/([\w:]+::)?(\w+)$/
+ abcd
+ 0: abcd
+ 1:
+ 2: abcd
+ xy:z:::abcd
+ 0: xy:z:::abcd
+ 1: xy:z:::
+ 2: abcd
+\= Expect no match
+ abcd:
+No match
+ abcd:
+No match
+
+/^[^bcd]*(c+)/
+ aexycd
+ 0: aexyc
+ 1: c
+
+/(>a+)ab/
+
+/(?>a+)b/
+ aaab
+ 0: aaab
+
+/([[:]+)/
+ a:[b]:
+ 0: :[
+ 1: :[
+
+/([[=]+)/
+ a=[b]=
+ 0: =[
+ 1: =[
+
+/([[.]+)/
+ a.[b].
+ 0: .[
+ 1: .[
+
+/((?>a+)b)/
+ aaab
+ 0: aaab
+ 1: aaab
+
+/(?>(a+))b/
+ aaab
+ 0: aaab
+ 1: aaa
+
+/((?>[^()]+)|\([^()]*\))+/
+ ((abc(ade)ufh()()x
+ 0: abc(ade)ufh()()x
+ 1: x
+
+/a\Z/
+\= Expect no match
+ aaab
+No match
+ a\nb\n
+No match
+
+/b\Z/
+ a\nb\n
+ 0: b
+
+/b\z/
+
+/b\Z/
+ a\nb
+ 0: b
+
+/b\z/
+ a\nb
+ 0: b
+
+/^(?>(?(1)\.|())[^\W_](?>[a-z0-9-]*[^\W_])?)+$/
+ a
+ 0: a
+ 1:
+ abc
+ 0: abc
+ 1:
+ a-b
+ 0: a-b
+ 1:
+ 0-9
+ 0: 0-9
+ 1:
+ a.b
+ 0: a.b
+ 1:
+ 5.6.7
+ 0: 5.6.7
+ 1:
+ the.quick.brown.fox
+ 0: the.quick.brown.fox
+ 1:
+ a100.b200.300c
+ 0: a100.b200.300c
+ 1:
+ 12-ab.1245
+ 0: 12-ab.1245
+ 1:
+\= Expect no match
+ \
+No match
+ .a
+No match
+ -a
+No match
+ a-
+No match
+ a.
+No match
+ a_b
+No match
+ a.-
+No match
+ a..
+No match
+ ab..bc
+No match
+ the.quick.brown.fox-
+No match
+ the.quick.brown.fox.
+No match
+ the.quick.brown.fox_
+No match
+ the.quick.brown.fox+
+No match
+
+/(?>.*)(?<=(abcd|wxyz))/
+ alphabetabcd
+ 0: alphabetabcd
+ 1: abcd
+ endingwxyz
+ 0: endingwxyz
+ 1: wxyz
+\= Expect no match
+ a rather long string that doesn't end with one of them
+No match
+
+/word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword/
+ word cat dog elephant mussel cow horse canary baboon snake shark otherword
+ 0: word cat dog elephant mussel cow horse canary baboon snake shark otherword
+\= Expect no match
+ word cat dog elephant mussel cow horse canary baboon snake shark
+No match
+
+/word (?>[a-zA-Z0-9]+ ){0,30}otherword/
+\= Expect no match
+ word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope
+No match
+
+/(?<=\d{3}(?!999))foo/
+ 999foo
+ 0: foo
+ 123999foo
+ 0: foo
+\= Expect no match
+ 123abcfoo
+No match
+
+/(?<=(?!...999)\d{3})foo/
+ 999foo
+ 0: foo
+ 123999foo
+ 0: foo
+\= Expect no match
+ 123abcfoo
+No match
+
+/(?<=\d{3}(?!999)...)foo/
+ 123abcfoo
+ 0: foo
+ 123456foo
+ 0: foo
+\= Expect no match
+ 123999foo
+No match
+
+/(?<=\d{3}...)(?
+ 2:
+ 3: abcd
+
+ 2:
+ 3: abcd
+ \s*)=(?>\s*) # find
+ 2:
+ 3: abcd
+ Z)+|A)*/
+ ZABCDEFG
+ 0: ZA
+ 1: A
+
+/((?>)+|A)*/
+ ZABCDEFG
+ 0:
+ 1:
+
+/^[\d-a]/
+ abcde
+ 0: a
+ -things
+ 0: -
+ 0digit
+ 0: 0
+\= Expect no match
+ bcdef
+No match
+
+/[\s]+/
+ > \x09\x0a\x0c\x0d\x0b<
+ 0: \x09\x0a\x0c\x0d\x0b
+
+/\s+/
+ > \x09\x0a\x0c\x0d\x0b<
+ 0: \x09\x0a\x0c\x0d\x0b
+
+/ab/x
+ ab
+ 0: ab
+
+/(?!\A)x/m
+ a\nxb\n
+ 0: x
+
+/(?!^)x/m
+\= Expect no match
+ a\nxb\n
+No match
+
+#/abc\Qabc\Eabc/
+# abcabcabc
+# 0: abcabcabc
+
+#/abc\Q(*+|\Eabc/
+# abc(*+|abc
+# 0: abc(*+|abc
+
+#/ abc\Q abc\Eabc/x
+# abc abcabc
+# 0: abc abcabc
+#\= Expect no match
+# abcabcabc
+#No match
+
+#/abc#comment
+# \Q#not comment
+# literal\E/x
+# abc#not comment\n literal
+# 0: abc#not comment\x0a literal
+
+#/abc#comment
+# \Q#not comment
+# literal/x
+# abc#not comment\n literal
+# 0: abc#not comment\x0a literal
+
+#/abc#comment
+# \Q#not comment
+# literal\E #more comment
+# /x
+# abc#not comment\n literal
+# 0: abc#not comment\x0a literal
+
+#/abc#comment
+# \Q#not comment
+# literal\E #more comment/x
+# abc#not comment\n literal
+# 0: abc#not comment\x0a literal
+
+#/\Qabc\$xyz\E/
+# abc\\\$xyz
+# 0: abc\$xyz
+
+#/\Qabc\E\$\Qxyz\E/
+# abc\$xyz
+# 0: abc$xyz
+
+/\Gabc/
+ abc
+ 0: abc
+\= Expect no match
+ xyzabc
+No match
+
+/a(?x: b c )d/
+ XabcdY
+ 0: abcd
+\= Expect no match
+ Xa b c d Y
+No match
+
+/((?x)x y z | a b c)/
+ XabcY
+ 0: abc
+ 1: abc
+ AxyzB
+ 0: xyz
+ 1: xyz
+
+/(?i)AB(?-i)C/
+ XabCY
+ 0: abC
+\= Expect no match
+ XabcY
+No match
+
+/((?i)AB(?-i)C|D)E/
+ abCE
+ 0: abCE
+ 1: abC
+ DE
+ 0: DE
+ 1: D
+\= Expect no match
+ abcE
+No match
+ abCe
+No match
+ dE
+No match
+ De
+No match
+
+/(.*)\d+\1/
+ abc123abc
+ 0: abc123abc
+ 1: abc
+ abc123bc
+ 0: bc123bc
+ 1: bc
+
+/(.*)\d+\1/s
+ abc123abc
+ 0: abc123abc
+ 1: abc
+ abc123bc
+ 0: bc123bc
+ 1: bc
+
+/((.*))\d+\1/
+ abc123abc
+ 0: abc123abc
+ 1: abc
+ 2: abc
+ abc123bc
+ 0: bc123bc
+ 1: bc
+ 2: bc
+
+# This tests for an IPv6 address in the form where it can have up to
+# eight components, one and only one of which is empty. This must be
+# an internal component.
+
+/^(?!:) # colon disallowed at start
+ (?: # start of item
+ (?: [0-9a-f]{1,4} | # 1-4 hex digits or
+ (?(1)0 | () ) ) # if null previously matched, fail; else null
+ : # followed by colon
+ ){1,7} # end item; 1-7 of them required
+ [0-9a-f]{1,4} $ # final hex number at end of string
+ (?(1)|.) # check that there was an empty component
+ /ix
+ a123::a123
+ 0: a123::a123
+ 1:
+ a123:b342::abcd
+ 0: a123:b342::abcd
+ 1:
+ a123:b342::324e:abcd
+ 0: a123:b342::324e:abcd
+ 1:
+ a123:ddde:b342::324e:abcd
+ 0: a123:ddde:b342::324e:abcd
+ 1:
+ a123:ddde:b342::324e:dcba:abcd
+ 0: a123:ddde:b342::324e:dcba:abcd
+ 1:
+ a123:ddde:9999:b342::324e:dcba:abcd
+ 0: a123:ddde:9999:b342::324e:dcba:abcd
+ 1:
+\= Expect no match
+ 1:2:3:4:5:6:7:8
+No match
+ a123:bce:ddde:9999:b342::324e:dcba:abcd
+No match
+ a123::9999:b342::324e:dcba:abcd
+No match
+ abcde:2:3:4:5:6:7:8
+No match
+ ::1
+No match
+ abcd:fee0:123::
+No match
+ :1
+No match
+ 1:
+No match
+
+#/[z\Qa-d]\E]/
+# z
+# 0: z
+# a
+# 0: a
+# -
+# 0: -
+# d
+# 0: d
+# ]
+# 0: ]
+#\= Expect no match
+# b
+#No match
+
+#TODO: PCRE has an optimization to make this workable, .NET does not
+#/(a+)*b/
+#\= Expect no match
+# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+#No match
+
+# All these had to be updated because we understand unicode
+# and this looks like it's expecting single byte matches
+
+# .NET generates \xe4...not sure what's up, might just be different code pages
+/(?i)reg(?:ul(?:[aä]|ae)r|ex)/
+ REGular
+ 0: REGular
+ regulaer
+ 0: regulaer
+ Regex
+ 0: Regex
+ regulär
+ 0: regul\xc3\xa4r
+
+#/Åæåä[à-ÿÀ-ß]+/
+# Åæåäà
+# 0: \xc5\xe6\xe5\xe4\xe0
+# Åæåäÿ
+# 0: \xc5\xe6\xe5\xe4\xff
+# ÅæåäÀ
+# 0: \xc5\xe6\xe5\xe4\xc0
+# Åæåäß
+# 0: \xc5\xe6\xe5\xe4\xdf
+
+/(?<=Z)X./
+ \x84XAZXB
+ 0: XB
+
+/ab cd (?x) de fg/
+ ab cd defg
+ 0: ab cd defg
+
+/ab cd(?x) de fg/
+ ab cddefg
+ 0: ab cddefg
+\= Expect no match
+ abcddefg
+No match
+
+/(?
+ 2:
+ D
+ 0: D
+ 1:
+ 2:
+
+# this is really long with debug -- removing for now
+#/(a|)*\d/
+# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
+# 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
+# 1:
+#\= Expect no match
+# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+#No match
+
+/(?>a|)*\d/
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
+ 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
+\= Expect no match
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+No match
+
+/(?:a|)*\d/
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
+ 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
+\= Expect no match
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+No match
+
+/^(?s)(?>.*)(?
+ 2: a
+
+/(?>(a))b|(a)c/
+ ac
+ 0: ac
+ 1:
+ 2: a
+
+/(?=(a))ab|(a)c/
+ ac
+ 0: ac
+ 1:
+ 2: a
+
+/((?>(a))b|(a)c)/
+ ac
+ 0: ac
+ 1: ac
+ 2:
+ 3: a
+
+/(?=(?>(a))b|(a)c)(..)/
+ ac
+ 0: ac
+ 1:
+ 2: a
+ 3: ac
+
+/(?>(?>(a))b|(a)c)/
+ ac
+ 0: ac
+ 1:
+ 2: a
+
+/((?>(a+)b)+(aabab))/
+ aaaabaaabaabab
+ 0: aaaabaaabaabab
+ 1: aaaabaaabaabab
+ 2: aaa
+ 3: aabab
+
+/(?>a+|ab)+?c/
+\= Expect no match
+ aabc
+No match
+
+/(?>a+|ab)+c/
+\= Expect no match
+ aabc
+No match
+
+/(?:a+|ab)+c/
+ aabc
+ 0: aabc
+
+/^(?:a|ab)+c/
+ aaaabc
+ 0: aaaabc
+
+/(?=abc){0}xyz/
+ xyz
+ 0: xyz
+
+/(?=abc){1}xyz/
+\= Expect no match
+ xyz
+No match
+
+/(?=(a))?./
+ ab
+ 0: a
+ 1: a
+ bc
+ 0: b
+
+/(?=(a))??./
+ ab
+ 0: a
+ bc
+ 0: b
+
+/^(?!a){0}\w+/
+ aaaaa
+ 0: aaaaa
+
+/(?<=(abc))?xyz/
+ abcxyz
+ 0: xyz
+ 1: abc
+ pqrxyz
+ 0: xyz
+
+/^[g]+/
+ ggg<<>>
+ 0: ggg<<>>
+\= Expect no match
+ \\ga
+No match
+
+/^[ga]+/
+ gggagagaxyz
+ 0: gggagaga
+
+/[:a]xxx[b:]/
+ :xxx:
+ 0: :xxx:
+
+/(?<=a{2})b/i
+ xaabc
+ 0: b
+\= Expect no match
+ xabc
+No match
+
+/(?
+# 4:
+# 5: c
+# 6: d
+# 7: Y
+
+#/^X(?7)(a)(?|(b|(?|(r)|(t))(s))|(q))(c)(d)(Y)/
+# XYabcdY
+# 0: XYabcdY
+# 1: a
+# 2: b
+# 3:
+# 4:
+# 5: c
+# 6: d
+# 7: Y
+
+/(?'abc'\w+):\k{2}/
+ a:aaxyz
+ 0: a:aa
+ 1: a
+ ab:ababxyz
+ 0: ab:abab
+ 1: ab
+\= Expect no match
+ a:axyz
+No match
+ ab:abxyz
+No match
+
+/^(?a)? (?(ab)b|c) (?(ab)d|e)/x
+ abd
+ 0: abd
+ 1: a
+ ce
+ 0: ce
+
+# .NET has more consistent grouping numbers with these dupe groups for the two options
+/(?:a(? (?')|(?")) |b(? (?')|(?")) ) (?(quote)[a-z]+|[0-9]+)/x,dupnames
+ a\"aaaaa
+ 0: a"aaaaa
+ 1: "
+ 2:
+ 3: "
+ b\"aaaaa
+ 0: b"aaaaa
+ 1: "
+ 2:
+ 3: "
+\= Expect no match
+ b\"11111
+No match
+
+#/(?P(?P0)(?P>L1)|(?P>L2))/
+# 0
+# 0: 0
+# 1: 0
+# 00
+# 0: 00
+# 1: 00
+# 2: 0
+# 0000
+# 0: 0000
+# 1: 0000
+# 2: 0
+
+#/(?P(?P0)|(?P>L2)(?P>L1))/
+# 0
+# 0: 0
+# 1: 0
+# 2: 0
+# 00
+# 0: 0
+# 1: 0
+# 2: 0
+# 0000
+# 0: 0
+# 1: 0
+# 2: 0
+
+# Check the use of names for failure
+
+# Check opening parens in comment when seeking forward reference.
+
+#/(?P(?P=abn)xxx|)+/
+# xxx
+# 0:
+# 1:
+
+#Posses
+/^(a)?(\w)/
+ aaaaX
+ 0: aa
+ 1: a
+ 2: a
+ YZ
+ 0: Y
+ 1:
+ 2: Y
+
+#Posses
+/^(?:a)?(\w)/
+ aaaaX
+ 0: aa
+ 1: a
+ YZ
+ 0: Y
+ 1: Y
+
+/\A.*?(a|bc)/
+ ba
+ 0: ba
+ 1: a
+
+/\A.*?(?:a|bc|d)/
+ ba
+ 0: ba
+
+# --------------------------
+
+/(another)?(\1?)test/
+ hello world test
+ 0: test
+ 1:
+ 2:
+
+/(another)?(\1+)test/
+\= Expect no match
+ hello world test
+No match
+
+/((?:a?)*)*c/
+ aac
+ 0: aac
+ 1:
+
+/((?>a?)*)*c/
+ aac
+ 0: aac
+ 1:
+
+/(?>.*?a)(?<=ba)/
+ aba
+ 0: ba
+
+/(?:.*?a)(?<=ba)/
+ aba
+ 0: aba
+
+/(?>.*?a)b/s
+ aab
+ 0: ab
+
+/(?>.*?a)b/
+ aab
+ 0: ab
+
+/(?>^a)b/s
+\= Expect no match
+ aab
+No match
+
+/(?>.*?)(?<=(abcd)|(wxyz))/
+ alphabetabcd
+ 0:
+ 1: abcd
+ endingwxyz
+ 0:
+ 1:
+ 2: wxyz
+
+/(?>.*)(?<=(abcd)|(wxyz))/
+ alphabetabcd
+ 0: alphabetabcd
+ 1: abcd
+ endingwxyz
+ 0: endingwxyz
+ 1:
+ 2: wxyz
+
+"(?>.*)foo"
+\= Expect no match
+ abcdfooxyz
+No match
+
+"(?>.*?)foo"
+ abcdfooxyz
+ 0: foo
+
+# Tests that try to figure out how Perl works. My hypothesis is that the first
+# verb that is backtracked onto is the one that acts. This seems to be the case
+# almost all the time, but there is one exception that is perhaps a bug.
+
+/a(?=bc).|abd/
+ abd
+ 0: abd
+ abc
+ 0: ab
+
+/a(?>bc)d|abd/
+ abceabd
+ 0: abd
+
+# These tests were formerly in test 2, but changes in PCRE and Perl have
+# made them compatible.
+
+/^(a)?(?(1)a|b)+$/
+\= Expect no match
+ a
+No match
+
+# ----
+
+/^\d*\w{4}/
+ 1234
+ 0: 1234
+\= Expect no match
+ 123
+No match
+
+/^[^b]*\w{4}/
+ aaaa
+ 0: aaaa
+\= Expect no match
+ aaa
+No match
+
+/^[^b]*\w{4}/i
+ aaaa
+ 0: aaaa
+\= Expect no match
+ aaa
+No match
+
+/^a*\w{4}/
+ aaaa
+ 0: aaaa
+\= Expect no match
+ aaa
+No match
+
+/^a*\w{4}/i
+ aaaa
+ 0: aaaa
+\= Expect no match
+ aaa
+No match
+
+/(?:(?foo)|(?bar))\k/dupnames
+ foofoo
+ 0: foofoo
+ 1: foo
+ barbar
+ 0: barbar
+ 1: bar
+
+# A notable difference between PCRE and .NET. According to
+# the PCRE docs:
+# If you make a subroutine call to a non-unique named
+# subpattern, the one that corresponds to the first
+# occurrence of the name is used. In the absence of
+# duplicate numbers (see the previous section) this is
+# the one with the lowest number.
+# .NET takes the most recently captured number according to MSDN:
+# A backreference refers to the most recent definition of
+# a group (the definition most immediately to the left,
+# when matching left to right). When a group makes multiple
+# captures, a backreference refers to the most recent capture.
+
+#/(?A)(?:(?foo)|(?bar))\k/dupnames
+# AfooA
+# 0: AfooA
+# 1: A
+# 2: foo
+# AbarA
+# 0: AbarA
+# 1: A
+# 2:
+# 3: bar
+#\= Expect no match
+# Afoofoo
+#No match
+# Abarbar
+#No match
+
+/^(\d+)\s+IN\s+SOA\s+(\S+)\s+(\S+)\s*\(\s*$/
+ 1 IN SOA non-sp1 non-sp2(
+ 0: 1 IN SOA non-sp1 non-sp2(
+ 1: 1
+ 2: non-sp1
+ 3: non-sp2
+
+# TODO: .NET's group number ordering here in the second example is a bit odd
+/^ (?:(?A)|(?'B'B)(?A)) (?(A)x) (?(B)y)$/x,dupnames
+ Ax
+ 0: Ax
+ 1: A
+ BAxy
+ 0: BAxy
+ 1: A
+ 2: B
+
+/ ^ a + b $ /x
+ aaaab
+ 0: aaaab
+
+/ ^ a + #comment
+ b $ /x
+ aaaab
+ 0: aaaab
+
+/ ^ a + #comment
+ #comment
+ b $ /x
+ aaaab
+ 0: aaaab
+
+/ ^ (?> a + ) b $ /x
+ aaaab
+ 0: aaaab
+
+/ ^ ( a + ) + \w $ /x
+ aaaab
+ 0: aaaab
+ 1: aaaa
+
+/(?:x|(?:(xx|yy)+|x|x|x|x|x)|a|a|a)bc/
+\= Expect no match
+ acb
+No match
+
+#Posses
+#/\A(?:[^\"]+|\"(?:[^\"]*|\"\")*\")+/
+# NON QUOTED \"QUOT\"\"ED\" AFTER \"NOT MATCHED
+# 0: NON QUOTED "QUOT""ED" AFTER
+
+#Posses
+#/\A(?:[^\"]+|\"(?:[^\"]+|\"\")*\")+/
+# NON QUOTED \"QUOT\"\"ED\" AFTER \"NOT MATCHED
+# 0: NON QUOTED "QUOT""ED" AFTER
+
+#Posses
+#/\A(?:[^\"]+|\"(?:[^\"]+|\"\")+\")+/
+# NON QUOTED \"QUOT\"\"ED\" AFTER \"NOT MATCHED
+# 0: NON QUOTED "QUOT""ED" AFTER
+
+#Posses
+#/\A([^\"1]+|[\"2]([^\"3]*|[\"4][\"5])*[\"6])+/
+# NON QUOTED \"QUOT\"\"ED\" AFTER \"NOT MATCHED
+# 0: NON QUOTED "QUOT""ED" AFTER
+# 1: AFTER
+# 2:
+
+/^\w+(?>\s*)(?<=\w)/
+ test test
+ 0: tes
+
+#/(?Pa)?(?Pb)?(?()c|d)*l/
+# acl
+# 0: acl
+# 1: a
+# bdl
+# 0: bdl
+# 1:
+# 2: b
+# adl
+# 0: dl
+# bcl
+# 0: l
+
+/\sabc/
+ \x0babc
+ 0: \x0babc
+
+#/[\Qa]\E]+/
+# aa]]
+# 0: aa]]
+
+#/[\Q]a\E]+/
+# aa]]
+# 0: aa]]
+
+/A((((((((a))))))))\8B/
+ AaaB
+ 0: AaaB
+ 1: a
+ 2: a
+ 3: a
+ 4: a
+ 5: a
+ 6: a
+ 7: a
+ 8: a
+
+/A(((((((((a)))))))))\9B/
+ AaaB
+ 0: AaaB
+ 1: a
+ 2: a
+ 3: a
+ 4: a
+ 5: a
+ 6: a
+ 7: a
+ 8: a
+ 9: a
+
+/(|ab)*?d/
+ abd
+ 0: abd
+ 1: ab
+ xyd
+ 0: d
+
+/(\2|a)(\1)/
+ aaa
+ 0: aa
+ 1: a
+ 2: a
+
+/(\2)(\1)/
+
+"Z*(|d*){216}"
+
+/((((((((((((x))))))))))))\12/
+ xx
+ 0: xx
+ 1: x
+ 2: x
+ 3: x
+ 4: x
+ 5: x
+ 6: x
+ 7: x
+ 8: x
+ 9: x
+10: x
+11: x
+12: x
+
+#"(?|(\k'Pm')|(?'Pm'))"
+# abcd
+# 0:
+# 1:
+
+#/(?|(aaa)|(b))\g{1}/
+# aaaaaa
+# 0: aaaaaa
+# 1: aaa
+# bb
+# 0: bb
+# 1: b
+
+#/(?|(aaa)|(b))(?1)/
+# aaaaaa
+# 0: aaaaaa
+# 1: aaa
+# baaa
+# 0: baaa
+# 1: b
+#\= Expect no match
+# bb
+#No match
+
+#/(?|(aaa)|(b))/
+# xaaa
+# 0: aaa
+# 1: aaa
+# xbc
+# 0: b
+# 1: b
+
+#/(?|(?'a'aaa)|(?'a'b))\k'a'/
+# aaaaaa
+# 0: aaaaaa
+# 1: aaa
+# bb
+# 0: bb
+# 1: b
+
+#/(?|(?'a'aaa)|(?'a'b))(?'a'cccc)\k'a'/dupnames
+# aaaccccaaa
+# 0: aaaccccaaa
+# 1: aaa
+# 2: cccc
+# bccccb
+# 0: bccccb
+# 1: b
+# 2: cccc
+
+# End of testinput1
diff --git a/vendor/github.com/eknkc/amber/.travis.yml b/vendor/github.com/eknkc/amber/.travis.yml
new file mode 100644
index 0000000..fa3d8d3
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/.travis.yml
@@ -0,0 +1,7 @@
+language: go
+
+go:
+ - tip
+
+script:
+ - go test -v ./...
diff --git a/vendor/github.com/eknkc/amber/LICENSE b/vendor/github.com/eknkc/amber/LICENSE
new file mode 100644
index 0000000..77dfb91
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/LICENSE
@@ -0,0 +1,9 @@
+(The MIT License)
+
+Copyright (c) 2012 Ekin Koc ekin@eknkc.com
+
+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/eknkc/amber/README.md b/vendor/github.com/eknkc/amber/README.md
new file mode 100644
index 0000000..ec0e52f
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/README.md
@@ -0,0 +1,442 @@
+# amber [![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](http://godoc.org/github.com/eknkc/amber) [![Build Status](https://travis-ci.org/eknkc/amber.svg?branch=master)](https://travis-ci.org/eknkc/amber)
+
+## Notice
+> While Amber is perfectly fine and stable to use, I've been working on a direct Pug.js port for Go. It is somewhat hacky at the moment but take a look at [Pug.go](https://github.com/eknkc/pug) if you are looking for a [Pug.js](https://github.com/pugjs/pug) compatible Go template engine.
+
+### Usage
+```go
+import "github.com/eknkc/amber"
+```
+
+Amber is an elegant templating engine for Go Programming Language
+It is inspired from HAML and Jade
+
+### Tags
+
+A tag is simply a word:
+
+ html
+
+is converted to
+
+```html
+
+```
+
+It is possible to add ID and CLASS attributes to tags:
+
+ div#main
+ span.time
+
+are converted to
+
+```html
+
+
+```
+
+Any arbitrary attribute name / value pair can be added this way:
+
+ a[href="http://www.google.com"]
+
+You can mix multiple attributes together
+
+ a#someid[href="/"][title="Main Page"].main.link Click Link
+
+gets converted to
+
+```html
+Click Link
+```
+
+It is also possible to define these attributes within the block of a tag
+
+ a
+ #someid
+ [href="/"]
+ [title="Main Page"]
+ .main
+ .link
+ | Click Link
+
+### Doctypes
+
+To add a doctype, use `!!!` or `doctype` keywords:
+
+ !!! transitional
+ //
+
+or use `doctype`
+
+ doctype 5
+ //
+
+Available options: `5`, `default`, `xml`, `transitional`, `strict`, `frameset`, `1.1`, `basic`, `mobile`
+
+### Tag Content
+
+For single line tag text, you can just append the text after tag name:
+
+ p Testing!
+
+would yield
+
+ Testing!
+
+For multi line tag text, or nested tags, use indentation:
+
+ html
+ head
+ title Page Title
+ body
+ div#content
+ p
+ | This is a long page content
+ | These lines are all part of the parent p
+
+ a[href="/"] Go To Main Page
+
+### Data
+
+Input template data can be reached by key names directly. For example, assuming the template has been
+executed with following JSON data:
+
+```json
+{
+ "Name": "Ekin",
+ "LastName": "Koc",
+ "Repositories": [
+ "amber",
+ "dateformat"
+ ],
+ "Avatar": "/images/ekin.jpg",
+ "Friends": 17
+}
+```
+
+It is possible to interpolate fields using `#{}`
+
+ p Welcome #{Name}!
+
+would print
+
+```html
+Welcome Ekin!
+```
+
+Attributes can have field names as well
+
+ a[title=Name][href="/ekin.koc"]
+
+would print
+
+```html
+
+```
+
+### Expressions
+
+Amber can expand basic expressions. For example, it is possible to concatenate strings with + operator:
+
+ p Welcome #{Name + " " + LastName}
+
+Arithmetic expressions are also supported:
+
+ p You need #{50 - Friends} more friends to reach 50!
+
+Expressions can be used within attributes
+
+ img[alt=Name + " " + LastName][src=Avatar]
+
+### Variables
+
+It is possible to define dynamic variables within templates,
+all variables must start with a $ character and can be assigned as in the following example:
+
+ div
+ $fullname = Name + " " + LastName
+ p Welcome #{$fullname}
+
+If you need to access the supplied data itself (i.e. the object containing Name, LastName etc fields.) you can use `$` variable
+
+ p $.Name
+
+### Conditions
+
+For conditional blocks, it is possible to use `if `
+
+ div
+ if Friends > 10
+ p You have more than 10 friends
+ else if Friends > 5
+ p You have more than 5 friends
+ else
+ p You need more friends
+
+Again, it is possible to use arithmetic and boolean operators
+
+ div
+ if Name == "Ekin" && LastName == "Koc"
+ p Hey! I know you..
+
+There is a special syntax for conditional attributes. Only block attributes can have conditions;
+
+ div
+ .hasfriends ? Friends > 0
+
+This would yield a div with `hasfriends` class only if the `Friends > 0` condition holds. It is
+perfectly fine to use the same method for other types of attributes:
+
+ div
+ #foo ? Name == "Ekin"
+ [bar=baz] ? len(Repositories) > 0
+
+### Iterations
+
+It is possible to iterate over arrays and maps using `each`:
+
+ each $repo in Repositories
+ p #{$repo}
+
+would print
+
+ p amber
+ p dateformat
+
+It is also possible to iterate over values and indexes at the same time
+
+ each $i, $repo in Repositories
+ p
+ .even ? $i % 2 == 0
+ .odd ? $i % 2 == 1
+
+### Mixins
+
+Mixins (reusable template blocks that accept arguments) can be defined:
+
+ mixin surprise
+ span Surprise!
+ mixin link($href, $title, $text)
+ a[href=$href][title=$title] #{$text}
+
+and then called multiple times within a template (or even within another mixin definition):
+
+ div
+ +surprise
+ +surprise
+ +link("http://google.com", "Google", "Check out Google")
+
+Template data, variables, expressions, etc., can all be passed as arguments:
+
+ +link(GoogleUrl, $googleTitle, "Check out " + $googleTitle)
+
+### Imports
+
+A template can import other templates using `import`:
+
+ a.amber
+ p this is template a
+
+ b.amber
+ p this is template b
+
+ c.amber
+ div
+ import a
+ import b
+
+gets compiled to
+
+ div
+ p this is template a
+ p this is template b
+
+### Inheritance
+
+A template can inherit other templates. In order to inherit another template, an `extends` keyword should be used.
+Parent template can define several named blocks and child template can modify the blocks.
+
+ master.amber
+ !!! 5
+ html
+ head
+ block meta
+ meta[name="description"][content="This is a great website"]
+
+ title
+ block title
+ | Default title
+ body
+ block content
+
+ subpage.amber
+ extends master
+
+ block title
+ | Some sub page!
+
+ block append meta
+ // This will be added after the description meta tag. It is also possible
+ // to prepend someting to an existing block
+ meta[name="keywords"][content="foo bar"]
+
+ block content
+ div#main
+ p Some content here
+
+### License
+(The MIT License)
+
+Copyright (c) 2012 Ekin Koc
+
+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.
+
+## Usage
+
+```go
+var DefaultOptions = Options{true, false}
+var DefaultDirOptions = DirOptions{".amber", true}
+```
+
+#### func Compile
+
+```go
+func Compile(input string, options Options) (*template.Template, error)
+```
+Parses and compiles the supplied amber template string. Returns corresponding Go
+Template (html/templates) instance. Necessary runtime functions will be injected
+and the template will be ready to be executed.
+
+#### func CompileFile
+
+```go
+func CompileFile(filename string, options Options) (*template.Template, error)
+```
+Parses and compiles the contents of supplied filename. Returns corresponding Go
+Template (html/templates) instance. Necessary runtime functions will be injected
+and the template will be ready to be executed.
+
+#### func CompileDir
+```go
+func CompileDir(dirname string, dopt DirOptions, opt Options) (map[string]*template.Template, error)
+```
+Parses and compiles the contents of a supplied directory name. Returns a mapping of template name (extension stripped) to corresponding Go Template (html/template) instance. Necessary runtime functions will be injected and the template will be ready to be executed.
+
+If there are templates in subdirectories, its key in the map will be it's path relative to `dirname`. For example:
+```
+templates/
+ |-- index.amber
+ |-- layouts/
+ |-- base.amber
+```
+```go
+templates, err := amber.CompileDir("templates/", amber.DefaultDirOptions, amber.DefaultOptions)
+templates["index"] // index.amber Go Template
+templates["layouts/base"] // base.amber Go Template
+```
+By default, the search will be recursive and will match only files ending in ".amber". If recursive is turned off, it will only search the top level of the directory. Specified extension must start with a period.
+
+#### type Compiler
+
+```go
+type Compiler struct {
+ // Compiler options
+ Options
+}
+```
+
+Compiler is the main interface of Amber Template Engine. In order to use an
+Amber template, it is required to create a Compiler and compile an Amber source
+to native Go template.
+
+ compiler := amber.New()
+ // Parse the input file
+ err := compiler.ParseFile("./input.amber")
+ if err == nil {
+ // Compile input file to Go template
+ tpl, err := compiler.Compile()
+ if err == nil {
+ // Check built in html/template documentation for further details
+ tpl.Execute(os.Stdout, somedata)
+ }
+ }
+
+#### func New
+
+```go
+func New() *Compiler
+```
+Create and initialize a new Compiler
+
+#### func (*Compiler) Compile
+
+```go
+func (c *Compiler) Compile() (*template.Template, error)
+```
+Compile amber and create a Go Template (html/templates) instance. Necessary
+runtime functions will be injected and the template will be ready to be
+executed.
+
+#### func (*Compiler) CompileString
+
+```go
+func (c *Compiler) CompileString() (string, error)
+```
+Compile template and return the Go Template source You would not be using this
+unless debugging / checking the output. Please use Compile method to obtain a
+template instance directly.
+
+#### func (*Compiler) CompileWriter
+
+```go
+func (c *Compiler) CompileWriter(out io.Writer) (err error)
+```
+Compile amber and write the Go Template source into given io.Writer instance You
+would not be using this unless debugging / checking the output. Please use
+Compile method to obtain a template instance directly.
+
+#### func (*Compiler) Parse
+
+```go
+func (c *Compiler) Parse(input string) (err error)
+```
+Parse given raw amber template string.
+
+#### func (*Compiler) ParseFile
+
+```go
+func (c *Compiler) ParseFile(filename string) (err error)
+```
+Parse the amber template file in given path
+
+#### type Options
+
+```go
+type Options struct {
+ // Setting if pretty printing is enabled.
+ // Pretty printing ensures that the output html is properly indented and in human readable form.
+ // If disabled, produced HTML is compact. This might be more suitable in production environments.
+ // Defaukt: true
+ PrettyPrint bool
+ // Setting if line number emitting is enabled
+ // In this form, Amber emits line number comments in the output template. It is usable in debugging environments.
+ // Default: false
+ LineNumbers bool
+}
+```
+
+#### type DirOptions
+
+```go
+// Used to provide options to directory compilation
+type DirOptions struct {
+ // File extension to match for compilation
+ Ext string
+ // Whether or not to walk subdirectories
+ Recursive bool
+}
+```
diff --git a/vendor/github.com/eknkc/amber/compiler.go b/vendor/github.com/eknkc/amber/compiler.go
new file mode 100644
index 0000000..bec57b7
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/compiler.go
@@ -0,0 +1,844 @@
+package amber
+
+import (
+ "bytes"
+ "container/list"
+ "errors"
+ "fmt"
+ "go/ast"
+ gp "go/parser"
+ gt "go/token"
+ "html/template"
+ "io"
+ "net/http"
+ "os"
+ "path/filepath"
+ "reflect"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+
+ "github.com/eknkc/amber/parser"
+)
+
+var builtinFunctions = [...]string{
+ "len",
+ "print",
+ "printf",
+ "println",
+ "urlquery",
+ "js",
+ "json",
+ "index",
+ "html",
+ "unescaped",
+}
+
+const (
+ dollar = "__DOLLAR__"
+)
+
+// Compiler is the main interface of Amber Template Engine.
+// In order to use an Amber template, it is required to create a Compiler and
+// compile an Amber source to native Go template.
+// compiler := amber.New()
+// // Parse the input file
+// err := compiler.ParseFile("./input.amber")
+// if err == nil {
+// // Compile input file to Go template
+// tpl, err := compiler.Compile()
+// if err == nil {
+// // Check built in html/template documentation for further details
+// tpl.Execute(os.Stdout, somedata)
+// }
+// }
+type Compiler struct {
+ // Compiler options
+ Options
+ filename string
+ node parser.Node
+ indentLevel int
+ newline bool
+ buffer *bytes.Buffer
+ tempvarIndex int
+ mixins map[string]*parser.Mixin
+}
+
+// New creates and initialize a new Compiler.
+func New() *Compiler {
+ compiler := new(Compiler)
+ compiler.filename = ""
+ compiler.tempvarIndex = 0
+ compiler.PrettyPrint = true
+ compiler.Options = DefaultOptions
+ compiler.mixins = make(map[string]*parser.Mixin)
+
+ return compiler
+}
+
+// Options defines template output behavior.
+type Options struct {
+ // Setting if pretty printing is enabled.
+ // Pretty printing ensures that the output html is properly indented and in human readable form.
+ // If disabled, produced HTML is compact. This might be more suitable in production environments.
+ // Default: true
+ PrettyPrint bool
+ // Setting if line number emitting is enabled
+ // In this form, Amber emits line number comments in the output template. It is usable in debugging environments.
+ // Default: false
+ LineNumbers bool
+ // Setting the virtual filesystem to use
+ // If set, will attempt to use a virtual filesystem provided instead of os.
+ // Default: nil
+ VirtualFilesystem http.FileSystem
+}
+
+// DirOptions is used to provide options to directory compilation.
+type DirOptions struct {
+ // File extension to match for compilation
+ Ext string
+ // Whether or not to walk subdirectories
+ Recursive bool
+}
+
+// DefaultOptions sets pretty-printing to true and line numbering to false.
+var DefaultOptions = Options{true, false, nil}
+
+// DefaultDirOptions sets expected file extension to ".amber" and recursive search for templates within a directory to true.
+var DefaultDirOptions = DirOptions{".amber", true}
+
+// Compile parses and compiles the supplied amber template string. Returns corresponding Go Template (html/templates) instance.
+// Necessary runtime functions will be injected and the template will be ready to be executed.
+func Compile(input string, options Options) (*template.Template, error) {
+ comp := New()
+ comp.Options = options
+
+ err := comp.Parse(input)
+ if err != nil {
+ return nil, err
+ }
+
+ return comp.Compile()
+}
+
+// Compile parses and compiles the supplied amber template []byte.
+// Returns corresponding Go Template (html/templates) instance.
+// Necessary runtime functions will be injected and the template will be ready to be executed.
+func CompileData(input []byte, filename string, options Options) (*template.Template, error) {
+ comp := New()
+ comp.Options = options
+
+ err := comp.ParseData(input, filename)
+ if err != nil {
+ return nil, err
+ }
+
+ return comp.Compile()
+}
+
+// MustCompile is the same as Compile, except the input is assumed error free. If else, panic.
+func MustCompile(input string, options Options) *template.Template {
+ t, err := Compile(input, options)
+ if err != nil {
+ panic(err)
+ }
+ return t
+}
+
+// CompileFile parses and compiles the contents of supplied filename. Returns corresponding Go Template (html/templates) instance.
+// Necessary runtime functions will be injected and the template will be ready to be executed.
+func CompileFile(filename string, options Options) (*template.Template, error) {
+ comp := New()
+ comp.Options = options
+
+ err := comp.ParseFile(filename)
+ if err != nil {
+ return nil, err
+ }
+
+ return comp.Compile()
+}
+
+// MustCompileFile is the same as CompileFile, except the input is assumed error free. If else, panic.
+func MustCompileFile(filename string, options Options) *template.Template {
+ t, err := CompileFile(filename, options)
+ if err != nil {
+ panic(err)
+ }
+ return t
+}
+
+// CompileDir parses and compiles the contents of a supplied directory path, with options.
+// Returns a map of a template identifier (key) to a Go Template instance.
+// Ex: if the dirname="templates/" had a file "index.amber" the key would be "index"
+// If option for recursive is True, this parses every file of relevant extension
+// in all subdirectories. The key then is the path e.g: "layouts/layout"
+func CompileDir(dirname string, dopt DirOptions, opt Options) (map[string]*template.Template, error) {
+ dir, err := os.Open(dirname)
+ if err != nil && opt.VirtualFilesystem != nil {
+ vdir, err := opt.VirtualFilesystem.Open(dirname)
+ if err != nil {
+ return nil, err
+ }
+ dir = vdir.(*os.File)
+ } else if err != nil {
+ return nil, err
+ }
+ defer dir.Close()
+
+ files, err := dir.Readdir(0)
+ if err != nil {
+ return nil, err
+ }
+
+ compiled := make(map[string]*template.Template)
+ for _, file := range files {
+ // filename is for example "index.amber"
+ filename := file.Name()
+ fileext := filepath.Ext(filename)
+
+ // If recursive is true and there's a subdirectory, recurse
+ if dopt.Recursive && file.IsDir() {
+ dirpath := filepath.Join(dirname, filename)
+ subcompiled, err := CompileDir(dirpath, dopt, opt)
+ if err != nil {
+ return nil, err
+ }
+ // Copy templates from subdirectory into parent template mapping
+ for k, v := range subcompiled {
+ // Concat with parent directory name for unique paths
+ key := filepath.Join(filename, k)
+ compiled[key] = v
+ }
+ } else if fileext == dopt.Ext {
+ // Otherwise compile the file and add to mapping
+ fullpath := filepath.Join(dirname, filename)
+ tmpl, err := CompileFile(fullpath, opt)
+ if err != nil {
+ return nil, err
+ }
+ // Strip extension
+ key := filename[0 : len(filename)-len(fileext)]
+ compiled[key] = tmpl
+ }
+ }
+
+ return compiled, nil
+}
+
+// MustCompileDir is the same as CompileDir, except input is assumed error free. If else, panic.
+func MustCompileDir(dirname string, dopt DirOptions, opt Options) map[string]*template.Template {
+ m, err := CompileDir(dirname, dopt, opt)
+ if err != nil {
+ panic(err)
+ }
+ return m
+}
+
+// Parse given raw amber template string.
+func (c *Compiler) Parse(input string) (err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ err = errors.New(r.(string))
+ }
+ }()
+
+ parser, err := parser.StringParser(input)
+
+ if err != nil {
+ return
+ }
+
+ c.node = parser.Parse()
+ return
+}
+
+// Parse given raw amber template bytes, and the filename that belongs with it
+func (c *Compiler) ParseData(input []byte, filename string) (err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ err = errors.New(r.(string))
+ }
+ }()
+
+ parser, err := parser.ByteParser(input)
+ parser.SetFilename(filename)
+ if c.VirtualFilesystem != nil {
+ parser.SetVirtualFilesystem(c.VirtualFilesystem)
+ }
+
+ if err != nil {
+ return
+ }
+
+ c.node = parser.Parse()
+ return
+}
+
+// ParseFile parses the amber template file in given path.
+func (c *Compiler) ParseFile(filename string) (err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ err = errors.New(r.(string))
+ }
+ }()
+
+ p, err := parser.FileParser(filename)
+ if err != nil && c.VirtualFilesystem != nil {
+ p, err = parser.VirtualFileParser(filename, c.VirtualFilesystem)
+ }
+ if err != nil {
+ return
+ }
+
+ c.node = p.Parse()
+ c.filename = filename
+ return
+}
+
+// Compile amber and create a Go Template (html/templates) instance.
+// Necessary runtime functions will be injected and the template will be ready to be executed.
+func (c *Compiler) Compile() (*template.Template, error) {
+ return c.CompileWithName(filepath.Base(c.filename))
+}
+
+// CompileWithName is the same as Compile, but allows to specify a name for the template.
+func (c *Compiler) CompileWithName(name string) (*template.Template, error) {
+ return c.CompileWithTemplate(template.New(name))
+}
+
+// CompileWithTemplate is the same as Compile but allows to specify a template.
+func (c *Compiler) CompileWithTemplate(t *template.Template) (*template.Template, error) {
+ data, err := c.CompileString()
+
+ if err != nil {
+ return nil, err
+ }
+
+ tpl, err := t.Funcs(FuncMap).Parse(data)
+
+ if err != nil {
+ return nil, err
+ }
+
+ return tpl, nil
+}
+
+// CompileWriter compiles amber and writes the Go Template source into given io.Writer instance.
+// You would not be using this unless debugging / checking the output. Please use Compile
+// method to obtain a template instance directly.
+func (c *Compiler) CompileWriter(out io.Writer) (err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ err = errors.New(r.(string))
+ }
+ }()
+
+ c.buffer = new(bytes.Buffer)
+ c.visit(c.node)
+
+ if c.buffer.Len() > 0 {
+ c.write("\n")
+ }
+
+ _, err = c.buffer.WriteTo(out)
+ return
+}
+
+// CompileString compiles the template and returns the Go Template source.
+// You would not be using this unless debugging / checking the output. Please use Compile
+// method to obtain a template instance directly.
+func (c *Compiler) CompileString() (string, error) {
+ var buf bytes.Buffer
+
+ if err := c.CompileWriter(&buf); err != nil {
+ return "", err
+ }
+
+ result := buf.String()
+
+ return result, nil
+}
+
+func (c *Compiler) visit(node parser.Node) {
+ defer func() {
+ if r := recover(); r != nil {
+ if rs, ok := r.(string); ok && rs[:len("Amber Error")] == "Amber Error" {
+ panic(r)
+ }
+
+ pos := node.Pos()
+
+ if len(pos.Filename) > 0 {
+ panic(fmt.Sprintf("Amber Error in <%s>: %v - Line: %d, Column: %d, Length: %d", pos.Filename, r, pos.LineNum, pos.ColNum, pos.TokenLength))
+ } else {
+ panic(fmt.Sprintf("Amber Error: %v - Line: %d, Column: %d, Length: %d", r, pos.LineNum, pos.ColNum, pos.TokenLength))
+ }
+ }
+ }()
+
+ switch node.(type) {
+ case *parser.Block:
+ c.visitBlock(node.(*parser.Block))
+ case *parser.Doctype:
+ c.visitDoctype(node.(*parser.Doctype))
+ case *parser.Comment:
+ c.visitComment(node.(*parser.Comment))
+ case *parser.Tag:
+ c.visitTag(node.(*parser.Tag))
+ case *parser.Text:
+ c.visitText(node.(*parser.Text))
+ case *parser.Condition:
+ c.visitCondition(node.(*parser.Condition))
+ case *parser.Each:
+ c.visitEach(node.(*parser.Each))
+ case *parser.Assignment:
+ c.visitAssignment(node.(*parser.Assignment))
+ case *parser.Mixin:
+ c.visitMixin(node.(*parser.Mixin))
+ case *parser.MixinCall:
+ c.visitMixinCall(node.(*parser.MixinCall))
+ }
+}
+
+func (c *Compiler) write(value string) {
+ c.buffer.WriteString(value)
+}
+
+func (c *Compiler) indent(offset int, newline bool) {
+ if !c.PrettyPrint {
+ return
+ }
+
+ if newline && c.buffer.Len() > 0 {
+ c.write("\n")
+ }
+
+ for i := 0; i < c.indentLevel+offset; i++ {
+ c.write("\t")
+ }
+}
+
+func (c *Compiler) tempvar() string {
+ c.tempvarIndex++
+ return "$__amber_" + strconv.Itoa(c.tempvarIndex)
+}
+
+func (c *Compiler) escape(input string) string {
+ return strings.Replace(strings.Replace(input, `\`, `\\`, -1), `"`, `\"`, -1)
+}
+
+func (c *Compiler) visitBlock(block *parser.Block) {
+ for _, node := range block.Children {
+ if _, ok := node.(*parser.Text); !block.CanInline() && ok {
+ c.indent(0, true)
+ }
+
+ c.visit(node)
+ }
+}
+
+func (c *Compiler) visitDoctype(doctype *parser.Doctype) {
+ c.write(doctype.String())
+}
+
+func (c *Compiler) visitComment(comment *parser.Comment) {
+ if comment.Silent {
+ return
+ }
+
+ c.indent(0, false)
+
+ if comment.Block == nil {
+ c.write(`{{unescaped ""}}`)
+ } else {
+ c.write(``)
+ }
+}
+
+func (c *Compiler) visitCondition(condition *parser.Condition) {
+ c.write(`{{if ` + c.visitRawInterpolation(condition.Expression) + `}}`)
+ c.visitBlock(condition.Positive)
+ if condition.Negative != nil {
+ c.write(`{{else}}`)
+ c.visitBlock(condition.Negative)
+ }
+ c.write(`{{end}}`)
+}
+
+func (c *Compiler) visitEach(each *parser.Each) {
+ if each.Block == nil {
+ return
+ }
+
+ if len(each.Y) == 0 {
+ c.write(`{{range ` + each.X + ` := ` + c.visitRawInterpolation(each.Expression) + `}}`)
+ } else {
+ c.write(`{{range ` + each.X + `, ` + each.Y + ` := ` + c.visitRawInterpolation(each.Expression) + `}}`)
+ }
+ c.visitBlock(each.Block)
+ c.write(`{{end}}`)
+}
+
+func (c *Compiler) visitAssignment(assgn *parser.Assignment) {
+ c.write(`{{` + assgn.X + ` := ` + c.visitRawInterpolation(assgn.Expression) + `}}`)
+}
+
+func (c *Compiler) visitTag(tag *parser.Tag) {
+ type attrib struct {
+ name string
+ value func() string
+ condition string
+ }
+
+ attribs := make(map[string]*attrib)
+
+ for _, item := range tag.Attributes {
+ attritem := item
+ attr := new(attrib)
+ attr.name = item.Name
+
+ attr.value = func() string {
+ if !attritem.IsRaw {
+ return c.visitInterpolation(attritem.Value)
+ } else if attritem.Value == "" {
+ return ""
+ } else {
+ return attritem.Value
+ }
+ }
+
+ if len(attritem.Condition) != 0 {
+ attr.condition = c.visitRawInterpolation(attritem.Condition)
+ }
+
+ if attr.name == "class" && attribs["class"] != nil {
+ prevclass := attribs["class"]
+ prevvalue := prevclass.value
+
+ prevclass.value = func() string {
+ aval := attr.value()
+
+ if len(attr.condition) > 0 {
+ aval = `{{if ` + attr.condition + `}}` + aval + `{{end}}`
+ }
+
+ if len(prevclass.condition) > 0 {
+ return `{{if ` + prevclass.condition + `}}` + prevvalue() + `{{end}} ` + aval
+ }
+
+ return prevvalue() + " " + aval
+ }
+ } else {
+ attribs[attritem.Name] = attr
+ }
+ }
+
+ keys := make([]string, 0, len(attribs))
+ for key := range attribs {
+ keys = append(keys, key)
+ }
+ sort.Strings(keys)
+
+ c.indent(0, true)
+ c.write("<" + tag.Name)
+
+ for _, name := range keys {
+ value := attribs[name]
+
+ if len(value.condition) > 0 {
+ c.write(`{{if ` + value.condition + `}}`)
+ }
+
+ val := value.value()
+
+ if val == "" {
+ c.write(` ` + name)
+ } else {
+ c.write(` ` + name + `="` + val + `"`)
+ }
+
+ if len(value.condition) > 0 {
+ c.write(`{{end}}`)
+ }
+ }
+
+ if tag.IsSelfClosing() {
+ c.write(` />`)
+ } else {
+ c.write(`>`)
+
+ if tag.Block != nil {
+ if !tag.Block.CanInline() {
+ c.indentLevel++
+ }
+
+ c.visitBlock(tag.Block)
+
+ if !tag.Block.CanInline() {
+ c.indentLevel--
+ c.indent(0, true)
+ }
+ }
+
+ c.write(`` + tag.Name + `>`)
+ }
+}
+
+var textInterpolateRegexp = regexp.MustCompile(`#\{(.*?)\}`)
+var textEscapeRegexp = regexp.MustCompile(`\{\{(.*?)\}\}`)
+
+func (c *Compiler) visitText(txt *parser.Text) {
+ value := textEscapeRegexp.ReplaceAllStringFunc(txt.Value, func(value string) string {
+ return `{{"{{"}}` + value[2:len(value)-2] + `{{"}}"}}`
+ })
+
+ value = textInterpolateRegexp.ReplaceAllStringFunc(value, func(value string) string {
+ return c.visitInterpolation(value[2 : len(value)-1])
+ })
+
+ lines := strings.Split(value, "\n")
+ for i := 0; i < len(lines); i++ {
+ c.write(lines[i])
+
+ if i < len(lines)-1 {
+ c.write("\n")
+ c.indent(0, false)
+ }
+ }
+}
+
+func (c *Compiler) visitInterpolation(value string) string {
+ return `{{` + c.visitRawInterpolation(value) + `}}`
+}
+
+func (c *Compiler) visitRawInterpolation(value string) string {
+ if value == "" {
+ value = "\"\""
+ }
+
+ value = strings.Replace(value, "$", dollar, -1)
+ expr, err := gp.ParseExpr(value)
+ if err != nil {
+ panic("Unable to parse expression.")
+ }
+ value = strings.Replace(c.visitExpression(expr), dollar, "$", -1)
+ return value
+}
+
+func (c *Compiler) visitExpression(outerexpr ast.Expr) string {
+ stack := list.New()
+
+ pop := func() string {
+ if stack.Front() == nil {
+ return ""
+ }
+
+ val := stack.Front().Value.(string)
+ stack.Remove(stack.Front())
+ return val
+ }
+
+ var exec func(ast.Expr)
+
+ exec = func(expr ast.Expr) {
+ switch expr := expr.(type) {
+ case *ast.BinaryExpr:
+ {
+ be := expr
+
+ exec(be.Y)
+ exec(be.X)
+
+ negate := false
+ name := c.tempvar()
+ c.write(`{{` + name + ` := `)
+
+ switch be.Op {
+ case gt.ADD:
+ c.write("__amber_add ")
+ case gt.SUB:
+ c.write("__amber_sub ")
+ case gt.MUL:
+ c.write("__amber_mul ")
+ case gt.QUO:
+ c.write("__amber_quo ")
+ case gt.REM:
+ c.write("__amber_rem ")
+ case gt.LAND:
+ c.write("and ")
+ case gt.LOR:
+ c.write("or ")
+ case gt.EQL:
+ c.write("__amber_eql ")
+ case gt.NEQ:
+ c.write("__amber_eql ")
+ negate = true
+ case gt.LSS:
+ c.write("__amber_lss ")
+ case gt.GTR:
+ c.write("__amber_gtr ")
+ case gt.LEQ:
+ c.write("__amber_gtr ")
+ negate = true
+ case gt.GEQ:
+ c.write("__amber_lss ")
+ negate = true
+ default:
+ panic("Unexpected operator!")
+ }
+
+ c.write(pop() + ` ` + pop() + `}}`)
+
+ if !negate {
+ stack.PushFront(name)
+ } else {
+ negname := c.tempvar()
+ c.write(`{{` + negname + ` := not ` + name + `}}`)
+ stack.PushFront(negname)
+ }
+ }
+ case *ast.UnaryExpr:
+ {
+ ue := expr
+
+ exec(ue.X)
+
+ name := c.tempvar()
+ c.write(`{{` + name + ` := `)
+
+ switch ue.Op {
+ case gt.SUB:
+ c.write("__amber_minus ")
+ case gt.ADD:
+ c.write("__amber_plus ")
+ case gt.NOT:
+ c.write("not ")
+ default:
+ panic("Unexpected operator!")
+ }
+
+ c.write(pop() + `}}`)
+ stack.PushFront(name)
+ }
+ case *ast.ParenExpr:
+ exec(expr.X)
+ case *ast.BasicLit:
+ stack.PushFront(strings.Replace(expr.Value, dollar, "$", -1))
+ case *ast.Ident:
+ name := expr.Name
+ if len(name) >= len(dollar) && name[:len(dollar)] == dollar {
+ if name == dollar {
+ stack.PushFront(`.`)
+ } else {
+ stack.PushFront(`$` + expr.Name[len(dollar):])
+ }
+ } else {
+ stack.PushFront(`.` + expr.Name)
+ }
+ case *ast.SelectorExpr:
+ se := expr
+ exec(se.X)
+ x := pop()
+
+ if x == "." {
+ x = ""
+ }
+
+ name := c.tempvar()
+ c.write(`{{` + name + ` := ` + x + `.` + se.Sel.Name + `}}`)
+ stack.PushFront(name)
+ case *ast.CallExpr:
+ ce := expr
+
+ for i := len(ce.Args) - 1; i >= 0; i-- {
+ exec(ce.Args[i])
+ }
+
+ name := c.tempvar()
+ builtin := false
+
+ if ident, ok := ce.Fun.(*ast.Ident); ok {
+ for _, fname := range builtinFunctions {
+ if fname == ident.Name {
+ builtin = true
+ break
+ }
+ }
+ for fname, _ := range FuncMap {
+ if fname == ident.Name {
+ builtin = true
+ break
+ }
+ }
+ }
+
+ if builtin {
+ stack.PushFront(ce.Fun.(*ast.Ident).Name)
+ c.write(`{{` + name + ` := ` + pop())
+ } else if se, ok := ce.Fun.(*ast.SelectorExpr); ok {
+ exec(se.X)
+ x := pop()
+
+ if x == "." {
+ x = ""
+ }
+ stack.PushFront(se.Sel.Name)
+ c.write(`{{` + name + ` := ` + x + `.` + pop())
+ } else {
+ exec(ce.Fun)
+ c.write(`{{` + name + ` := call ` + pop())
+ }
+
+ for i := 0; i < len(ce.Args); i++ {
+ c.write(` `)
+ c.write(pop())
+ }
+
+ c.write(`}}`)
+
+ stack.PushFront(name)
+ default:
+ panic("Unable to parse expression. Unsupported: " + reflect.TypeOf(expr).String())
+ }
+ }
+
+ exec(outerexpr)
+ return pop()
+}
+
+func (c *Compiler) visitMixin(mixin *parser.Mixin) {
+ c.mixins[mixin.Name] = mixin
+}
+
+func (c *Compiler) visitMixinCall(mixinCall *parser.MixinCall) {
+ mixin := c.mixins[mixinCall.Name]
+
+ switch {
+ case mixin == nil:
+ panic(fmt.Sprintf("unknown mixin %q", mixinCall.Name))
+
+ case len(mixinCall.Args) < len(mixin.Args):
+ panic(fmt.Sprintf(
+ "not enough arguments in call to mixin %q (have: %d, want: %d)",
+ mixinCall.Name,
+ len(mixinCall.Args),
+ len(mixin.Args),
+ ))
+ case len(mixinCall.Args) > len(mixin.Args):
+ panic(fmt.Sprintf(
+ "too many arguments in call to mixin %q (have: %d, want: %d)",
+ mixinCall.Name,
+ len(mixinCall.Args),
+ len(mixin.Args),
+ ))
+ }
+
+ for i, arg := range mixin.Args {
+ c.write(fmt.Sprintf(`{{%s := %s}}`, arg, c.visitRawInterpolation(mixinCall.Args[i])))
+ }
+ c.visitBlock(mixin.Block)
+}
diff --git a/vendor/github.com/eknkc/amber/doc.go b/vendor/github.com/eknkc/amber/doc.go
new file mode 100644
index 0000000..76ee96a
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/doc.go
@@ -0,0 +1,257 @@
+/*
+Package amber is an elegant templating engine for Go Programming Language.
+It is inspired from HAML and Jade.
+
+Tags
+
+A tag is simply a word:
+
+ html
+
+is converted to
+
+
+
+It is possible to add ID and CLASS attributes to tags:
+
+ div#main
+ span.time
+
+are converted to
+
+
+
+
+Any arbitrary attribute name / value pair can be added this way:
+
+ a[href="http://www.google.com"]
+
+You can mix multiple attributes together
+
+ a#someid[href="/"][title="Main Page"].main.link Click Link
+
+gets converted to
+
+ Click Link
+
+It is also possible to define these attributes within the block of a tag
+
+ a
+ #someid
+ [href="/"]
+ [title="Main Page"]
+ .main
+ .link
+ | Click Link
+
+Doctypes
+
+To add a doctype, use `!!!` or `doctype` keywords:
+
+ !!! transitional
+ //
+
+or use `doctype`
+
+ doctype 5
+ //
+
+Available options: `5`, `default`, `xml`, `transitional`, `strict`, `frameset`, `1.1`, `basic`, `mobile`
+
+Tag Content
+
+For single line tag text, you can just append the text after tag name:
+
+ p Testing!
+
+would yield
+
+ Testing!
+
+For multi line tag text, or nested tags, use indentation:
+
+ html
+ head
+ title Page Title
+ body
+ div#content
+ p
+ | This is a long page content
+ | These lines are all part of the parent p
+
+ a[href="/"] Go To Main Page
+
+Data
+
+Input template data can be reached by key names directly. For example, assuming the template has been
+executed with following JSON data:
+
+ {
+ "Name": "Ekin",
+ "LastName": "Koc",
+ "Repositories": [
+ "amber",
+ "dateformat"
+ ],
+ "Avatar": "/images/ekin.jpg",
+ "Friends": 17
+ }
+
+It is possible to interpolate fields using `#{}`
+
+ p Welcome #{Name}!
+
+would print
+
+ Welcome Ekin!
+
+Attributes can have field names as well
+
+ a[title=Name][href="/ekin.koc"]
+
+would print
+
+
+
+Expressions
+
+Amber can expand basic expressions. For example, it is possible to concatenate strings with + operator:
+
+ p Welcome #{Name + " " + LastName}
+
+Arithmetic expressions are also supported:
+
+ p You need #{50 - Friends} more friends to reach 50!
+
+Expressions can be used within attributes
+
+ img[alt=Name + " " + LastName][src=Avatar]
+
+Variables
+
+It is possible to define dynamic variables within templates,
+all variables must start with a $ character and can be assigned as in the following example:
+
+ div
+ $fullname = Name + " " + LastName
+ p Welcome #{$fullname}
+
+If you need to access the supplied data itself (i.e. the object containing Name, LastName etc fields.) you can use `$` variable
+
+ p $.Name
+
+Conditions
+
+For conditional blocks, it is possible to use `if `
+
+ div
+ if Friends > 10
+ p You have more than 10 friends
+ else if Friends > 5
+ p You have more than 5 friends
+ else
+ p You need more friends
+
+Again, it is possible to use arithmetic and boolean operators
+
+ div
+ if Name == "Ekin" && LastName == "Koc"
+ p Hey! I know you..
+
+There is a special syntax for conditional attributes. Only block attributes can have conditions;
+
+ div
+ .hasfriends ? Friends > 0
+
+This would yield a div with `hasfriends` class only if the `Friends > 0` condition holds. It is
+perfectly fine to use the same method for other types of attributes:
+
+ div
+ #foo ? Name == "Ekin"
+ [bar=baz] ? len(Repositories) > 0
+
+Iterations
+
+It is possible to iterate over arrays and maps using `each`:
+
+ each $repo in Repositories
+ p #{$repo}
+
+would print
+
+ p amber
+ p dateformat
+
+It is also possible to iterate over values and indexes at the same time
+
+ each $i, $repo in Repositories
+ p
+ .even ? $i % 2 == 0
+ .odd ? $i % 2 == 1
+
+Includes
+
+A template can include other templates using `include`:
+
+ a.amber
+ p this is template a
+
+ b.amber
+ p this is template b
+
+ c.amber
+ div
+ include a
+ include b
+
+gets compiled to
+
+ div
+ p this is template a
+ p this is template b
+
+Inheritance
+
+A template can inherit other templates. In order to inherit another template, an `extends` keyword should be used.
+Parent template can define several named blocks and child template can modify the blocks.
+
+ master.amber
+ !!! 5
+ html
+ head
+ block meta
+ meta[name="description"][content="This is a great website"]
+
+ title
+ block title
+ | Default title
+ body
+ block content
+
+ subpage.amber
+ extends master
+
+ block title
+ | Some sub page!
+
+ block append meta
+ // This will be added after the description meta tag. It is also possible
+ // to prepend something to an existing block
+ meta[name="keywords"][content="foo bar"]
+
+ block content
+ div#main
+ p Some content here
+
+License
+(The MIT License)
+
+Copyright (c) 2012 Ekin Koc
+
+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.
+*/
+package amber
diff --git a/vendor/github.com/eknkc/amber/parser/nodes.go b/vendor/github.com/eknkc/amber/parser/nodes.go
new file mode 100644
index 0000000..2f75ddd
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/parser/nodes.go
@@ -0,0 +1,285 @@
+package parser
+
+import (
+ "regexp"
+ "strings"
+)
+
+var selfClosingTags = [...]string{
+ "meta",
+ "img",
+ "link",
+ "input",
+ "source",
+ "area",
+ "base",
+ "col",
+ "br",
+ "hr",
+}
+
+var doctypes = map[string]string{
+ "5": ``,
+ "default": ``,
+ "xml": ``,
+ "transitional": ``,
+ "strict": ``,
+ "frameset": ``,
+ "1.1": ``,
+ "basic": ``,
+ "mobile": ``,
+}
+
+type Node interface {
+ Pos() SourcePosition
+}
+
+type SourcePosition struct {
+ LineNum int
+ ColNum int
+ TokenLength int
+ Filename string
+}
+
+func (s *SourcePosition) Pos() SourcePosition {
+ return *s
+}
+
+type Doctype struct {
+ SourcePosition
+ Value string
+}
+
+func newDoctype(value string) *Doctype {
+ dt := new(Doctype)
+ dt.Value = value
+ return dt
+}
+
+func (d *Doctype) String() string {
+ if defined := doctypes[d.Value]; len(defined) != 0 {
+ return defined
+ }
+
+ return ``
+}
+
+type Comment struct {
+ SourcePosition
+ Value string
+ Block *Block
+ Silent bool
+}
+
+func newComment(value string) *Comment {
+ dt := new(Comment)
+ dt.Value = value
+ dt.Block = nil
+ dt.Silent = false
+ return dt
+}
+
+type Text struct {
+ SourcePosition
+ Value string
+ Raw bool
+}
+
+func newText(value string, raw bool) *Text {
+ dt := new(Text)
+ dt.Value = value
+ dt.Raw = raw
+ return dt
+}
+
+type Block struct {
+ SourcePosition
+ Children []Node
+}
+
+func newBlock() *Block {
+ block := new(Block)
+ block.Children = make([]Node, 0)
+ return block
+}
+
+func (b *Block) push(node Node) {
+ b.Children = append(b.Children, node)
+}
+
+func (b *Block) pushFront(node Node) {
+ b.Children = append([]Node{node}, b.Children...)
+}
+
+func (b *Block) CanInline() bool {
+ if len(b.Children) == 0 {
+ return true
+ }
+
+ allText := true
+
+ for _, child := range b.Children {
+ if txt, ok := child.(*Text); !ok || txt.Raw {
+ allText = false
+ break
+ }
+ }
+
+ return allText
+}
+
+const (
+ NamedBlockDefault = iota
+ NamedBlockAppend
+ NamedBlockPrepend
+)
+
+type NamedBlock struct {
+ Block
+ Name string
+ Modifier int
+}
+
+func newNamedBlock(name string) *NamedBlock {
+ bb := new(NamedBlock)
+ bb.Name = name
+ bb.Block.Children = make([]Node, 0)
+ bb.Modifier = NamedBlockDefault
+ return bb
+}
+
+type Attribute struct {
+ SourcePosition
+ Name string
+ Value string
+ IsRaw bool
+ Condition string
+}
+
+type Tag struct {
+ SourcePosition
+ Block *Block
+ Name string
+ IsInterpolated bool
+ Attributes []Attribute
+}
+
+func newTag(name string) *Tag {
+ tag := new(Tag)
+ tag.Block = nil
+ tag.Name = name
+ tag.Attributes = make([]Attribute, 0)
+ tag.IsInterpolated = false
+ return tag
+
+}
+
+func (t *Tag) IsSelfClosing() bool {
+ for _, tag := range selfClosingTags {
+ if tag == t.Name {
+ return true
+ }
+ }
+
+ return false
+}
+
+func (t *Tag) IsRawText() bool {
+ return t.Name == "style" || t.Name == "script"
+}
+
+type Condition struct {
+ SourcePosition
+ Positive *Block
+ Negative *Block
+ Expression string
+}
+
+func newCondition(exp string) *Condition {
+ cond := new(Condition)
+ cond.Expression = exp
+ return cond
+}
+
+type Each struct {
+ SourcePosition
+ X string
+ Y string
+ Expression string
+ Block *Block
+}
+
+func newEach(exp string) *Each {
+ each := new(Each)
+ each.Expression = exp
+ return each
+}
+
+type Assignment struct {
+ SourcePosition
+ X string
+ Expression string
+}
+
+func newAssignment(x, expression string) *Assignment {
+ assgn := new(Assignment)
+ assgn.X = x
+ assgn.Expression = expression
+ return assgn
+}
+
+type Mixin struct {
+ SourcePosition
+ Block *Block
+ Name string
+ Args []string
+}
+
+func newMixin(name, args string) *Mixin {
+ mixin := new(Mixin)
+ mixin.Name = name
+
+ delExp := regexp.MustCompile(`,\s`)
+ mixin.Args = delExp.Split(args, -1)
+
+ for i := 0; i < len(mixin.Args); i++ {
+ mixin.Args[i] = strings.TrimSpace(mixin.Args[i])
+ if mixin.Args[i] == "" {
+ mixin.Args = append(mixin.Args[:i], mixin.Args[i+1:]...)
+ i--
+ }
+ }
+
+ return mixin
+}
+
+type MixinCall struct {
+ SourcePosition
+ Name string
+ Args []string
+}
+
+func newMixinCall(name, args string) *MixinCall {
+ mixinCall := new(MixinCall)
+ mixinCall.Name = name
+
+ if args != "" {
+ const t = "%s"
+ quoteExp := regexp.MustCompile(`"(.*?)"`)
+ delExp := regexp.MustCompile(`,\s`)
+
+ quotes := quoteExp.FindAllString(args, -1)
+ replaced := quoteExp.ReplaceAllString(args, t)
+ mixinCall.Args = delExp.Split(replaced, -1)
+
+ qi := 0
+ for i, arg := range mixinCall.Args {
+ if arg == t {
+ mixinCall.Args[i] = quotes[qi]
+ qi++
+ }
+ }
+ }
+
+ return mixinCall
+}
diff --git a/vendor/github.com/eknkc/amber/parser/parser.go b/vendor/github.com/eknkc/amber/parser/parser.go
new file mode 100644
index 0000000..9769f0b
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/parser/parser.go
@@ -0,0 +1,482 @@
+package parser
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "path/filepath"
+ "strings"
+)
+
+type Parser struct {
+ scanner *scanner
+ filename string
+ fs http.FileSystem
+ currenttoken *token
+ namedBlocks map[string]*NamedBlock
+ parent *Parser
+ result *Block
+}
+
+func newParser(rdr io.Reader) *Parser {
+ p := new(Parser)
+ p.scanner = newScanner(rdr)
+ p.namedBlocks = make(map[string]*NamedBlock)
+ return p
+}
+
+func StringParser(input string) (*Parser, error) {
+ return newParser(bytes.NewReader([]byte(input))), nil
+}
+
+func ByteParser(input []byte) (*Parser, error) {
+ return newParser(bytes.NewReader(input)), nil
+}
+
+func (p *Parser) SetFilename(filename string) {
+ p.filename = filename
+}
+
+func (p *Parser) SetVirtualFilesystem(fs http.FileSystem) {
+ p.fs = fs
+}
+
+func FileParser(filename string) (*Parser, error) {
+ data, err := ioutil.ReadFile(filename)
+
+ if err != nil {
+ return nil, err
+ }
+
+ parser := newParser(bytes.NewReader(data))
+ parser.filename = filename
+ return parser, nil
+}
+
+func VirtualFileParser(filename string, fs http.FileSystem) (*Parser, error) {
+ file, err := fs.Open(filename)
+ if err != nil {
+ return nil, err
+ }
+
+ data, err := ioutil.ReadAll(file)
+ if err != nil {
+ return nil, err
+ }
+
+ parser := newParser(bytes.NewReader(data))
+ parser.filename = filename
+ parser.fs = fs
+ return parser, nil
+}
+
+func (p *Parser) Parse() *Block {
+ if p.result != nil {
+ return p.result
+ }
+
+ defer func() {
+ if r := recover(); r != nil {
+ if rs, ok := r.(string); ok && rs[:len("Amber Error")] == "Amber Error" {
+ panic(r)
+ }
+
+ pos := p.pos()
+
+ if len(pos.Filename) > 0 {
+ panic(fmt.Sprintf("Amber Error in <%s>: %v - Line: %d, Column: %d, Length: %d", pos.Filename, r, pos.LineNum, pos.ColNum, pos.TokenLength))
+ } else {
+ panic(fmt.Sprintf("Amber Error: %v - Line: %d, Column: %d, Length: %d", r, pos.LineNum, pos.ColNum, pos.TokenLength))
+ }
+ }
+ }()
+
+ block := newBlock()
+ p.advance()
+
+ for {
+ if p.currenttoken == nil || p.currenttoken.Kind == tokEOF {
+ break
+ }
+
+ if p.currenttoken.Kind == tokBlank {
+ p.advance()
+ continue
+ }
+
+ block.push(p.parse())
+ }
+
+ if p.parent != nil {
+ p.parent.Parse()
+
+ for _, prev := range p.parent.namedBlocks {
+ ours := p.namedBlocks[prev.Name]
+
+ if ours == nil {
+ // Put a copy of the named block into current context, so that sub-templates can use the block
+ p.namedBlocks[prev.Name] = prev
+ continue
+ }
+
+ top := findTopmostParentWithNamedBlock(p, prev.Name)
+ nb := top.namedBlocks[prev.Name]
+ switch ours.Modifier {
+ case NamedBlockAppend:
+ for i := 0; i < len(ours.Children); i++ {
+ nb.push(ours.Children[i])
+ }
+ case NamedBlockPrepend:
+ for i := len(ours.Children) - 1; i >= 0; i-- {
+ nb.pushFront(ours.Children[i])
+ }
+ default:
+ nb.Children = ours.Children
+ }
+ }
+
+ block = p.parent.result
+ }
+
+ p.result = block
+ return block
+}
+
+func (p *Parser) pos() SourcePosition {
+ pos := p.scanner.Pos()
+ pos.Filename = p.filename
+ return pos
+}
+
+func (p *Parser) parseRelativeFile(filename string) *Parser {
+ if len(p.filename) == 0 {
+ panic("Unable to import or extend " + filename + " in a non filesystem based parser.")
+ }
+
+ filename = filepath.Join(filepath.Dir(p.filename), filename)
+
+ if strings.IndexRune(filepath.Base(filename), '.') < 0 {
+ filename = filename + ".amber"
+ }
+
+ parser, err := FileParser(filename)
+ if err != nil && p.fs != nil {
+ parser, err = VirtualFileParser(filename, p.fs)
+ }
+ if err != nil {
+ panic("Unable to read " + filename + ", Error: " + string(err.Error()))
+ }
+
+ return parser
+}
+
+func (p *Parser) parse() Node {
+ switch p.currenttoken.Kind {
+ case tokDoctype:
+ return p.parseDoctype()
+ case tokComment:
+ return p.parseComment()
+ case tokText:
+ return p.parseText()
+ case tokIf:
+ return p.parseIf()
+ case tokEach:
+ return p.parseEach()
+ case tokImport:
+ return p.parseImport()
+ case tokTag:
+ return p.parseTag()
+ case tokAssignment:
+ return p.parseAssignment()
+ case tokNamedBlock:
+ return p.parseNamedBlock()
+ case tokExtends:
+ return p.parseExtends()
+ case tokIndent:
+ return p.parseBlock(nil)
+ case tokMixin:
+ return p.parseMixin()
+ case tokMixinCall:
+ return p.parseMixinCall()
+ }
+
+ panic(fmt.Sprintf("Unexpected token: %d", p.currenttoken.Kind))
+}
+
+func (p *Parser) expect(typ rune) *token {
+ if p.currenttoken.Kind != typ {
+ panic("Unexpected token!")
+ }
+ curtok := p.currenttoken
+ p.advance()
+ return curtok
+}
+
+func (p *Parser) advance() {
+ p.currenttoken = p.scanner.Next()
+}
+
+func (p *Parser) parseExtends() *Block {
+ if p.parent != nil {
+ panic("Unable to extend multiple parent templates.")
+ }
+
+ tok := p.expect(tokExtends)
+ parser := p.parseRelativeFile(tok.Value)
+ parser.Parse()
+ p.parent = parser
+ return newBlock()
+}
+
+func (p *Parser) parseBlock(parent Node) *Block {
+ p.expect(tokIndent)
+ block := newBlock()
+ block.SourcePosition = p.pos()
+
+ for {
+ if p.currenttoken == nil || p.currenttoken.Kind == tokEOF || p.currenttoken.Kind == tokOutdent {
+ break
+ }
+
+ if p.currenttoken.Kind == tokBlank {
+ p.advance()
+ continue
+ }
+
+ if p.currenttoken.Kind == tokId ||
+ p.currenttoken.Kind == tokClassName ||
+ p.currenttoken.Kind == tokAttribute {
+
+ if tag, ok := parent.(*Tag); ok {
+ attr := p.expect(p.currenttoken.Kind)
+ cond := attr.Data["Condition"]
+
+ switch attr.Kind {
+ case tokId:
+ tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "id", attr.Value, true, cond})
+ case tokClassName:
+ tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "class", attr.Value, true, cond})
+ case tokAttribute:
+ tag.Attributes = append(tag.Attributes, Attribute{p.pos(), attr.Value, attr.Data["Content"], attr.Data["Mode"] == "raw", cond})
+ }
+
+ continue
+ } else {
+ panic("Conditional attributes must be placed immediately within a parent tag.")
+ }
+ }
+
+ block.push(p.parse())
+ }
+
+ p.expect(tokOutdent)
+
+ return block
+}
+
+func (p *Parser) parseIf() *Condition {
+ tok := p.expect(tokIf)
+ cnd := newCondition(tok.Value)
+ cnd.SourcePosition = p.pos()
+
+readmore:
+ switch p.currenttoken.Kind {
+ case tokIndent:
+ cnd.Positive = p.parseBlock(cnd)
+ goto readmore
+ case tokElse:
+ p.expect(tokElse)
+ if p.currenttoken.Kind == tokIf {
+ cnd.Negative = newBlock()
+ cnd.Negative.push(p.parseIf())
+ } else if p.currenttoken.Kind == tokIndent {
+ cnd.Negative = p.parseBlock(cnd)
+ } else {
+ panic("Unexpected token!")
+ }
+ goto readmore
+ }
+
+ return cnd
+}
+
+func (p *Parser) parseEach() *Each {
+ tok := p.expect(tokEach)
+ ech := newEach(tok.Value)
+ ech.SourcePosition = p.pos()
+ ech.X = tok.Data["X"]
+ ech.Y = tok.Data["Y"]
+
+ if p.currenttoken.Kind == tokIndent {
+ ech.Block = p.parseBlock(ech)
+ }
+
+ return ech
+}
+
+func (p *Parser) parseImport() *Block {
+ tok := p.expect(tokImport)
+ node := p.parseRelativeFile(tok.Value).Parse()
+ node.SourcePosition = p.pos()
+ return node
+}
+
+func (p *Parser) parseNamedBlock() *Block {
+ tok := p.expect(tokNamedBlock)
+
+ if p.namedBlocks[tok.Value] != nil {
+ panic("Multiple definitions of named blocks are not permitted. Block " + tok.Value + " has been re defined.")
+ }
+
+ block := newNamedBlock(tok.Value)
+ block.SourcePosition = p.pos()
+
+ if tok.Data["Modifier"] == "append" {
+ block.Modifier = NamedBlockAppend
+ } else if tok.Data["Modifier"] == "prepend" {
+ block.Modifier = NamedBlockPrepend
+ }
+
+ if p.currenttoken.Kind == tokIndent {
+ block.Block = *(p.parseBlock(nil))
+ }
+
+ p.namedBlocks[block.Name] = block
+
+ if block.Modifier == NamedBlockDefault {
+ return &block.Block
+ }
+
+ return newBlock()
+}
+
+func (p *Parser) parseDoctype() *Doctype {
+ tok := p.expect(tokDoctype)
+ node := newDoctype(tok.Value)
+ node.SourcePosition = p.pos()
+ return node
+}
+
+func (p *Parser) parseComment() *Comment {
+ tok := p.expect(tokComment)
+ cmnt := newComment(tok.Value)
+ cmnt.SourcePosition = p.pos()
+ cmnt.Silent = tok.Data["Mode"] == "silent"
+
+ if p.currenttoken.Kind == tokIndent {
+ cmnt.Block = p.parseBlock(cmnt)
+ }
+
+ return cmnt
+}
+
+func (p *Parser) parseText() *Text {
+ tok := p.expect(tokText)
+ node := newText(tok.Value, tok.Data["Mode"] == "raw")
+ node.SourcePosition = p.pos()
+ return node
+}
+
+func (p *Parser) parseAssignment() *Assignment {
+ tok := p.expect(tokAssignment)
+ node := newAssignment(tok.Data["X"], tok.Value)
+ node.SourcePosition = p.pos()
+ return node
+}
+
+func (p *Parser) parseTag() *Tag {
+ tok := p.expect(tokTag)
+ tag := newTag(tok.Value)
+ tag.SourcePosition = p.pos()
+
+ ensureBlock := func() {
+ if tag.Block == nil {
+ tag.Block = newBlock()
+ }
+ }
+
+readmore:
+ switch p.currenttoken.Kind {
+ case tokIndent:
+ if tag.IsRawText() {
+ p.scanner.readRaw = true
+ }
+
+ block := p.parseBlock(tag)
+ if tag.Block == nil {
+ tag.Block = block
+ } else {
+ for _, c := range block.Children {
+ tag.Block.push(c)
+ }
+ }
+ case tokId:
+ id := p.expect(tokId)
+ if len(id.Data["Condition"]) > 0 {
+ panic("Conditional attributes must be placed in a block within a tag.")
+ }
+ tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "id", id.Value, true, ""})
+ goto readmore
+ case tokClassName:
+ cls := p.expect(tokClassName)
+ if len(cls.Data["Condition"]) > 0 {
+ panic("Conditional attributes must be placed in a block within a tag.")
+ }
+ tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "class", cls.Value, true, ""})
+ goto readmore
+ case tokAttribute:
+ attr := p.expect(tokAttribute)
+ if len(attr.Data["Condition"]) > 0 {
+ panic("Conditional attributes must be placed in a block within a tag.")
+ }
+ tag.Attributes = append(tag.Attributes, Attribute{p.pos(), attr.Value, attr.Data["Content"], attr.Data["Mode"] == "raw", ""})
+ goto readmore
+ case tokText:
+ if p.currenttoken.Data["Mode"] != "piped" {
+ ensureBlock()
+ tag.Block.pushFront(p.parseText())
+ goto readmore
+ }
+ }
+
+ return tag
+}
+
+func (p *Parser) parseMixin() *Mixin {
+ tok := p.expect(tokMixin)
+ mixin := newMixin(tok.Value, tok.Data["Args"])
+ mixin.SourcePosition = p.pos()
+
+ if p.currenttoken.Kind == tokIndent {
+ mixin.Block = p.parseBlock(mixin)
+ }
+
+ return mixin
+}
+
+func (p *Parser) parseMixinCall() *MixinCall {
+ tok := p.expect(tokMixinCall)
+ mixinCall := newMixinCall(tok.Value, tok.Data["Args"])
+ mixinCall.SourcePosition = p.pos()
+ return mixinCall
+}
+
+func findTopmostParentWithNamedBlock(p *Parser, name string) *Parser {
+ top := p
+
+ for {
+ if top.namedBlocks[name] == nil {
+ return nil
+ }
+ if top.parent == nil {
+ return top
+ }
+ if top.parent.namedBlocks[name] != nil {
+ top = top.parent
+ } else {
+ return top
+ }
+ }
+}
diff --git a/vendor/github.com/eknkc/amber/parser/scanner.go b/vendor/github.com/eknkc/amber/parser/scanner.go
new file mode 100644
index 0000000..70e0203
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/parser/scanner.go
@@ -0,0 +1,501 @@
+package parser
+
+import (
+ "bufio"
+ "container/list"
+ "fmt"
+ "io"
+ "regexp"
+)
+
+const (
+ tokEOF = -(iota + 1)
+ tokDoctype
+ tokComment
+ tokIndent
+ tokOutdent
+ tokBlank
+ tokId
+ tokClassName
+ tokTag
+ tokText
+ tokAttribute
+ tokIf
+ tokElse
+ tokEach
+ tokAssignment
+ tokImport
+ tokNamedBlock
+ tokExtends
+ tokMixin
+ tokMixinCall
+)
+
+const (
+ scnNewLine = iota
+ scnLine
+ scnEOF
+)
+
+type scanner struct {
+ reader *bufio.Reader
+ indentStack *list.List
+ stash *list.List
+
+ state int32
+ buffer string
+
+ line int
+ col int
+ lastTokenLine int
+ lastTokenCol int
+ lastTokenSize int
+
+ readRaw bool
+}
+
+type token struct {
+ Kind rune
+ Value string
+ Data map[string]string
+}
+
+func newScanner(r io.Reader) *scanner {
+ s := new(scanner)
+ s.reader = bufio.NewReader(r)
+ s.indentStack = list.New()
+ s.stash = list.New()
+ s.state = scnNewLine
+ s.line = -1
+ s.col = 0
+
+ return s
+}
+
+func (s *scanner) Pos() SourcePosition {
+ return SourcePosition{s.lastTokenLine + 1, s.lastTokenCol + 1, s.lastTokenSize, ""}
+}
+
+// Returns next token found in buffer
+func (s *scanner) Next() *token {
+ if s.readRaw {
+ s.readRaw = false
+ return s.NextRaw()
+ }
+
+ s.ensureBuffer()
+
+ if stashed := s.stash.Front(); stashed != nil {
+ tok := stashed.Value.(*token)
+ s.stash.Remove(stashed)
+ return tok
+ }
+
+ switch s.state {
+ case scnEOF:
+ if outdent := s.indentStack.Back(); outdent != nil {
+ s.indentStack.Remove(outdent)
+ return &token{tokOutdent, "", nil}
+ }
+
+ return &token{tokEOF, "", nil}
+ case scnNewLine:
+ s.state = scnLine
+
+ if tok := s.scanIndent(); tok != nil {
+ return tok
+ }
+
+ return s.Next()
+ case scnLine:
+ if tok := s.scanMixin(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanMixinCall(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanDoctype(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanCondition(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanEach(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanImport(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanExtends(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanBlock(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanAssignment(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanTag(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanId(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanClassName(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanAttribute(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanComment(); tok != nil {
+ return tok
+ }
+
+ if tok := s.scanText(); tok != nil {
+ return tok
+ }
+ }
+
+ return nil
+}
+
+func (s *scanner) NextRaw() *token {
+ result := ""
+ level := 0
+
+ for {
+ s.ensureBuffer()
+
+ switch s.state {
+ case scnEOF:
+ return &token{tokText, result, map[string]string{"Mode": "raw"}}
+ case scnNewLine:
+ s.state = scnLine
+
+ if tok := s.scanIndent(); tok != nil {
+ if tok.Kind == tokIndent {
+ level++
+ } else if tok.Kind == tokOutdent {
+ level--
+ } else {
+ result = result + "\n"
+ continue
+ }
+
+ if level < 0 {
+ s.stash.PushBack(&token{tokOutdent, "", nil})
+
+ if len(result) > 0 && result[len(result)-1] == '\n' {
+ result = result[:len(result)-1]
+ }
+
+ return &token{tokText, result, map[string]string{"Mode": "raw"}}
+ }
+ }
+ case scnLine:
+ if len(result) > 0 {
+ result = result + "\n"
+ }
+ for i := 0; i < level; i++ {
+ result += "\t"
+ }
+ result = result + s.buffer
+ s.consume(len(s.buffer))
+ }
+ }
+
+ return nil
+}
+
+var rgxIndent = regexp.MustCompile(`^(\s+)`)
+
+func (s *scanner) scanIndent() *token {
+ if len(s.buffer) == 0 {
+ return &token{tokBlank, "", nil}
+ }
+
+ var head *list.Element
+ for head = s.indentStack.Front(); head != nil; head = head.Next() {
+ value := head.Value.(*regexp.Regexp)
+
+ if match := value.FindString(s.buffer); len(match) != 0 {
+ s.consume(len(match))
+ } else {
+ break
+ }
+ }
+
+ newIndent := rgxIndent.FindString(s.buffer)
+
+ if len(newIndent) != 0 && head == nil {
+ s.indentStack.PushBack(regexp.MustCompile(regexp.QuoteMeta(newIndent)))
+ s.consume(len(newIndent))
+ return &token{tokIndent, newIndent, nil}
+ }
+
+ if len(newIndent) == 0 && head != nil {
+ for head != nil {
+ next := head.Next()
+ s.indentStack.Remove(head)
+ if next == nil {
+ return &token{tokOutdent, "", nil}
+ } else {
+ s.stash.PushBack(&token{tokOutdent, "", nil})
+ }
+ head = next
+ }
+ }
+
+ if len(newIndent) != 0 && head != nil {
+ panic("Mismatching indentation. Please use a coherent indent schema.")
+ }
+
+ return nil
+}
+
+var rgxDoctype = regexp.MustCompile(`^(!!!|doctype)\s*(.*)`)
+
+func (s *scanner) scanDoctype() *token {
+ if sm := rgxDoctype.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ if len(sm[2]) == 0 {
+ sm[2] = "html"
+ }
+
+ s.consume(len(sm[0]))
+ return &token{tokDoctype, sm[2], nil}
+ }
+
+ return nil
+}
+
+var rgxIf = regexp.MustCompile(`^if\s+(.+)$`)
+var rgxElse = regexp.MustCompile(`^else\s*`)
+
+func (s *scanner) scanCondition() *token {
+ if sm := rgxIf.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokIf, sm[1], nil}
+ }
+
+ if sm := rgxElse.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokElse, "", nil}
+ }
+
+ return nil
+}
+
+var rgxEach = regexp.MustCompile(`^each\s+(\$[\w0-9\-_]*)(?:\s*,\s*(\$[\w0-9\-_]*))?\s+in\s+(.+)$`)
+
+func (s *scanner) scanEach() *token {
+ if sm := rgxEach.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokEach, sm[3], map[string]string{"X": sm[1], "Y": sm[2]}}
+ }
+
+ return nil
+}
+
+var rgxAssignment = regexp.MustCompile(`^(\$[\w0-9\-_]*)?\s*=\s*(.+)$`)
+
+func (s *scanner) scanAssignment() *token {
+ if sm := rgxAssignment.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokAssignment, sm[2], map[string]string{"X": sm[1]}}
+ }
+
+ return nil
+}
+
+var rgxComment = regexp.MustCompile(`^\/\/(-)?\s*(.*)$`)
+
+func (s *scanner) scanComment() *token {
+ if sm := rgxComment.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ mode := "embed"
+ if len(sm[1]) != 0 {
+ mode = "silent"
+ }
+
+ s.consume(len(sm[0]))
+ return &token{tokComment, sm[2], map[string]string{"Mode": mode}}
+ }
+
+ return nil
+}
+
+var rgxId = regexp.MustCompile(`^#([\w-]+)(?:\s*\?\s*(.*)$)?`)
+
+func (s *scanner) scanId() *token {
+ if sm := rgxId.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokId, sm[1], map[string]string{"Condition": sm[2]}}
+ }
+
+ return nil
+}
+
+var rgxClassName = regexp.MustCompile(`^\.([\w-]+)(?:\s*\?\s*(.*)$)?`)
+
+func (s *scanner) scanClassName() *token {
+ if sm := rgxClassName.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokClassName, sm[1], map[string]string{"Condition": sm[2]}}
+ }
+
+ return nil
+}
+
+var rgxAttribute = regexp.MustCompile(`^\[([\w\-:@\.]+)\s*(?:=\s*(\"([^\"\\]*)\"|([^\]]+)))?\](?:\s*\?\s*(.*)$)?`)
+
+func (s *scanner) scanAttribute() *token {
+ if sm := rgxAttribute.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+
+ if len(sm[3]) != 0 || sm[2] == "" {
+ return &token{tokAttribute, sm[1], map[string]string{"Content": sm[3], "Mode": "raw", "Condition": sm[5]}}
+ }
+
+ return &token{tokAttribute, sm[1], map[string]string{"Content": sm[4], "Mode": "expression", "Condition": sm[5]}}
+ }
+
+ return nil
+}
+
+var rgxImport = regexp.MustCompile(`^import\s+([0-9a-zA-Z_\-\. \/]*)$`)
+
+func (s *scanner) scanImport() *token {
+ if sm := rgxImport.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokImport, sm[1], nil}
+ }
+
+ return nil
+}
+
+var rgxExtends = regexp.MustCompile(`^extends\s+([0-9a-zA-Z_\-\. \/]*)$`)
+
+func (s *scanner) scanExtends() *token {
+ if sm := rgxExtends.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokExtends, sm[1], nil}
+ }
+
+ return nil
+}
+
+var rgxBlock = regexp.MustCompile(`^block\s+(?:(append|prepend)\s+)?([0-9a-zA-Z_\-\. \/]*)$`)
+
+func (s *scanner) scanBlock() *token {
+ if sm := rgxBlock.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokNamedBlock, sm[2], map[string]string{"Modifier": sm[1]}}
+ }
+
+ return nil
+}
+
+var rgxTag = regexp.MustCompile(`^(\w[-:\w]*)`)
+
+func (s *scanner) scanTag() *token {
+ if sm := rgxTag.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokTag, sm[1], nil}
+ }
+
+ return nil
+}
+
+var rgxMixin = regexp.MustCompile(`^mixin ([a-zA-Z_-]+\w*)(\(((\$\w*(,\s)?)*)\))?$`)
+
+func (s *scanner) scanMixin() *token {
+ if sm := rgxMixin.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokMixin, sm[1], map[string]string{"Args": sm[3]}}
+ }
+
+ return nil
+}
+
+var rgxMixinCall = regexp.MustCompile(`^\+([A-Za-z_-]+\w*)(\((.+(,\s)?)*\))?$`)
+
+func (s *scanner) scanMixinCall() *token {
+ if sm := rgxMixinCall.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+ return &token{tokMixinCall, sm[1], map[string]string{"Args": sm[3]}}
+ }
+
+ return nil
+}
+
+var rgxText = regexp.MustCompile(`^(\|)? ?(.*)$`)
+
+func (s *scanner) scanText() *token {
+ if sm := rgxText.FindStringSubmatch(s.buffer); len(sm) != 0 {
+ s.consume(len(sm[0]))
+
+ mode := "inline"
+ if sm[1] == "|" {
+ mode = "piped"
+ }
+
+ return &token{tokText, sm[2], map[string]string{"Mode": mode}}
+ }
+
+ return nil
+}
+
+// Moves position forward, and removes beginning of s.buffer (len bytes)
+func (s *scanner) consume(runes int) {
+ if len(s.buffer) < runes {
+ panic(fmt.Sprintf("Unable to consume %d runes from buffer.", runes))
+ }
+
+ s.lastTokenLine = s.line
+ s.lastTokenCol = s.col
+ s.lastTokenSize = runes
+
+ s.buffer = s.buffer[runes:]
+ s.col += runes
+}
+
+// Reads string into s.buffer
+func (s *scanner) ensureBuffer() {
+ if len(s.buffer) > 0 {
+ return
+ }
+
+ buf, err := s.reader.ReadString('\n')
+
+ if err != nil && err != io.EOF {
+ panic(err)
+ } else if err != nil && len(buf) == 0 {
+ s.state = scnEOF
+ } else {
+ // endline "LF only" or "\n" use Unix, Linux, modern MacOS X, FreeBSD, BeOS, RISC OS
+ if buf[len(buf)-1] == '\n' {
+ buf = buf[:len(buf)-1]
+ }
+ // endline "CR+LF" or "\r\n" use internet protocols, DEC RT-11, Windows, CP/M, MS-DOS, OS/2, Symbian OS
+ if len(buf) > 0 && buf[len(buf)-1] == '\r' {
+ buf = buf[:len(buf)-1]
+ }
+
+ s.state = scnNewLine
+ s.buffer = buf
+ s.line += 1
+ s.col = 0
+ }
+}
diff --git a/vendor/github.com/eknkc/amber/runtime.go b/vendor/github.com/eknkc/amber/runtime.go
new file mode 100644
index 0000000..6438fd1
--- /dev/null
+++ b/vendor/github.com/eknkc/amber/runtime.go
@@ -0,0 +1,287 @@
+package amber
+
+import (
+ "encoding/json"
+ "fmt"
+ "html/template"
+ "reflect"
+)
+
+var FuncMap = template.FuncMap{
+ "__amber_add": runtime_add,
+ "__amber_sub": runtime_sub,
+ "__amber_mul": runtime_mul,
+ "__amber_quo": runtime_quo,
+ "__amber_rem": runtime_rem,
+ "__amber_minus": runtime_minus,
+ "__amber_plus": runtime_plus,
+ "__amber_eql": runtime_eql,
+ "__amber_gtr": runtime_gtr,
+ "__amber_lss": runtime_lss,
+
+ "json": runtime_json,
+ "unescaped": runtime_unescaped,
+}
+
+func runtime_add(x, y interface{}) interface{} {
+ vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Int() + vy.Int()
+ case reflect.Float32, reflect.Float64:
+ return float64(vx.Int()) + vy.Float()
+ case reflect.String:
+ return fmt.Sprintf("%d%s", vx.Int(), vy.String())
+ }
+ }
+ case reflect.Float32, reflect.Float64:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Float() + float64(vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.Float() + vy.Float()
+ case reflect.String:
+ return fmt.Sprintf("%f%s", vx.Float(), vy.String())
+ }
+ }
+ case reflect.String:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return fmt.Sprintf("%s%d", vx.String(), vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return fmt.Sprintf("%s%f", vx.String(), vy.Float())
+ case reflect.String:
+ return fmt.Sprintf("%s%s", vx.String(), vy.String())
+ }
+ }
+ }
+
+ return ""
+}
+
+func runtime_sub(x, y interface{}) interface{} {
+ vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Int() - vy.Int()
+ case reflect.Float32, reflect.Float64:
+ return float64(vx.Int()) - vy.Float()
+ }
+ }
+ case reflect.Float32, reflect.Float64:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Float() - float64(vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.Float() - vy.Float()
+ }
+ }
+ }
+
+ return ""
+}
+
+func runtime_mul(x, y interface{}) interface{} {
+ vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Int() * vy.Int()
+ case reflect.Float32, reflect.Float64:
+ return float64(vx.Int()) * vy.Float()
+ }
+ }
+ case reflect.Float32, reflect.Float64:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Float() * float64(vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.Float() * vy.Float()
+ }
+ }
+ }
+
+ return ""
+}
+
+func runtime_quo(x, y interface{}) interface{} {
+ vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Int() / vy.Int()
+ case reflect.Float32, reflect.Float64:
+ return float64(vx.Int()) / vy.Float()
+ }
+ }
+ case reflect.Float32, reflect.Float64:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Float() / float64(vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.Float() / vy.Float()
+ }
+ }
+ }
+
+ return ""
+}
+
+func runtime_rem(x, y interface{}) interface{} {
+ vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Int() % vy.Int()
+ }
+ }
+ }
+
+ return ""
+}
+
+func runtime_minus(x interface{}) interface{} {
+ vx := reflect.ValueOf(x)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return -vx.Int()
+ case reflect.Float32, reflect.Float64:
+ return -vx.Float()
+ }
+
+ return ""
+}
+
+func runtime_plus(x interface{}) interface{} {
+ vx := reflect.ValueOf(x)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return +vx.Int()
+ case reflect.Float32, reflect.Float64:
+ return +vx.Float()
+ }
+
+ return ""
+}
+
+func runtime_eql(x, y interface{}) bool {
+ vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Int() == vy.Int()
+ case reflect.Float32, reflect.Float64:
+ return float64(vx.Int()) == vy.Float()
+ case reflect.String:
+ return fmt.Sprintf("%d", vx.Int()) == vy.String()
+ }
+ }
+ case reflect.Float32, reflect.Float64:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Float() == float64(vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.Float() == vy.Float()
+ case reflect.String:
+ return fmt.Sprintf("%f", vx.Float()) == vy.String()
+ }
+ }
+ case reflect.String:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.String() == fmt.Sprintf("%d", vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.String() == fmt.Sprintf("%f", vy.Float())
+ case reflect.String:
+ return vx.String() == fmt.Sprintf("%s", vy.String())
+ }
+ }
+ case reflect.Bool:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Bool() && vy.Int() != 0
+ case reflect.Bool:
+ return vx.Bool() == vy.Bool()
+ }
+ }
+ }
+
+ return false
+}
+
+func runtime_lss(x, y interface{}) bool {
+ vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+ switch vx.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Int() < vy.Int()
+ case reflect.Float32, reflect.Float64:
+ return float64(vx.Int()) < vy.Float()
+ case reflect.String:
+ return fmt.Sprintf("%d", vx.Int()) < vy.String()
+ }
+ }
+ case reflect.Float32, reflect.Float64:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.Float() < float64(vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.Float() < vy.Float()
+ case reflect.String:
+ return fmt.Sprintf("%f", vx.Float()) < vy.String()
+ }
+ }
+ case reflect.String:
+ {
+ switch vy.Kind() {
+ case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
+ return vx.String() < fmt.Sprintf("%d", vy.Int())
+ case reflect.Float32, reflect.Float64:
+ return vx.String() < fmt.Sprintf("%f", vy.Float())
+ case reflect.String:
+ return vx.String() < vy.String()
+ }
+ }
+ }
+
+ return false
+}
+
+func runtime_gtr(x, y interface{}) bool {
+ return !runtime_lss(x, y) && !runtime_eql(x, y)
+}
+
+func runtime_json(x interface{}) (res string, err error) {
+ bres, err := json.Marshal(x)
+ res = string(bres)
+ return
+}
+
+func runtime_unescaped(x string) interface{} {
+ return template.HTML(x)
+}
diff --git a/vendor/github.com/russross/blackfriday/v2/.gitignore b/vendor/github.com/russross/blackfriday/v2/.gitignore
new file mode 100644
index 0000000..75623dc
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/.gitignore
@@ -0,0 +1,8 @@
+*.out
+*.swp
+*.8
+*.6
+_obj
+_test*
+markdown
+tags
diff --git a/vendor/github.com/russross/blackfriday/v2/.travis.yml b/vendor/github.com/russross/blackfriday/v2/.travis.yml
new file mode 100644
index 0000000..b0b525a
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/.travis.yml
@@ -0,0 +1,17 @@
+sudo: false
+language: go
+go:
+ - "1.10.x"
+ - "1.11.x"
+ - tip
+matrix:
+ fast_finish: true
+ allow_failures:
+ - go: tip
+install:
+ - # Do nothing. This is needed to prevent default install action "go get -t -v ./..." from happening here (we want it to happen inside script step).
+script:
+ - go get -t -v ./...
+ - diff -u <(echo -n) <(gofmt -d -s .)
+ - go tool vet .
+ - go test -v ./...
diff --git a/vendor/github.com/russross/blackfriday/v2/LICENSE.txt b/vendor/github.com/russross/blackfriday/v2/LICENSE.txt
new file mode 100644
index 0000000..2885af3
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/LICENSE.txt
@@ -0,0 +1,29 @@
+Blackfriday is distributed under the Simplified BSD License:
+
+> Copyright © 2011 Russ Ross
+> All rights reserved.
+>
+> Redistribution and use in source and binary forms, with or without
+> modification, are permitted provided that the following conditions
+> are met:
+>
+> 1. Redistributions of source code must retain the above copyright
+> notice, this list of conditions and the following disclaimer.
+>
+> 2. Redistributions in binary form must reproduce the above
+> copyright notice, this list of conditions and the following
+> disclaimer in the documentation and/or other materials provided with
+> the distribution.
+>
+> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+> "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+> LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+> FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+> COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+> INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+> BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+> LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+> LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+> ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+> POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/russross/blackfriday/v2/README.md b/vendor/github.com/russross/blackfriday/v2/README.md
new file mode 100644
index 0000000..d9c08a2
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/README.md
@@ -0,0 +1,335 @@
+Blackfriday
+[![Build Status][BuildV2SVG]][BuildV2URL]
+[![PkgGoDev][PkgGoDevV2SVG]][PkgGoDevV2URL]
+===========
+
+Blackfriday is a [Markdown][1] processor implemented in [Go][2]. It
+is paranoid about its input (so you can safely feed it user-supplied
+data), it is fast, it supports common extensions (tables, smart
+punctuation substitutions, etc.), and it is safe for all utf-8
+(unicode) input.
+
+HTML output is currently supported, along with Smartypants
+extensions.
+
+It started as a translation from C of [Sundown][3].
+
+
+Installation
+------------
+
+Blackfriday is compatible with modern Go releases in module mode.
+With Go installed:
+
+ go get github.com/russross/blackfriday/v2
+
+will resolve and add the package to the current development module,
+then build and install it. Alternatively, you can achieve the same
+if you import it in a package:
+
+ import "github.com/russross/blackfriday/v2"
+
+and `go get` without parameters.
+
+Legacy GOPATH mode is unsupported.
+
+
+Versions
+--------
+
+Currently maintained and recommended version of Blackfriday is `v2`. It's being
+developed on its own branch: https://github.com/russross/blackfriday/tree/v2 and the
+documentation is available at
+https://pkg.go.dev/github.com/russross/blackfriday/v2.
+
+It is `go get`-able in module mode at `github.com/russross/blackfriday/v2`.
+
+Version 2 offers a number of improvements over v1:
+
+* Cleaned up API
+* A separate call to [`Parse`][4], which produces an abstract syntax tree for
+ the document
+* Latest bug fixes
+* Flexibility to easily add your own rendering extensions
+
+Potential drawbacks:
+
+* Our benchmarks show v2 to be slightly slower than v1. Currently in the
+ ballpark of around 15%.
+* API breakage. If you can't afford modifying your code to adhere to the new API
+ and don't care too much about the new features, v2 is probably not for you.
+* Several bug fixes are trailing behind and still need to be forward-ported to
+ v2. See issue [#348](https://github.com/russross/blackfriday/issues/348) for
+ tracking.
+
+If you are still interested in the legacy `v1`, you can import it from
+`github.com/russross/blackfriday`. Documentation for the legacy v1 can be found
+here: https://pkg.go.dev/github.com/russross/blackfriday.
+
+
+Usage
+-----
+
+For the most sensible markdown processing, it is as simple as getting your input
+into a byte slice and calling:
+
+```go
+output := blackfriday.Run(input)
+```
+
+Your input will be parsed and the output rendered with a set of most popular
+extensions enabled. If you want the most basic feature set, corresponding with
+the bare Markdown specification, use:
+
+```go
+output := blackfriday.Run(input, blackfriday.WithNoExtensions())
+```
+
+### Sanitize untrusted content
+
+Blackfriday itself does nothing to protect against malicious content. If you are
+dealing with user-supplied markdown, we recommend running Blackfriday's output
+through HTML sanitizer such as [Bluemonday][5].
+
+Here's an example of simple usage of Blackfriday together with Bluemonday:
+
+```go
+import (
+ "github.com/microcosm-cc/bluemonday"
+ "github.com/russross/blackfriday/v2"
+)
+
+// ...
+unsafe := blackfriday.Run(input)
+html := bluemonday.UGCPolicy().SanitizeBytes(unsafe)
+```
+
+### Custom options
+
+If you want to customize the set of options, use `blackfriday.WithExtensions`,
+`blackfriday.WithRenderer` and `blackfriday.WithRefOverride`.
+
+### `blackfriday-tool`
+
+You can also check out `blackfriday-tool` for a more complete example
+of how to use it. Download and install it using:
+
+ go get github.com/russross/blackfriday-tool
+
+This is a simple command-line tool that allows you to process a
+markdown file using a standalone program. You can also browse the
+source directly on github if you are just looking for some example
+code:
+
+*
+
+Note that if you have not already done so, installing
+`blackfriday-tool` will be sufficient to download and install
+blackfriday in addition to the tool itself. The tool binary will be
+installed in `$GOPATH/bin`. This is a statically-linked binary that
+can be copied to wherever you need it without worrying about
+dependencies and library versions.
+
+### Sanitized anchor names
+
+Blackfriday includes an algorithm for creating sanitized anchor names
+corresponding to a given input text. This algorithm is used to create
+anchors for headings when `AutoHeadingIDs` extension is enabled. The
+algorithm has a specification, so that other packages can create
+compatible anchor names and links to those anchors.
+
+The specification is located at https://pkg.go.dev/github.com/russross/blackfriday/v2#hdr-Sanitized_Anchor_Names.
+
+[`SanitizedAnchorName`](https://pkg.go.dev/github.com/russross/blackfriday/v2#SanitizedAnchorName) exposes this functionality, and can be used to
+create compatible links to the anchor names generated by blackfriday.
+This algorithm is also implemented in a small standalone package at
+[`github.com/shurcooL/sanitized_anchor_name`](https://pkg.go.dev/github.com/shurcooL/sanitized_anchor_name). It can be useful for clients
+that want a small package and don't need full functionality of blackfriday.
+
+
+Features
+--------
+
+All features of Sundown are supported, including:
+
+* **Compatibility**. The Markdown v1.0.3 test suite passes with
+ the `--tidy` option. Without `--tidy`, the differences are
+ mostly in whitespace and entity escaping, where blackfriday is
+ more consistent and cleaner.
+
+* **Common extensions**, including table support, fenced code
+ blocks, autolinks, strikethroughs, non-strict emphasis, etc.
+
+* **Safety**. Blackfriday is paranoid when parsing, making it safe
+ to feed untrusted user input without fear of bad things
+ happening. The test suite stress tests this and there are no
+ known inputs that make it crash. If you find one, please let me
+ know and send me the input that does it.
+
+ NOTE: "safety" in this context means *runtime safety only*. In order to
+ protect yourself against JavaScript injection in untrusted content, see
+ [this example](https://github.com/russross/blackfriday#sanitize-untrusted-content).
+
+* **Fast processing**. It is fast enough to render on-demand in
+ most web applications without having to cache the output.
+
+* **Thread safety**. You can run multiple parsers in different
+ goroutines without ill effect. There is no dependence on global
+ shared state.
+
+* **Minimal dependencies**. Blackfriday only depends on standard
+ library packages in Go. The source code is pretty
+ self-contained, so it is easy to add to any project, including
+ Google App Engine projects.
+
+* **Standards compliant**. Output successfully validates using the
+ W3C validation tool for HTML 4.01 and XHTML 1.0 Transitional.
+
+
+Extensions
+----------
+
+In addition to the standard markdown syntax, this package
+implements the following extensions:
+
+* **Intra-word emphasis supression**. The `_` character is
+ commonly used inside words when discussing code, so having
+ markdown interpret it as an emphasis command is usually the
+ wrong thing. Blackfriday lets you treat all emphasis markers as
+ normal characters when they occur inside a word.
+
+* **Tables**. Tables can be created by drawing them in the input
+ using a simple syntax:
+
+ ```
+ Name | Age
+ --------|------
+ Bob | 27
+ Alice | 23
+ ```
+
+* **Fenced code blocks**. In addition to the normal 4-space
+ indentation to mark code blocks, you can explicitly mark them
+ and supply a language (to make syntax highlighting simple). Just
+ mark it like this:
+
+ ```go
+ func getTrue() bool {
+ return true
+ }
+ ```
+
+ You can use 3 or more backticks to mark the beginning of the
+ block, and the same number to mark the end of the block.
+
+ To preserve classes of fenced code blocks while using the bluemonday
+ HTML sanitizer, use the following policy:
+
+ ```go
+ p := bluemonday.UGCPolicy()
+ p.AllowAttrs("class").Matching(regexp.MustCompile("^language-[a-zA-Z0-9]+$")).OnElements("code")
+ html := p.SanitizeBytes(unsafe)
+ ```
+
+* **Definition lists**. A simple definition list is made of a single-line
+ term followed by a colon and the definition for that term.
+
+ Cat
+ : Fluffy animal everyone likes
+
+ Internet
+ : Vector of transmission for pictures of cats
+
+ Terms must be separated from the previous definition by a blank line.
+
+* **Footnotes**. A marker in the text that will become a superscript number;
+ a footnote definition that will be placed in a list of footnotes at the
+ end of the document. A footnote looks like this:
+
+ This is a footnote.[^1]
+
+ [^1]: the footnote text.
+
+* **Autolinking**. Blackfriday can find URLs that have not been
+ explicitly marked as links and turn them into links.
+
+* **Strikethrough**. Use two tildes (`~~`) to mark text that
+ should be crossed out.
+
+* **Hard line breaks**. With this extension enabled newlines in the input
+ translate into line breaks in the output. This extension is off by default.
+
+* **Smart quotes**. Smartypants-style punctuation substitution is
+ supported, turning normal double- and single-quote marks into
+ curly quotes, etc.
+
+* **LaTeX-style dash parsing** is an additional option, where `--`
+ is translated into `–`, and `---` is translated into
+ `—`. This differs from most smartypants processors, which
+ turn a single hyphen into an ndash and a double hyphen into an
+ mdash.
+
+* **Smart fractions**, where anything that looks like a fraction
+ is translated into suitable HTML (instead of just a few special
+ cases like most smartypant processors). For example, `4/5`
+ becomes `4⁄5`, which renders as
+ 4⁄5.
+
+
+Other renderers
+---------------
+
+Blackfriday is structured to allow alternative rendering engines. Here
+are a few of note:
+
+* [github_flavored_markdown](https://pkg.go.dev/github.com/shurcooL/github_flavored_markdown):
+ provides a GitHub Flavored Markdown renderer with fenced code block
+ highlighting, clickable heading anchor links.
+
+ It's not customizable, and its goal is to produce HTML output
+ equivalent to the [GitHub Markdown API endpoint](https://developer.github.com/v3/markdown/#render-a-markdown-document-in-raw-mode),
+ except the rendering is performed locally.
+
+* [markdownfmt](https://github.com/shurcooL/markdownfmt): like gofmt,
+ but for markdown.
+
+* [LaTeX output](https://gitlab.com/ambrevar/blackfriday-latex):
+ renders output as LaTeX.
+
+* [bfchroma](https://github.com/Depado/bfchroma/): provides convenience
+ integration with the [Chroma](https://github.com/alecthomas/chroma) code
+ highlighting library. bfchroma is only compatible with v2 of Blackfriday and
+ provides a drop-in renderer ready to use with Blackfriday, as well as
+ options and means for further customization.
+
+* [Blackfriday-Confluence](https://github.com/kentaro-m/blackfriday-confluence): provides a [Confluence Wiki Markup](https://confluence.atlassian.com/doc/confluence-wiki-markup-251003035.html) renderer.
+
+* [Blackfriday-Slack](https://github.com/karriereat/blackfriday-slack): converts markdown to slack message style
+
+
+TODO
+----
+
+* More unit testing
+* Improve Unicode support. It does not understand all Unicode
+ rules (about what constitutes a letter, a punctuation symbol,
+ etc.), so it may fail to detect word boundaries correctly in
+ some instances. It is safe on all UTF-8 input.
+
+
+License
+-------
+
+[Blackfriday is distributed under the Simplified BSD License](LICENSE.txt)
+
+
+ [1]: https://daringfireball.net/projects/markdown/ "Markdown"
+ [2]: https://golang.org/ "Go Language"
+ [3]: https://github.com/vmg/sundown "Sundown"
+ [4]: https://pkg.go.dev/github.com/russross/blackfriday/v2#Parse "Parse func"
+ [5]: https://github.com/microcosm-cc/bluemonday "Bluemonday"
+
+ [BuildV2SVG]: https://travis-ci.org/russross/blackfriday.svg?branch=v2
+ [BuildV2URL]: https://travis-ci.org/russross/blackfriday
+ [PkgGoDevV2SVG]: https://pkg.go.dev/badge/github.com/russross/blackfriday/v2
+ [PkgGoDevV2URL]: https://pkg.go.dev/github.com/russross/blackfriday/v2
diff --git a/vendor/github.com/russross/blackfriday/v2/block.go b/vendor/github.com/russross/blackfriday/v2/block.go
new file mode 100644
index 0000000..dcd61e6
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/block.go
@@ -0,0 +1,1612 @@
+//
+// Blackfriday Markdown Processor
+// Available at http://github.com/russross/blackfriday
+//
+// Copyright © 2011 Russ Ross .
+// Distributed under the Simplified BSD License.
+// See README.md for details.
+//
+
+//
+// Functions to parse block-level elements.
+//
+
+package blackfriday
+
+import (
+ "bytes"
+ "html"
+ "regexp"
+ "strings"
+ "unicode"
+)
+
+const (
+ charEntity = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});"
+ escapable = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]"
+)
+
+var (
+ reBackslashOrAmp = regexp.MustCompile("[\\&]")
+ reEntityOrEscapedChar = regexp.MustCompile("(?i)\\\\" + escapable + "|" + charEntity)
+)
+
+// Parse block-level data.
+// Note: this function and many that it calls assume that
+// the input buffer ends with a newline.
+func (p *Markdown) block(data []byte) {
+ // this is called recursively: enforce a maximum depth
+ if p.nesting >= p.maxNesting {
+ return
+ }
+ p.nesting++
+
+ // parse out one block-level construct at a time
+ for len(data) > 0 {
+ // prefixed heading:
+ //
+ // # Heading 1
+ // ## Heading 2
+ // ...
+ // ###### Heading 6
+ if p.isPrefixHeading(data) {
+ data = data[p.prefixHeading(data):]
+ continue
+ }
+
+ // block of preformatted HTML:
+ //
+ //
+ // ...
+ //
+ if data[0] == '<' {
+ if i := p.html(data, true); i > 0 {
+ data = data[i:]
+ continue
+ }
+ }
+
+ // title block
+ //
+ // % stuff
+ // % more stuff
+ // % even more stuff
+ if p.extensions&Titleblock != 0 {
+ if data[0] == '%' {
+ if i := p.titleBlock(data, true); i > 0 {
+ data = data[i:]
+ continue
+ }
+ }
+ }
+
+ // blank lines. note: returns the # of bytes to skip
+ if i := p.isEmpty(data); i > 0 {
+ data = data[i:]
+ continue
+ }
+
+ // indented code block:
+ //
+ // func max(a, b int) int {
+ // if a > b {
+ // return a
+ // }
+ // return b
+ // }
+ if p.codePrefix(data) > 0 {
+ data = data[p.code(data):]
+ continue
+ }
+
+ // fenced code block:
+ //
+ // ``` go
+ // func fact(n int) int {
+ // if n <= 1 {
+ // return n
+ // }
+ // return n * fact(n-1)
+ // }
+ // ```
+ if p.extensions&FencedCode != 0 {
+ if i := p.fencedCodeBlock(data, true); i > 0 {
+ data = data[i:]
+ continue
+ }
+ }
+
+ // horizontal rule:
+ //
+ // ------
+ // or
+ // ******
+ // or
+ // ______
+ if p.isHRule(data) {
+ p.addBlock(HorizontalRule, nil)
+ var i int
+ for i = 0; i < len(data) && data[i] != '\n'; i++ {
+ }
+ data = data[i:]
+ continue
+ }
+
+ // block quote:
+ //
+ // > A big quote I found somewhere
+ // > on the web
+ if p.quotePrefix(data) > 0 {
+ data = data[p.quote(data):]
+ continue
+ }
+
+ // table:
+ //
+ // Name | Age | Phone
+ // ------|-----|---------
+ // Bob | 31 | 555-1234
+ // Alice | 27 | 555-4321
+ if p.extensions&Tables != 0 {
+ if i := p.table(data); i > 0 {
+ data = data[i:]
+ continue
+ }
+ }
+
+ // an itemized/unordered list:
+ //
+ // * Item 1
+ // * Item 2
+ //
+ // also works with + or -
+ if p.uliPrefix(data) > 0 {
+ data = data[p.list(data, 0):]
+ continue
+ }
+
+ // a numbered/ordered list:
+ //
+ // 1. Item 1
+ // 2. Item 2
+ if p.oliPrefix(data) > 0 {
+ data = data[p.list(data, ListTypeOrdered):]
+ continue
+ }
+
+ // definition lists:
+ //
+ // Term 1
+ // : Definition a
+ // : Definition b
+ //
+ // Term 2
+ // : Definition c
+ if p.extensions&DefinitionLists != 0 {
+ if p.dliPrefix(data) > 0 {
+ data = data[p.list(data, ListTypeDefinition):]
+ continue
+ }
+ }
+
+ // anything else must look like a normal paragraph
+ // note: this finds underlined headings, too
+ data = data[p.paragraph(data):]
+ }
+
+ p.nesting--
+}
+
+func (p *Markdown) addBlock(typ NodeType, content []byte) *Node {
+ p.closeUnmatchedBlocks()
+ container := p.addChild(typ, 0)
+ container.content = content
+ return container
+}
+
+func (p *Markdown) isPrefixHeading(data []byte) bool {
+ if data[0] != '#' {
+ return false
+ }
+
+ if p.extensions&SpaceHeadings != 0 {
+ level := 0
+ for level < 6 && level < len(data) && data[level] == '#' {
+ level++
+ }
+ if level == len(data) || data[level] != ' ' {
+ return false
+ }
+ }
+ return true
+}
+
+func (p *Markdown) prefixHeading(data []byte) int {
+ level := 0
+ for level < 6 && level < len(data) && data[level] == '#' {
+ level++
+ }
+ i := skipChar(data, level, ' ')
+ end := skipUntilChar(data, i, '\n')
+ skip := end
+ id := ""
+ if p.extensions&HeadingIDs != 0 {
+ j, k := 0, 0
+ // find start/end of heading id
+ for j = i; j < end-1 && (data[j] != '{' || data[j+1] != '#'); j++ {
+ }
+ for k = j + 1; k < end && data[k] != '}'; k++ {
+ }
+ // extract heading id iff found
+ if j < end && k < end {
+ id = string(data[j+2 : k])
+ end = j
+ skip = k + 1
+ for end > 0 && data[end-1] == ' ' {
+ end--
+ }
+ }
+ }
+ for end > 0 && data[end-1] == '#' {
+ if isBackslashEscaped(data, end-1) {
+ break
+ }
+ end--
+ }
+ for end > 0 && data[end-1] == ' ' {
+ end--
+ }
+ if end > i {
+ if id == "" && p.extensions&AutoHeadingIDs != 0 {
+ id = SanitizedAnchorName(string(data[i:end]))
+ }
+ block := p.addBlock(Heading, data[i:end])
+ block.HeadingID = id
+ block.Level = level
+ }
+ return skip
+}
+
+func (p *Markdown) isUnderlinedHeading(data []byte) int {
+ // test of level 1 heading
+ if data[0] == '=' {
+ i := skipChar(data, 1, '=')
+ i = skipChar(data, i, ' ')
+ if i < len(data) && data[i] == '\n' {
+ return 1
+ }
+ return 0
+ }
+
+ // test of level 2 heading
+ if data[0] == '-' {
+ i := skipChar(data, 1, '-')
+ i = skipChar(data, i, ' ')
+ if i < len(data) && data[i] == '\n' {
+ return 2
+ }
+ return 0
+ }
+
+ return 0
+}
+
+func (p *Markdown) titleBlock(data []byte, doRender bool) int {
+ if data[0] != '%' {
+ return 0
+ }
+ splitData := bytes.Split(data, []byte("\n"))
+ var i int
+ for idx, b := range splitData {
+ if !bytes.HasPrefix(b, []byte("%")) {
+ i = idx // - 1
+ break
+ }
+ }
+
+ data = bytes.Join(splitData[0:i], []byte("\n"))
+ consumed := len(data)
+ data = bytes.TrimPrefix(data, []byte("% "))
+ data = bytes.Replace(data, []byte("\n% "), []byte("\n"), -1)
+ block := p.addBlock(Heading, data)
+ block.Level = 1
+ block.IsTitleblock = true
+
+ return consumed
+}
+
+func (p *Markdown) html(data []byte, doRender bool) int {
+ var i, j int
+
+ // identify the opening tag
+ if data[0] != '<' {
+ return 0
+ }
+ curtag, tagfound := p.htmlFindTag(data[1:])
+
+ // handle special cases
+ if !tagfound {
+ // check for an HTML comment
+ if size := p.htmlComment(data, doRender); size > 0 {
+ return size
+ }
+
+ // check for an
tag
+ if size := p.htmlHr(data, doRender); size > 0 {
+ return size
+ }
+
+ // no special case recognized
+ return 0
+ }
+
+ // look for an unindented matching closing tag
+ // followed by a blank line
+ found := false
+ /*
+ closetag := []byte("\n" + curtag + ">")
+ j = len(curtag) + 1
+ for !found {
+ // scan for a closing tag at the beginning of a line
+ if skip := bytes.Index(data[j:], closetag); skip >= 0 {
+ j += skip + len(closetag)
+ } else {
+ break
+ }
+
+ // see if it is the only thing on the line
+ if skip := p.isEmpty(data[j:]); skip > 0 {
+ // see if it is followed by a blank line/eof
+ j += skip
+ if j >= len(data) {
+ found = true
+ i = j
+ } else {
+ if skip := p.isEmpty(data[j:]); skip > 0 {
+ j += skip
+ found = true
+ i = j
+ }
+ }
+ }
+ }
+ */
+
+ // if not found, try a second pass looking for indented match
+ // but not if tag is "ins" or "del" (following original Markdown.pl)
+ if !found && curtag != "ins" && curtag != "del" {
+ i = 1
+ for i < len(data) {
+ i++
+ for i < len(data) && !(data[i-1] == '<' && data[i] == '/') {
+ i++
+ }
+
+ if i+2+len(curtag) >= len(data) {
+ break
+ }
+
+ j = p.htmlFindEnd(curtag, data[i-1:])
+
+ if j > 0 {
+ i += j - 1
+ found = true
+ break
+ }
+ }
+ }
+
+ if !found {
+ return 0
+ }
+
+ // the end of the block has been found
+ if doRender {
+ // trim newlines
+ end := i
+ for end > 0 && data[end-1] == '\n' {
+ end--
+ }
+ finalizeHTMLBlock(p.addBlock(HTMLBlock, data[:end]))
+ }
+
+ return i
+}
+
+func finalizeHTMLBlock(block *Node) {
+ block.Literal = block.content
+ block.content = nil
+}
+
+// HTML comment, lax form
+func (p *Markdown) htmlComment(data []byte, doRender bool) int {
+ i := p.inlineHTMLComment(data)
+ // needs to end with a blank line
+ if j := p.isEmpty(data[i:]); j > 0 {
+ size := i + j
+ if doRender {
+ // trim trailing newlines
+ end := size
+ for end > 0 && data[end-1] == '\n' {
+ end--
+ }
+ block := p.addBlock(HTMLBlock, data[:end])
+ finalizeHTMLBlock(block)
+ }
+ return size
+ }
+ return 0
+}
+
+// HR, which is the only self-closing block tag considered
+func (p *Markdown) htmlHr(data []byte, doRender bool) int {
+ if len(data) < 4 {
+ return 0
+ }
+ if data[0] != '<' || (data[1] != 'h' && data[1] != 'H') || (data[2] != 'r' && data[2] != 'R') {
+ return 0
+ }
+ if data[3] != ' ' && data[3] != '/' && data[3] != '>' {
+ // not an
tag after all; at least not a valid one
+ return 0
+ }
+ i := 3
+ for i < len(data) && data[i] != '>' && data[i] != '\n' {
+ i++
+ }
+ if i < len(data) && data[i] == '>' {
+ i++
+ if j := p.isEmpty(data[i:]); j > 0 {
+ size := i + j
+ if doRender {
+ // trim newlines
+ end := size
+ for end > 0 && data[end-1] == '\n' {
+ end--
+ }
+ finalizeHTMLBlock(p.addBlock(HTMLBlock, data[:end]))
+ }
+ return size
+ }
+ }
+ return 0
+}
+
+func (p *Markdown) htmlFindTag(data []byte) (string, bool) {
+ i := 0
+ for i < len(data) && isalnum(data[i]) {
+ i++
+ }
+ key := string(data[:i])
+ if _, ok := blockTags[key]; ok {
+ return key, true
+ }
+ return "", false
+}
+
+func (p *Markdown) htmlFindEnd(tag string, data []byte) int {
+ // assume data[0] == '<' && data[1] == '/' already tested
+ if tag == "hr" {
+ return 2
+ }
+ // check if tag is a match
+ closetag := []byte("" + tag + ">")
+ if !bytes.HasPrefix(data, closetag) {
+ return 0
+ }
+ i := len(closetag)
+
+ // check that the rest of the line is blank
+ skip := 0
+ if skip = p.isEmpty(data[i:]); skip == 0 {
+ return 0
+ }
+ i += skip
+ skip = 0
+
+ if i >= len(data) {
+ return i
+ }
+
+ if p.extensions&LaxHTMLBlocks != 0 {
+ return i
+ }
+ if skip = p.isEmpty(data[i:]); skip == 0 {
+ // following line must be blank
+ return 0
+ }
+
+ return i + skip
+}
+
+func (*Markdown) isEmpty(data []byte) int {
+ // it is okay to call isEmpty on an empty buffer
+ if len(data) == 0 {
+ return 0
+ }
+
+ var i int
+ for i = 0; i < len(data) && data[i] != '\n'; i++ {
+ if data[i] != ' ' && data[i] != '\t' {
+ return 0
+ }
+ }
+ if i < len(data) && data[i] == '\n' {
+ i++
+ }
+ return i
+}
+
+func (*Markdown) isHRule(data []byte) bool {
+ i := 0
+
+ // skip up to three spaces
+ for i < 3 && data[i] == ' ' {
+ i++
+ }
+
+ // look at the hrule char
+ if data[i] != '*' && data[i] != '-' && data[i] != '_' {
+ return false
+ }
+ c := data[i]
+
+ // the whole line must be the char or whitespace
+ n := 0
+ for i < len(data) && data[i] != '\n' {
+ switch {
+ case data[i] == c:
+ n++
+ case data[i] != ' ':
+ return false
+ }
+ i++
+ }
+
+ return n >= 3
+}
+
+// isFenceLine checks if there's a fence line (e.g., ``` or ``` go) at the beginning of data,
+// and returns the end index if so, or 0 otherwise. It also returns the marker found.
+// If info is not nil, it gets set to the syntax specified in the fence line.
+func isFenceLine(data []byte, info *string, oldmarker string) (end int, marker string) {
+ i, size := 0, 0
+
+ // skip up to three spaces
+ for i < len(data) && i < 3 && data[i] == ' ' {
+ i++
+ }
+
+ // check for the marker characters: ~ or `
+ if i >= len(data) {
+ return 0, ""
+ }
+ if data[i] != '~' && data[i] != '`' {
+ return 0, ""
+ }
+
+ c := data[i]
+
+ // the whole line must be the same char or whitespace
+ for i < len(data) && data[i] == c {
+ size++
+ i++
+ }
+
+ // the marker char must occur at least 3 times
+ if size < 3 {
+ return 0, ""
+ }
+ marker = string(data[i-size : i])
+
+ // if this is the end marker, it must match the beginning marker
+ if oldmarker != "" && marker != oldmarker {
+ return 0, ""
+ }
+
+ // TODO(shurcooL): It's probably a good idea to simplify the 2 code paths here
+ // into one, always get the info string, and discard it if the caller doesn't care.
+ if info != nil {
+ infoLength := 0
+ i = skipChar(data, i, ' ')
+
+ if i >= len(data) {
+ if i == len(data) {
+ return i, marker
+ }
+ return 0, ""
+ }
+
+ infoStart := i
+
+ if data[i] == '{' {
+ i++
+ infoStart++
+
+ for i < len(data) && data[i] != '}' && data[i] != '\n' {
+ infoLength++
+ i++
+ }
+
+ if i >= len(data) || data[i] != '}' {
+ return 0, ""
+ }
+
+ // strip all whitespace at the beginning and the end
+ // of the {} block
+ for infoLength > 0 && isspace(data[infoStart]) {
+ infoStart++
+ infoLength--
+ }
+
+ for infoLength > 0 && isspace(data[infoStart+infoLength-1]) {
+ infoLength--
+ }
+ i++
+ i = skipChar(data, i, ' ')
+ } else {
+ for i < len(data) && !isverticalspace(data[i]) {
+ infoLength++
+ i++
+ }
+ }
+
+ *info = strings.TrimSpace(string(data[infoStart : infoStart+infoLength]))
+ }
+
+ if i == len(data) {
+ return i, marker
+ }
+ if i > len(data) || data[i] != '\n' {
+ return 0, ""
+ }
+ return i + 1, marker // Take newline into account.
+}
+
+// fencedCodeBlock returns the end index if data contains a fenced code block at the beginning,
+// or 0 otherwise. It writes to out if doRender is true, otherwise it has no side effects.
+// If doRender is true, a final newline is mandatory to recognize the fenced code block.
+func (p *Markdown) fencedCodeBlock(data []byte, doRender bool) int {
+ var info string
+ beg, marker := isFenceLine(data, &info, "")
+ if beg == 0 || beg >= len(data) {
+ return 0
+ }
+ fenceLength := beg - 1
+
+ var work bytes.Buffer
+ work.Write([]byte(info))
+ work.WriteByte('\n')
+
+ for {
+ // safe to assume beg < len(data)
+
+ // check for the end of the code block
+ fenceEnd, _ := isFenceLine(data[beg:], nil, marker)
+ if fenceEnd != 0 {
+ beg += fenceEnd
+ break
+ }
+
+ // copy the current line
+ end := skipUntilChar(data, beg, '\n') + 1
+
+ // did we reach the end of the buffer without a closing marker?
+ if end >= len(data) {
+ return 0
+ }
+
+ // verbatim copy to the working buffer
+ if doRender {
+ work.Write(data[beg:end])
+ }
+ beg = end
+ }
+
+ if doRender {
+ block := p.addBlock(CodeBlock, work.Bytes()) // TODO: get rid of temp buffer
+ block.IsFenced = true
+ block.FenceLength = fenceLength
+ finalizeCodeBlock(block)
+ }
+
+ return beg
+}
+
+func unescapeChar(str []byte) []byte {
+ if str[0] == '\\' {
+ return []byte{str[1]}
+ }
+ return []byte(html.UnescapeString(string(str)))
+}
+
+func unescapeString(str []byte) []byte {
+ if reBackslashOrAmp.Match(str) {
+ return reEntityOrEscapedChar.ReplaceAllFunc(str, unescapeChar)
+ }
+ return str
+}
+
+func finalizeCodeBlock(block *Node) {
+ if block.IsFenced {
+ newlinePos := bytes.IndexByte(block.content, '\n')
+ firstLine := block.content[:newlinePos]
+ rest := block.content[newlinePos+1:]
+ block.Info = unescapeString(bytes.Trim(firstLine, "\n"))
+ block.Literal = rest
+ } else {
+ block.Literal = block.content
+ }
+ block.content = nil
+}
+
+func (p *Markdown) table(data []byte) int {
+ table := p.addBlock(Table, nil)
+ i, columns := p.tableHeader(data)
+ if i == 0 {
+ p.tip = table.Parent
+ table.Unlink()
+ return 0
+ }
+
+ p.addBlock(TableBody, nil)
+
+ for i < len(data) {
+ pipes, rowStart := 0, i
+ for ; i < len(data) && data[i] != '\n'; i++ {
+ if data[i] == '|' {
+ pipes++
+ }
+ }
+
+ if pipes == 0 {
+ i = rowStart
+ break
+ }
+
+ // include the newline in data sent to tableRow
+ if i < len(data) && data[i] == '\n' {
+ i++
+ }
+ p.tableRow(data[rowStart:i], columns, false)
+ }
+
+ return i
+}
+
+// check if the specified position is preceded by an odd number of backslashes
+func isBackslashEscaped(data []byte, i int) bool {
+ backslashes := 0
+ for i-backslashes-1 >= 0 && data[i-backslashes-1] == '\\' {
+ backslashes++
+ }
+ return backslashes&1 == 1
+}
+
+func (p *Markdown) tableHeader(data []byte) (size int, columns []CellAlignFlags) {
+ i := 0
+ colCount := 1
+ for i = 0; i < len(data) && data[i] != '\n'; i++ {
+ if data[i] == '|' && !isBackslashEscaped(data, i) {
+ colCount++
+ }
+ }
+
+ // doesn't look like a table header
+ if colCount == 1 {
+ return
+ }
+
+ // include the newline in the data sent to tableRow
+ j := i
+ if j < len(data) && data[j] == '\n' {
+ j++
+ }
+ header := data[:j]
+
+ // column count ignores pipes at beginning or end of line
+ if data[0] == '|' {
+ colCount--
+ }
+ if i > 2 && data[i-1] == '|' && !isBackslashEscaped(data, i-1) {
+ colCount--
+ }
+
+ columns = make([]CellAlignFlags, colCount)
+
+ // move on to the header underline
+ i++
+ if i >= len(data) {
+ return
+ }
+
+ if data[i] == '|' && !isBackslashEscaped(data, i) {
+ i++
+ }
+ i = skipChar(data, i, ' ')
+
+ // each column header is of form: / *:?-+:? *|/ with # dashes + # colons >= 3
+ // and trailing | optional on last column
+ col := 0
+ for i < len(data) && data[i] != '\n' {
+ dashes := 0
+
+ if data[i] == ':' {
+ i++
+ columns[col] |= TableAlignmentLeft
+ dashes++
+ }
+ for i < len(data) && data[i] == '-' {
+ i++
+ dashes++
+ }
+ if i < len(data) && data[i] == ':' {
+ i++
+ columns[col] |= TableAlignmentRight
+ dashes++
+ }
+ for i < len(data) && data[i] == ' ' {
+ i++
+ }
+ if i == len(data) {
+ return
+ }
+ // end of column test is messy
+ switch {
+ case dashes < 3:
+ // not a valid column
+ return
+
+ case data[i] == '|' && !isBackslashEscaped(data, i):
+ // marker found, now skip past trailing whitespace
+ col++
+ i++
+ for i < len(data) && data[i] == ' ' {
+ i++
+ }
+
+ // trailing junk found after last column
+ if col >= colCount && i < len(data) && data[i] != '\n' {
+ return
+ }
+
+ case (data[i] != '|' || isBackslashEscaped(data, i)) && col+1 < colCount:
+ // something else found where marker was required
+ return
+
+ case data[i] == '\n':
+ // marker is optional for the last column
+ col++
+
+ default:
+ // trailing junk found after last column
+ return
+ }
+ }
+ if col != colCount {
+ return
+ }
+
+ p.addBlock(TableHead, nil)
+ p.tableRow(header, columns, true)
+ size = i
+ if size < len(data) && data[size] == '\n' {
+ size++
+ }
+ return
+}
+
+func (p *Markdown) tableRow(data []byte, columns []CellAlignFlags, header bool) {
+ p.addBlock(TableRow, nil)
+ i, col := 0, 0
+
+ if data[i] == '|' && !isBackslashEscaped(data, i) {
+ i++
+ }
+
+ for col = 0; col < len(columns) && i < len(data); col++ {
+ for i < len(data) && data[i] == ' ' {
+ i++
+ }
+
+ cellStart := i
+
+ for i < len(data) && (data[i] != '|' || isBackslashEscaped(data, i)) && data[i] != '\n' {
+ i++
+ }
+
+ cellEnd := i
+
+ // skip the end-of-cell marker, possibly taking us past end of buffer
+ i++
+
+ for cellEnd > cellStart && cellEnd-1 < len(data) && data[cellEnd-1] == ' ' {
+ cellEnd--
+ }
+
+ cell := p.addBlock(TableCell, data[cellStart:cellEnd])
+ cell.IsHeader = header
+ cell.Align = columns[col]
+ }
+
+ // pad it out with empty columns to get the right number
+ for ; col < len(columns); col++ {
+ cell := p.addBlock(TableCell, nil)
+ cell.IsHeader = header
+ cell.Align = columns[col]
+ }
+
+ // silently ignore rows with too many cells
+}
+
+// returns blockquote prefix length
+func (p *Markdown) quotePrefix(data []byte) int {
+ i := 0
+ for i < 3 && i < len(data) && data[i] == ' ' {
+ i++
+ }
+ if i < len(data) && data[i] == '>' {
+ if i+1 < len(data) && data[i+1] == ' ' {
+ return i + 2
+ }
+ return i + 1
+ }
+ return 0
+}
+
+// blockquote ends with at least one blank line
+// followed by something without a blockquote prefix
+func (p *Markdown) terminateBlockquote(data []byte, beg, end int) bool {
+ if p.isEmpty(data[beg:]) <= 0 {
+ return false
+ }
+ if end >= len(data) {
+ return true
+ }
+ return p.quotePrefix(data[end:]) == 0 && p.isEmpty(data[end:]) == 0
+}
+
+// parse a blockquote fragment
+func (p *Markdown) quote(data []byte) int {
+ block := p.addBlock(BlockQuote, nil)
+ var raw bytes.Buffer
+ beg, end := 0, 0
+ for beg < len(data) {
+ end = beg
+ // Step over whole lines, collecting them. While doing that, check for
+ // fenced code and if one's found, incorporate it altogether,
+ // irregardless of any contents inside it
+ for end < len(data) && data[end] != '\n' {
+ if p.extensions&FencedCode != 0 {
+ if i := p.fencedCodeBlock(data[end:], false); i > 0 {
+ // -1 to compensate for the extra end++ after the loop:
+ end += i - 1
+ break
+ }
+ }
+ end++
+ }
+ if end < len(data) && data[end] == '\n' {
+ end++
+ }
+ if pre := p.quotePrefix(data[beg:]); pre > 0 {
+ // skip the prefix
+ beg += pre
+ } else if p.terminateBlockquote(data, beg, end) {
+ break
+ }
+ // this line is part of the blockquote
+ raw.Write(data[beg:end])
+ beg = end
+ }
+ p.block(raw.Bytes())
+ p.finalize(block)
+ return end
+}
+
+// returns prefix length for block code
+func (p *Markdown) codePrefix(data []byte) int {
+ if len(data) >= 1 && data[0] == '\t' {
+ return 1
+ }
+ if len(data) >= 4 && data[0] == ' ' && data[1] == ' ' && data[2] == ' ' && data[3] == ' ' {
+ return 4
+ }
+ return 0
+}
+
+func (p *Markdown) code(data []byte) int {
+ var work bytes.Buffer
+
+ i := 0
+ for i < len(data) {
+ beg := i
+ for i < len(data) && data[i] != '\n' {
+ i++
+ }
+ if i < len(data) && data[i] == '\n' {
+ i++
+ }
+
+ blankline := p.isEmpty(data[beg:i]) > 0
+ if pre := p.codePrefix(data[beg:i]); pre > 0 {
+ beg += pre
+ } else if !blankline {
+ // non-empty, non-prefixed line breaks the pre
+ i = beg
+ break
+ }
+
+ // verbatim copy to the working buffer
+ if blankline {
+ work.WriteByte('\n')
+ } else {
+ work.Write(data[beg:i])
+ }
+ }
+
+ // trim all the \n off the end of work
+ workbytes := work.Bytes()
+ eol := len(workbytes)
+ for eol > 0 && workbytes[eol-1] == '\n' {
+ eol--
+ }
+ if eol != len(workbytes) {
+ work.Truncate(eol)
+ }
+
+ work.WriteByte('\n')
+
+ block := p.addBlock(CodeBlock, work.Bytes()) // TODO: get rid of temp buffer
+ block.IsFenced = false
+ finalizeCodeBlock(block)
+
+ return i
+}
+
+// returns unordered list item prefix
+func (p *Markdown) uliPrefix(data []byte) int {
+ i := 0
+ // start with up to 3 spaces
+ for i < len(data) && i < 3 && data[i] == ' ' {
+ i++
+ }
+ if i >= len(data)-1 {
+ return 0
+ }
+ // need one of {'*', '+', '-'} followed by a space or a tab
+ if (data[i] != '*' && data[i] != '+' && data[i] != '-') ||
+ (data[i+1] != ' ' && data[i+1] != '\t') {
+ return 0
+ }
+ return i + 2
+}
+
+// returns ordered list item prefix
+func (p *Markdown) oliPrefix(data []byte) int {
+ i := 0
+
+ // start with up to 3 spaces
+ for i < 3 && i < len(data) && data[i] == ' ' {
+ i++
+ }
+
+ // count the digits
+ start := i
+ for i < len(data) && data[i] >= '0' && data[i] <= '9' {
+ i++
+ }
+ if start == i || i >= len(data)-1 {
+ return 0
+ }
+
+ // we need >= 1 digits followed by a dot and a space or a tab
+ if data[i] != '.' || !(data[i+1] == ' ' || data[i+1] == '\t') {
+ return 0
+ }
+ return i + 2
+}
+
+// returns definition list item prefix
+func (p *Markdown) dliPrefix(data []byte) int {
+ if len(data) < 2 {
+ return 0
+ }
+ i := 0
+ // need a ':' followed by a space or a tab
+ if data[i] != ':' || !(data[i+1] == ' ' || data[i+1] == '\t') {
+ return 0
+ }
+ for i < len(data) && data[i] == ' ' {
+ i++
+ }
+ return i + 2
+}
+
+// parse ordered or unordered list block
+func (p *Markdown) list(data []byte, flags ListType) int {
+ i := 0
+ flags |= ListItemBeginningOfList
+ block := p.addBlock(List, nil)
+ block.ListFlags = flags
+ block.Tight = true
+
+ for i < len(data) {
+ skip := p.listItem(data[i:], &flags)
+ if flags&ListItemContainsBlock != 0 {
+ block.ListData.Tight = false
+ }
+ i += skip
+ if skip == 0 || flags&ListItemEndOfList != 0 {
+ break
+ }
+ flags &= ^ListItemBeginningOfList
+ }
+
+ above := block.Parent
+ finalizeList(block)
+ p.tip = above
+ return i
+}
+
+// Returns true if the list item is not the same type as its parent list
+func (p *Markdown) listTypeChanged(data []byte, flags *ListType) bool {
+ if p.dliPrefix(data) > 0 && *flags&ListTypeDefinition == 0 {
+ return true
+ } else if p.oliPrefix(data) > 0 && *flags&ListTypeOrdered == 0 {
+ return true
+ } else if p.uliPrefix(data) > 0 && (*flags&ListTypeOrdered != 0 || *flags&ListTypeDefinition != 0) {
+ return true
+ }
+ return false
+}
+
+// Returns true if block ends with a blank line, descending if needed
+// into lists and sublists.
+func endsWithBlankLine(block *Node) bool {
+ // TODO: figure this out. Always false now.
+ for block != nil {
+ //if block.lastLineBlank {
+ //return true
+ //}
+ t := block.Type
+ if t == List || t == Item {
+ block = block.LastChild
+ } else {
+ break
+ }
+ }
+ return false
+}
+
+func finalizeList(block *Node) {
+ block.open = false
+ item := block.FirstChild
+ for item != nil {
+ // check for non-final list item ending with blank line:
+ if endsWithBlankLine(item) && item.Next != nil {
+ block.ListData.Tight = false
+ break
+ }
+ // recurse into children of list item, to see if there are spaces
+ // between any of them:
+ subItem := item.FirstChild
+ for subItem != nil {
+ if endsWithBlankLine(subItem) && (item.Next != nil || subItem.Next != nil) {
+ block.ListData.Tight = false
+ break
+ }
+ subItem = subItem.Next
+ }
+ item = item.Next
+ }
+}
+
+// Parse a single list item.
+// Assumes initial prefix is already removed if this is a sublist.
+func (p *Markdown) listItem(data []byte, flags *ListType) int {
+ // keep track of the indentation of the first line
+ itemIndent := 0
+ if data[0] == '\t' {
+ itemIndent += 4
+ } else {
+ for itemIndent < 3 && data[itemIndent] == ' ' {
+ itemIndent++
+ }
+ }
+
+ var bulletChar byte = '*'
+ i := p.uliPrefix(data)
+ if i == 0 {
+ i = p.oliPrefix(data)
+ } else {
+ bulletChar = data[i-2]
+ }
+ if i == 0 {
+ i = p.dliPrefix(data)
+ // reset definition term flag
+ if i > 0 {
+ *flags &= ^ListTypeTerm
+ }
+ }
+ if i == 0 {
+ // if in definition list, set term flag and continue
+ if *flags&ListTypeDefinition != 0 {
+ *flags |= ListTypeTerm
+ } else {
+ return 0
+ }
+ }
+
+ // skip leading whitespace on first line
+ for i < len(data) && data[i] == ' ' {
+ i++
+ }
+
+ // find the end of the line
+ line := i
+ for i > 0 && i < len(data) && data[i-1] != '\n' {
+ i++
+ }
+
+ // get working buffer
+ var raw bytes.Buffer
+
+ // put the first line into the working buffer
+ raw.Write(data[line:i])
+ line = i
+
+ // process the following lines
+ containsBlankLine := false
+ sublist := 0
+ codeBlockMarker := ""
+
+gatherlines:
+ for line < len(data) {
+ i++
+
+ // find the end of this line
+ for i < len(data) && data[i-1] != '\n' {
+ i++
+ }
+
+ // if it is an empty line, guess that it is part of this item
+ // and move on to the next line
+ if p.isEmpty(data[line:i]) > 0 {
+ containsBlankLine = true
+ line = i
+ continue
+ }
+
+ // calculate the indentation
+ indent := 0
+ indentIndex := 0
+ if data[line] == '\t' {
+ indentIndex++
+ indent += 4
+ } else {
+ for indent < 4 && line+indent < i && data[line+indent] == ' ' {
+ indent++
+ indentIndex++
+ }
+ }
+
+ chunk := data[line+indentIndex : i]
+
+ if p.extensions&FencedCode != 0 {
+ // determine if in or out of codeblock
+ // if in codeblock, ignore normal list processing
+ _, marker := isFenceLine(chunk, nil, codeBlockMarker)
+ if marker != "" {
+ if codeBlockMarker == "" {
+ // start of codeblock
+ codeBlockMarker = marker
+ } else {
+ // end of codeblock.
+ codeBlockMarker = ""
+ }
+ }
+ // we are in a codeblock, write line, and continue
+ if codeBlockMarker != "" || marker != "" {
+ raw.Write(data[line+indentIndex : i])
+ line = i
+ continue gatherlines
+ }
+ }
+
+ // evaluate how this line fits in
+ switch {
+ // is this a nested list item?
+ case (p.uliPrefix(chunk) > 0 && !p.isHRule(chunk)) ||
+ p.oliPrefix(chunk) > 0 ||
+ p.dliPrefix(chunk) > 0:
+
+ // to be a nested list, it must be indented more
+ // if not, it is either a different kind of list
+ // or the next item in the same list
+ if indent <= itemIndent {
+ if p.listTypeChanged(chunk, flags) {
+ *flags |= ListItemEndOfList
+ } else if containsBlankLine {
+ *flags |= ListItemContainsBlock
+ }
+
+ break gatherlines
+ }
+
+ if containsBlankLine {
+ *flags |= ListItemContainsBlock
+ }
+
+ // is this the first item in the nested list?
+ if sublist == 0 {
+ sublist = raw.Len()
+ }
+
+ // is this a nested prefix heading?
+ case p.isPrefixHeading(chunk):
+ // if the heading is not indented, it is not nested in the list
+ // and thus ends the list
+ if containsBlankLine && indent < 4 {
+ *flags |= ListItemEndOfList
+ break gatherlines
+ }
+ *flags |= ListItemContainsBlock
+
+ // anything following an empty line is only part
+ // of this item if it is indented 4 spaces
+ // (regardless of the indentation of the beginning of the item)
+ case containsBlankLine && indent < 4:
+ if *flags&ListTypeDefinition != 0 && i < len(data)-1 {
+ // is the next item still a part of this list?
+ next := i
+ for next < len(data) && data[next] != '\n' {
+ next++
+ }
+ for next < len(data)-1 && data[next] == '\n' {
+ next++
+ }
+ if i < len(data)-1 && data[i] != ':' && data[next] != ':' {
+ *flags |= ListItemEndOfList
+ }
+ } else {
+ *flags |= ListItemEndOfList
+ }
+ break gatherlines
+
+ // a blank line means this should be parsed as a block
+ case containsBlankLine:
+ raw.WriteByte('\n')
+ *flags |= ListItemContainsBlock
+ }
+
+ // if this line was preceded by one or more blanks,
+ // re-introduce the blank into the buffer
+ if containsBlankLine {
+ containsBlankLine = false
+ raw.WriteByte('\n')
+ }
+
+ // add the line into the working buffer without prefix
+ raw.Write(data[line+indentIndex : i])
+
+ line = i
+ }
+
+ rawBytes := raw.Bytes()
+
+ block := p.addBlock(Item, nil)
+ block.ListFlags = *flags
+ block.Tight = false
+ block.BulletChar = bulletChar
+ block.Delimiter = '.' // Only '.' is possible in Markdown, but ')' will also be possible in CommonMark
+
+ // render the contents of the list item
+ if *flags&ListItemContainsBlock != 0 && *flags&ListTypeTerm == 0 {
+ // intermediate render of block item, except for definition term
+ if sublist > 0 {
+ p.block(rawBytes[:sublist])
+ p.block(rawBytes[sublist:])
+ } else {
+ p.block(rawBytes)
+ }
+ } else {
+ // intermediate render of inline item
+ if sublist > 0 {
+ child := p.addChild(Paragraph, 0)
+ child.content = rawBytes[:sublist]
+ p.block(rawBytes[sublist:])
+ } else {
+ child := p.addChild(Paragraph, 0)
+ child.content = rawBytes
+ }
+ }
+ return line
+}
+
+// render a single paragraph that has already been parsed out
+func (p *Markdown) renderParagraph(data []byte) {
+ if len(data) == 0 {
+ return
+ }
+
+ // trim leading spaces
+ beg := 0
+ for data[beg] == ' ' {
+ beg++
+ }
+
+ end := len(data)
+ // trim trailing newline
+ if data[len(data)-1] == '\n' {
+ end--
+ }
+
+ // trim trailing spaces
+ for end > beg && data[end-1] == ' ' {
+ end--
+ }
+
+ p.addBlock(Paragraph, data[beg:end])
+}
+
+func (p *Markdown) paragraph(data []byte) int {
+ // prev: index of 1st char of previous line
+ // line: index of 1st char of current line
+ // i: index of cursor/end of current line
+ var prev, line, i int
+ tabSize := TabSizeDefault
+ if p.extensions&TabSizeEight != 0 {
+ tabSize = TabSizeDouble
+ }
+ // keep going until we find something to mark the end of the paragraph
+ for i < len(data) {
+ // mark the beginning of the current line
+ prev = line
+ current := data[i:]
+ line = i
+
+ // did we find a reference or a footnote? If so, end a paragraph
+ // preceding it and report that we have consumed up to the end of that
+ // reference:
+ if refEnd := isReference(p, current, tabSize); refEnd > 0 {
+ p.renderParagraph(data[:i])
+ return i + refEnd
+ }
+
+ // did we find a blank line marking the end of the paragraph?
+ if n := p.isEmpty(current); n > 0 {
+ // did this blank line followed by a definition list item?
+ if p.extensions&DefinitionLists != 0 {
+ if i < len(data)-1 && data[i+1] == ':' {
+ return p.list(data[prev:], ListTypeDefinition)
+ }
+ }
+
+ p.renderParagraph(data[:i])
+ return i + n
+ }
+
+ // an underline under some text marks a heading, so our paragraph ended on prev line
+ if i > 0 {
+ if level := p.isUnderlinedHeading(current); level > 0 {
+ // render the paragraph
+ p.renderParagraph(data[:prev])
+
+ // ignore leading and trailing whitespace
+ eol := i - 1
+ for prev < eol && data[prev] == ' ' {
+ prev++
+ }
+ for eol > prev && data[eol-1] == ' ' {
+ eol--
+ }
+
+ id := ""
+ if p.extensions&AutoHeadingIDs != 0 {
+ id = SanitizedAnchorName(string(data[prev:eol]))
+ }
+
+ block := p.addBlock(Heading, data[prev:eol])
+ block.Level = level
+ block.HeadingID = id
+
+ // find the end of the underline
+ for i < len(data) && data[i] != '\n' {
+ i++
+ }
+ return i
+ }
+ }
+
+ // if the next line starts a block of HTML, then the paragraph ends here
+ if p.extensions&LaxHTMLBlocks != 0 {
+ if data[i] == '<' && p.html(current, false) > 0 {
+ // rewind to before the HTML block
+ p.renderParagraph(data[:i])
+ return i
+ }
+ }
+
+ // if there's a prefixed heading or a horizontal rule after this, paragraph is over
+ if p.isPrefixHeading(current) || p.isHRule(current) {
+ p.renderParagraph(data[:i])
+ return i
+ }
+
+ // if there's a fenced code block, paragraph is over
+ if p.extensions&FencedCode != 0 {
+ if p.fencedCodeBlock(current, false) > 0 {
+ p.renderParagraph(data[:i])
+ return i
+ }
+ }
+
+ // if there's a definition list item, prev line is a definition term
+ if p.extensions&DefinitionLists != 0 {
+ if p.dliPrefix(current) != 0 {
+ ret := p.list(data[prev:], ListTypeDefinition)
+ return ret
+ }
+ }
+
+ // if there's a list after this, paragraph is over
+ if p.extensions&NoEmptyLineBeforeBlock != 0 {
+ if p.uliPrefix(current) != 0 ||
+ p.oliPrefix(current) != 0 ||
+ p.quotePrefix(current) != 0 ||
+ p.codePrefix(current) != 0 {
+ p.renderParagraph(data[:i])
+ return i
+ }
+ }
+
+ // otherwise, scan to the beginning of the next line
+ nl := bytes.IndexByte(data[i:], '\n')
+ if nl >= 0 {
+ i += nl + 1
+ } else {
+ i += len(data[i:])
+ }
+ }
+
+ p.renderParagraph(data[:i])
+ return i
+}
+
+func skipChar(data []byte, start int, char byte) int {
+ i := start
+ for i < len(data) && data[i] == char {
+ i++
+ }
+ return i
+}
+
+func skipUntilChar(text []byte, start int, char byte) int {
+ i := start
+ for i < len(text) && text[i] != char {
+ i++
+ }
+ return i
+}
+
+// SanitizedAnchorName returns a sanitized anchor name for the given text.
+//
+// It implements the algorithm specified in the package comment.
+func SanitizedAnchorName(text string) string {
+ var anchorName []rune
+ futureDash := false
+ for _, r := range text {
+ switch {
+ case unicode.IsLetter(r) || unicode.IsNumber(r):
+ if futureDash && len(anchorName) > 0 {
+ anchorName = append(anchorName, '-')
+ }
+ futureDash = false
+ anchorName = append(anchorName, unicode.ToLower(r))
+ default:
+ futureDash = true
+ }
+ }
+ return string(anchorName)
+}
diff --git a/vendor/github.com/russross/blackfriday/v2/doc.go b/vendor/github.com/russross/blackfriday/v2/doc.go
new file mode 100644
index 0000000..57ff152
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/doc.go
@@ -0,0 +1,46 @@
+// Package blackfriday is a markdown processor.
+//
+// It translates plain text with simple formatting rules into an AST, which can
+// then be further processed to HTML (provided by Blackfriday itself) or other
+// formats (provided by the community).
+//
+// The simplest way to invoke Blackfriday is to call the Run function. It will
+// take a text input and produce a text output in HTML (or other format).
+//
+// A slightly more sophisticated way to use Blackfriday is to create a Markdown
+// processor and to call Parse, which returns a syntax tree for the input
+// document. You can leverage Blackfriday's parsing for content extraction from
+// markdown documents. You can assign a custom renderer and set various options
+// to the Markdown processor.
+//
+// If you're interested in calling Blackfriday from command line, see
+// https://github.com/russross/blackfriday-tool.
+//
+// Sanitized Anchor Names
+//
+// Blackfriday includes an algorithm for creating sanitized anchor names
+// corresponding to a given input text. This algorithm is used to create
+// anchors for headings when AutoHeadingIDs extension is enabled. The
+// algorithm is specified below, so that other packages can create
+// compatible anchor names and links to those anchors.
+//
+// The algorithm iterates over the input text, interpreted as UTF-8,
+// one Unicode code point (rune) at a time. All runes that are letters (category L)
+// or numbers (category N) are considered valid characters. They are mapped to
+// lower case, and included in the output. All other runes are considered
+// invalid characters. Invalid characters that precede the first valid character,
+// as well as invalid character that follow the last valid character
+// are dropped completely. All other sequences of invalid characters
+// between two valid characters are replaced with a single dash character '-'.
+//
+// SanitizedAnchorName exposes this functionality, and can be used to
+// create compatible links to the anchor names generated by blackfriday.
+// This algorithm is also implemented in a small standalone package at
+// github.com/shurcooL/sanitized_anchor_name. It can be useful for clients
+// that want a small package and don't need full functionality of blackfriday.
+package blackfriday
+
+// NOTE: Keep Sanitized Anchor Name algorithm in sync with package
+// github.com/shurcooL/sanitized_anchor_name.
+// Otherwise, users of sanitized_anchor_name will get anchor names
+// that are incompatible with those generated by blackfriday.
diff --git a/vendor/github.com/russross/blackfriday/v2/entities.go b/vendor/github.com/russross/blackfriday/v2/entities.go
new file mode 100644
index 0000000..a2c3edb
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/entities.go
@@ -0,0 +1,2236 @@
+package blackfriday
+
+// Extracted from https://html.spec.whatwg.org/multipage/entities.json
+var entities = map[string]bool{
+ "Æ": true,
+ "Æ": true,
+ "&": true,
+ "&": true,
+ "Á": true,
+ "Á": true,
+ "Ă": true,
+ "Â": true,
+ "Â": true,
+ "А": true,
+ "𝔄": true,
+ "À": true,
+ "À": true,
+ "Α": true,
+ "Ā": true,
+ "⩓": true,
+ "Ą": true,
+ "𝔸": true,
+ "⁡": true,
+ "Å": true,
+ "Å": true,
+ "𝒜": true,
+ "≔": true,
+ "Ã": true,
+ "Ã": true,
+ "Ä": true,
+ "Ä": true,
+ "∖": true,
+ "⫧": true,
+ "⌆": true,
+ "Б": true,
+ "∵": true,
+ "ℬ": true,
+ "Β": true,
+ "𝔅": true,
+ "𝔹": true,
+ "˘": true,
+ "ℬ": true,
+ "≎": true,
+ "Ч": true,
+ "©": true,
+ "©": true,
+ "Ć": true,
+ "⋒": true,
+ "ⅅ": true,
+ "ℭ": true,
+ "Č": true,
+ "Ç": true,
+ "Ç": true,
+ "Ĉ": true,
+ "∰": true,
+ "Ċ": true,
+ "¸": true,
+ "·": true,
+ "ℭ": true,
+ "Χ": true,
+ "⊙": true,
+ "⊖": true,
+ "⊕": true,
+ "⊗": true,
+ "∲": true,
+ "”": true,
+ "’": true,
+ "∷": true,
+ "⩴": true,
+ "≡": true,
+ "∯": true,
+ "∮": true,
+ "ℂ": true,
+ "∐": true,
+ "∳": true,
+ "⨯": true,
+ "𝒞": true,
+ "⋓": true,
+ "≍": true,
+ "ⅅ": true,
+ "⤑": true,
+ "Ђ": true,
+ "Ѕ": true,
+ "Џ": true,
+ "‡": true,
+ "↡": true,
+ "⫤": true,
+ "Ď": true,
+ "Д": true,
+ "∇": true,
+ "Δ": true,
+ "𝔇": true,
+ "´": true,
+ "˙": true,
+ "˝": true,
+ "`": true,
+ "˜": true,
+ "⋄": true,
+ "ⅆ": true,
+ "𝔻": true,
+ "¨": true,
+ "⃜": true,
+ "≐": true,
+ "∯": true,
+ "¨": true,
+ "⇓": true,
+ "⇐": true,
+ "⇔": true,
+ "⫤": true,
+ "⟸": true,
+ "⟺": true,
+ "⟹": true,
+ "⇒": true,
+ "⊨": true,
+ "⇑": true,
+ "⇕": true,
+ "∥": true,
+ "↓": true,
+ "⤓": true,
+ "⇵": true,
+ "̑": true,
+ "⥐": true,
+ "⥞": true,
+ "↽": true,
+ "⥖": true,
+ "⥟": true,
+ "⇁": true,
+ "⥗": true,
+ "⊤": true,
+ "↧": true,
+ "⇓": true,
+ "𝒟": true,
+ "Đ": true,
+ "Ŋ": true,
+ "Ð": true,
+ "Ð": true,
+ "É": true,
+ "É": true,
+ "Ě": true,
+ "Ê": true,
+ "Ê": true,
+ "Э": true,
+ "Ė": true,
+ "𝔈": true,
+ "È": true,
+ "È": true,
+ "∈": true,
+ "Ē": true,
+ "◻": true,
+ "▫": true,
+ "Ę": true,
+ "𝔼": true,
+ "Ε": true,
+ "⩵": true,
+ "≂": true,
+ "⇌": true,
+ "ℰ": true,
+ "⩳": true,
+ "Η": true,
+ "Ë": true,
+ "Ë": true,
+ "∃": true,
+ "ⅇ": true,
+ "Ф": true,
+ "𝔉": true,
+ "◼": true,
+ "▪": true,
+ "𝔽": true,
+ "∀": true,
+ "ℱ": true,
+ "ℱ": true,
+ "Ѓ": true,
+ ">": true,
+ ">": true,
+ "Γ": true,
+ "Ϝ": true,
+ "Ğ": true,
+ "Ģ": true,
+ "Ĝ": true,
+ "Г": true,
+ "Ġ": true,
+ "𝔊": true,
+ "⋙": true,
+ "𝔾": true,
+ "≥": true,
+ "⋛": true,
+ "≧": true,
+ "⪢": true,
+ "≷": true,
+ "⩾": true,
+ "≳": true,
+ "𝒢": true,
+ "≫": true,
+ "Ъ": true,
+ "ˇ": true,
+ "^": true,
+ "Ĥ": true,
+ "ℌ": true,
+ "ℋ": true,
+ "ℍ": true,
+ "─": true,
+ "ℋ": true,
+ "Ħ": true,
+ "≎": true,
+ "≏": true,
+ "Е": true,
+ "IJ": true,
+ "Ё": true,
+ "Í": true,
+ "Í": true,
+ "Î": true,
+ "Î": true,
+ "И": true,
+ "İ": true,
+ "ℑ": true,
+ "Ì": true,
+ "Ì": true,
+ "ℑ": true,
+ "Ī": true,
+ "ⅈ": true,
+ "⇒": true,
+ "∬": true,
+ "∫": true,
+ "⋂": true,
+ "⁣": true,
+ "⁢": true,
+ "Į": true,
+ "𝕀": true,
+ "Ι": true,
+ "ℐ": true,
+ "Ĩ": true,
+ "І": true,
+ "Ï": true,
+ "Ï": true,
+ "Ĵ": true,
+ "Й": true,
+ "𝔍": true,
+ "𝕁": true,
+ "𝒥": true,
+ "Ј": true,
+ "Є": true,
+ "Х": true,
+ "Ќ": true,
+ "Κ": true,
+ "Ķ": true,
+ "К": true,
+ "𝔎": true,
+ "𝕂": true,
+ "𝒦": true,
+ "Љ": true,
+ "<": true,
+ "<": true,
+ "Ĺ": true,
+ "Λ": true,
+ "⟪": true,
+ "ℒ": true,
+ "↞": true,
+ "Ľ": true,
+ "Ļ": true,
+ "Л": true,
+ "⟨": true,
+ "←": true,
+ "⇤": true,
+ "⇆": true,
+ "⌈": true,
+ "⟦": true,
+ "⥡": true,
+ "⇃": true,
+ "⥙": true,
+ "⌊": true,
+ "↔": true,
+ "⥎": true,
+ "⊣": true,
+ "↤": true,
+ "⥚": true,
+ "⊲": true,
+ "⧏": true,
+ "⊴": true,
+ "⥑": true,
+ "⥠": true,
+ "↿": true,
+ "⥘": true,
+ "↼": true,
+ "⥒": true,
+ "⇐": true,
+ "⇔": true,
+ "⋚": true,
+ "≦": true,
+ "≶": true,
+ "⪡": true,
+ "⩽": true,
+ "≲": true,
+ "𝔏": true,
+ "⋘": true,
+ "⇚": true,
+ "Ŀ": true,
+ "⟵": true,
+ "⟷": true,
+ "⟶": true,
+ "⟸": true,
+ "⟺": true,
+ "⟹": true,
+ "𝕃": true,
+ "↙": true,
+ "↘": true,
+ "ℒ": true,
+ "↰": true,
+ "Ł": true,
+ "≪": true,
+ "⤅": true,
+ "М": true,
+ " ": true,
+ "ℳ": true,
+ "𝔐": true,
+ "∓": true,
+ "𝕄": true,
+ "ℳ": true,
+ "Μ": true,
+ "Њ": true,
+ "Ń": true,
+ "Ň": true,
+ "Ņ": true,
+ "Н": true,
+ "​": true,
+ "​": true,
+ "​": true,
+ "​": true,
+ "≫": true,
+ "≪": true,
+ "
": true,
+ "𝔑": true,
+ "⁠": true,
+ " ": true,
+ "ℕ": true,
+ "⫬": true,
+ "≢": true,
+ "≭": true,
+ "∦": true,
+ "∉": true,
+ "≠": true,
+ "≂̸": true,
+ "∄": true,
+ "≯": true,
+ "≱": true,
+ "≧̸": true,
+ "≫̸": true,
+ "≹": true,
+ "⩾̸": true,
+ "≵": true,
+ "≎̸": true,
+ "≏̸": true,
+ "⋪": true,
+ "⧏̸": true,
+ "⋬": true,
+ "≮": true,
+ "≰": true,
+ "≸": true,
+ "≪̸": true,
+ "⩽̸": true,
+ "≴": true,
+ "⪢̸": true,
+ "⪡̸": true,
+ "⊀": true,
+ "⪯̸": true,
+ "⋠": true,
+ "∌": true,
+ "⋫": true,
+ "⧐̸": true,
+ "⋭": true,
+ "⊏̸": true,
+ "⋢": true,
+ "⊐̸": true,
+ "⋣": true,
+ "⊂⃒": true,
+ "⊈": true,
+ "⊁": true,
+ "⪰̸": true,
+ "⋡": true,
+ "≿̸": true,
+ "⊃⃒": true,
+ "⊉": true,
+ "≁": true,
+ "≄": true,
+ "≇": true,
+ "≉": true,
+ "∤": true,
+ "𝒩": true,
+ "Ñ": true,
+ "Ñ": true,
+ "Ν": true,
+ "Œ": true,
+ "Ó": true,
+ "Ó": true,
+ "Ô": true,
+ "Ô": true,
+ "О": true,
+ "Ő": true,
+ "𝔒": true,
+ "Ò": true,
+ "Ò": true,
+ "Ō": true,
+ "Ω": true,
+ "Ο": true,
+ "𝕆": true,
+ "“": true,
+ "‘": true,
+ "⩔": true,
+ "𝒪": true,
+ "Ø": true,
+ "Ø": true,
+ "Õ": true,
+ "Õ": true,
+ "⨷": true,
+ "Ö": true,
+ "Ö": true,
+ "‾": true,
+ "⏞": true,
+ "⎴": true,
+ "⏜": true,
+ "∂": true,
+ "П": true,
+ "𝔓": true,
+ "Φ": true,
+ "Π": true,
+ "±": true,
+ "ℌ": true,
+ "ℙ": true,
+ "⪻": true,
+ "≺": true,
+ "⪯": true,
+ "≼": true,
+ "≾": true,
+ "″": true,
+ "∏": true,
+ "∷": true,
+ "∝": true,
+ "𝒫": true,
+ "Ψ": true,
+ """: true,
+ """: true,
+ "𝔔": true,
+ "ℚ": true,
+ "𝒬": true,
+ "⤐": true,
+ "®": true,
+ "®": true,
+ "Ŕ": true,
+ "⟫": true,
+ "↠": true,
+ "⤖": true,
+ "Ř": true,
+ "Ŗ": true,
+ "Р": true,
+ "ℜ": true,
+ "∋": true,
+ "⇋": true,
+ "⥯": true,
+ "ℜ": true,
+ "Ρ": true,
+ "⟩": true,
+ "→": true,
+ "⇥": true,
+ "⇄": true,
+ "⌉": true,
+ "⟧": true,
+ "⥝": true,
+ "⇂": true,
+ "⥕": true,
+ "⌋": true,
+ "⊢": true,
+ "↦": true,
+ "⥛": true,
+ "⊳": true,
+ "⧐": true,
+ "⊵": true,
+ "⥏": true,
+ "⥜": true,
+ "↾": true,
+ "⥔": true,
+ "⇀": true,
+ "⥓": true,
+ "⇒": true,
+ "ℝ": true,
+ "⥰": true,
+ "⇛": true,
+ "ℛ": true,
+ "↱": true,
+ "⧴": true,
+ "Щ": true,
+ "Ш": true,
+ "Ь": true,
+ "Ś": true,
+ "⪼": true,
+ "Š": true,
+ "Ş": true,
+ "Ŝ": true,
+ "С": true,
+ "𝔖": true,
+ "↓": true,
+ "←": true,
+ "→": true,
+ "↑": true,
+ "Σ": true,
+ "∘": true,
+ "𝕊": true,
+ "√": true,
+ "□": true,
+ "⊓": true,
+ "⊏": true,
+ "⊑": true,
+ "⊐": true,
+ "⊒": true,
+ "⊔": true,
+ "𝒮": true,
+ "⋆": true,
+ "⋐": true,
+ "⋐": true,
+ "⊆": true,
+ "≻": true,
+ "⪰": true,
+ "≽": true,
+ "≿": true,
+ "∋": true,
+ "∑": true,
+ "⋑": true,
+ "⊃": true,
+ "⊇": true,
+ "⋑": true,
+ "Þ": true,
+ "Þ": true,
+ "™": true,
+ "Ћ": true,
+ "Ц": true,
+ "	": true,
+ "Τ": true,
+ "Ť": true,
+ "Ţ": true,
+ "Т": true,
+ "𝔗": true,
+ "∴": true,
+ "Θ": true,
+ "  ": true,
+ " ": true,
+ "∼": true,
+ "≃": true,
+ "≅": true,
+ "≈": true,
+ "𝕋": true,
+ "⃛": true,
+ "𝒯": true,
+ "Ŧ": true,
+ "Ú": true,
+ "Ú": true,
+ "↟": true,
+ "⥉": true,
+ "Ў": true,
+ "Ŭ": true,
+ "Û": true,
+ "Û": true,
+ "У": true,
+ "Ű": true,
+ "𝔘": true,
+ "Ù": true,
+ "Ù": true,
+ "Ū": true,
+ "_": true,
+ "⏟": true,
+ "⎵": true,
+ "⏝": true,
+ "⋃": true,
+ "⊎": true,
+ "Ų": true,
+ "𝕌": true,
+ "↑": true,
+ "⤒": true,
+ "⇅": true,
+ "↕": true,
+ "⥮": true,
+ "⊥": true,
+ "↥": true,
+ "⇑": true,
+ "⇕": true,
+ "↖": true,
+ "↗": true,
+ "ϒ": true,
+ "Υ": true,
+ "Ů": true,
+ "𝒰": true,
+ "Ũ": true,
+ "Ü": true,
+ "Ü": true,
+ "⊫": true,
+ "⫫": true,
+ "В": true,
+ "⊩": true,
+ "⫦": true,
+ "⋁": true,
+ "‖": true,
+ "‖": true,
+ "∣": true,
+ "|": true,
+ "❘": true,
+ "≀": true,
+ " ": true,
+ "𝔙": true,
+ "𝕍": true,
+ "𝒱": true,
+ "⊪": true,
+ "Ŵ": true,
+ "⋀": true,
+ "𝔚": true,
+ "𝕎": true,
+ "𝒲": true,
+ "𝔛": true,
+ "Ξ": true,
+ "𝕏": true,
+ "𝒳": true,
+ "Я": true,
+ "Ї": true,
+ "Ю": true,
+ "Ý": true,
+ "Ý": true,
+ "Ŷ": true,
+ "Ы": true,
+ "𝔜": true,
+ "𝕐": true,
+ "𝒴": true,
+ "Ÿ": true,
+ "Ж": true,
+ "Ź": true,
+ "Ž": true,
+ "З": true,
+ "Ż": true,
+ "​": true,
+ "Ζ": true,
+ "ℨ": true,
+ "ℤ": true,
+ "𝒵": true,
+ "á": true,
+ "á": true,
+ "ă": true,
+ "∾": true,
+ "∾̳": true,
+ "∿": true,
+ "â": true,
+ "â": true,
+ "´": true,
+ "´": true,
+ "а": true,
+ "æ": true,
+ "æ": true,
+ "⁡": true,
+ "𝔞": true,
+ "à": true,
+ "à": true,
+ "ℵ": true,
+ "ℵ": true,
+ "α": true,
+ "ā": true,
+ "⨿": true,
+ "&": true,
+ "&": true,
+ "∧": true,
+ "⩕": true,
+ "⩜": true,
+ "⩘": true,
+ "⩚": true,
+ "∠": true,
+ "⦤": true,
+ "∠": true,
+ "∡": true,
+ "⦨": true,
+ "⦩": true,
+ "⦪": true,
+ "⦫": true,
+ "⦬": true,
+ "⦭": true,
+ "⦮": true,
+ "⦯": true,
+ "∟": true,
+ "⊾": true,
+ "⦝": true,
+ "∢": true,
+ "Å": true,
+ "⍼": true,
+ "ą": true,
+ "𝕒": true,
+ "≈": true,
+ "⩰": true,
+ "⩯": true,
+ "≊": true,
+ "≋": true,
+ "'": true,
+ "≈": true,
+ "≊": true,
+ "å": true,
+ "å": true,
+ "𝒶": true,
+ "*": true,
+ "≈": true,
+ "≍": true,
+ "ã": true,
+ "ã": true,
+ "ä": true,
+ "ä": true,
+ "∳": true,
+ "⨑": true,
+ "⫭": true,
+ "≌": true,
+ "϶": true,
+ "‵": true,
+ "∽": true,
+ "⋍": true,
+ "⊽": true,
+ "⌅": true,
+ "⌅": true,
+ "⎵": true,
+ "⎶": true,
+ "≌": true,
+ "б": true,
+ "„": true,
+ "∵": true,
+ "∵": true,
+ "⦰": true,
+ "϶": true,
+ "ℬ": true,
+ "β": true,
+ "ℶ": true,
+ "≬": true,
+ "𝔟": true,
+ "⋂": true,
+ "◯": true,
+ "⋃": true,
+ "⨀": true,
+ "⨁": true,
+ "⨂": true,
+ "⨆": true,
+ "★": true,
+ "▽": true,
+ "△": true,
+ "⨄": true,
+ "⋁": true,
+ "⋀": true,
+ "⤍": true,
+ "⧫": true,
+ "▪": true,
+ "▴": true,
+ "▾": true,
+ "◂": true,
+ "▸": true,
+ "␣": true,
+ "▒": true,
+ "░": true,
+ "▓": true,
+ "█": true,
+ "=⃥": true,
+ "≡⃥": true,
+ "⌐": true,
+ "𝕓": true,
+ "⊥": true,
+ "⊥": true,
+ "⋈": true,
+ "╗": true,
+ "╔": true,
+ "╖": true,
+ "╓": true,
+ "═": true,
+ "╦": true,
+ "╩": true,
+ "╤": true,
+ "╧": true,
+ "╝": true,
+ "╚": true,
+ "╜": true,
+ "╙": true,
+ "║": true,
+ "╬": true,
+ "╣": true,
+ "╠": true,
+ "╫": true,
+ "╢": true,
+ "╟": true,
+ "⧉": true,
+ "╕": true,
+ "╒": true,
+ "┐": true,
+ "┌": true,
+ "─": true,
+ "╥": true,
+ "╨": true,
+ "┬": true,
+ "┴": true,
+ "⊟": true,
+ "⊞": true,
+ "⊠": true,
+ "╛": true,
+ "╘": true,
+ "┘": true,
+ "└": true,
+ "│": true,
+ "╪": true,
+ "╡": true,
+ "╞": true,
+ "┼": true,
+ "┤": true,
+ "├": true,
+ "‵": true,
+ "˘": true,
+ "¦": true,
+ "¦": true,
+ "𝒷": true,
+ "⁏": true,
+ "∽": true,
+ "⋍": true,
+ "\": true,
+ "⧅": true,
+ "⟈": true,
+ "•": true,
+ "•": true,
+ "≎": true,
+ "⪮": true,
+ "≏": true,
+ "≏": true,
+ "ć": true,
+ "∩": true,
+ "⩄": true,
+ "⩉": true,
+ "⩋": true,
+ "⩇": true,
+ "⩀": true,
+ "∩︀": true,
+ "⁁": true,
+ "ˇ": true,
+ "⩍": true,
+ "č": true,
+ "ç": true,
+ "ç": true,
+ "ĉ": true,
+ "⩌": true,
+ "⩐": true,
+ "ċ": true,
+ "¸": true,
+ "¸": true,
+ "⦲": true,
+ "¢": true,
+ "¢": true,
+ "·": true,
+ "𝔠": true,
+ "ч": true,
+ "✓": true,
+ "✓": true,
+ "χ": true,
+ "○": true,
+ "⧃": true,
+ "ˆ": true,
+ "≗": true,
+ "↺": true,
+ "↻": true,
+ "®": true,
+ "Ⓢ": true,
+ "⊛": true,
+ "⊚": true,
+ "⊝": true,
+ "≗": true,
+ "⨐": true,
+ "⫯": true,
+ "⧂": true,
+ "♣": true,
+ "♣": true,
+ ":": true,
+ "≔": true,
+ "≔": true,
+ ",": true,
+ "@": true,
+ "∁": true,
+ "∘": true,
+ "∁": true,
+ "ℂ": true,
+ "≅": true,
+ "⩭": true,
+ "∮": true,
+ "𝕔": true,
+ "∐": true,
+ "©": true,
+ "©": true,
+ "℗": true,
+ "↵": true,
+ "✗": true,
+ "𝒸": true,
+ "⫏": true,
+ "⫑": true,
+ "⫐": true,
+ "⫒": true,
+ "⋯": true,
+ "⤸": true,
+ "⤵": true,
+ "⋞": true,
+ "⋟": true,
+ "↶": true,
+ "⤽": true,
+ "∪": true,
+ "⩈": true,
+ "⩆": true,
+ "⩊": true,
+ "⊍": true,
+ "⩅": true,
+ "∪︀": true,
+ "↷": true,
+ "⤼": true,
+ "⋞": true,
+ "⋟": true,
+ "⋎": true,
+ "⋏": true,
+ "¤": true,
+ "¤": true,
+ "↶": true,
+ "↷": true,
+ "⋎": true,
+ "⋏": true,
+ "∲": true,
+ "∱": true,
+ "⌭": true,
+ "⇓": true,
+ "⥥": true,
+ "†": true,
+ "ℸ": true,
+ "↓": true,
+ "‐": true,
+ "⊣": true,
+ "⤏": true,
+ "˝": true,
+ "ď": true,
+ "д": true,
+ "ⅆ": true,
+ "‡": true,
+ "⇊": true,
+ "⩷": true,
+ "°": true,
+ "°": true,
+ "δ": true,
+ "⦱": true,
+ "⥿": true,
+ "𝔡": true,
+ "⇃": true,
+ "⇂": true,
+ "⋄": true,
+ "⋄": true,
+ "♦": true,
+ "♦": true,
+ "¨": true,
+ "ϝ": true,
+ "⋲": true,
+ "÷": true,
+ "÷": true,
+ "÷": true,
+ "⋇": true,
+ "⋇": true,
+ "ђ": true,
+ "⌞": true,
+ "⌍": true,
+ "$": true,
+ "𝕕": true,
+ "˙": true,
+ "≐": true,
+ "≑": true,
+ "∸": true,
+ "∔": true,
+ "⊡": true,
+ "⌆": true,
+ "↓": true,
+ "⇊": true,
+ "⇃": true,
+ "⇂": true,
+ "⤐": true,
+ "⌟": true,
+ "⌌": true,
+ "𝒹": true,
+ "ѕ": true,
+ "⧶": true,
+ "đ": true,
+ "⋱": true,
+ "▿": true,
+ "▾": true,
+ "⇵": true,
+ "⥯": true,
+ "⦦": true,
+ "џ": true,
+ "⟿": true,
+ "⩷": true,
+ "≑": true,
+ "é": true,
+ "é": true,
+ "⩮": true,
+ "ě": true,
+ "≖": true,
+ "ê": true,
+ "ê": true,
+ "≕": true,
+ "э": true,
+ "ė": true,
+ "ⅇ": true,
+ "≒": true,
+ "𝔢": true,
+ "⪚": true,
+ "è": true,
+ "è": true,
+ "⪖": true,
+ "⪘": true,
+ "⪙": true,
+ "⏧": true,
+ "ℓ": true,
+ "⪕": true,
+ "⪗": true,
+ "ē": true,
+ "∅": true,
+ "∅": true,
+ "∅": true,
+ " ": true,
+ " ": true,
+ " ": true,
+ "ŋ": true,
+ " ": true,
+ "ę": true,
+ "𝕖": true,
+ "⋕": true,
+ "⧣": true,
+ "⩱": true,
+ "ε": true,
+ "ε": true,
+ "ϵ": true,
+ "≖": true,
+ "≕": true,
+ "≂": true,
+ "⪖": true,
+ "⪕": true,
+ "=": true,
+ "≟": true,
+ "≡": true,
+ "⩸": true,
+ "⧥": true,
+ "≓": true,
+ "⥱": true,
+ "ℯ": true,
+ "≐": true,
+ "≂": true,
+ "η": true,
+ "ð": true,
+ "ð": true,
+ "ë": true,
+ "ë": true,
+ "€": true,
+ "!": true,
+ "∃": true,
+ "ℰ": true,
+ "ⅇ": true,
+ "≒": true,
+ "ф": true,
+ "♀": true,
+ "ffi": true,
+ "ff": true,
+ "ffl": true,
+ "𝔣": true,
+ "fi": true,
+ "fj": true,
+ "♭": true,
+ "fl": true,
+ "▱": true,
+ "ƒ": true,
+ "𝕗": true,
+ "∀": true,
+ "⋔": true,
+ "⫙": true,
+ "⨍": true,
+ "½": true,
+ "½": true,
+ "⅓": true,
+ "¼": true,
+ "¼": true,
+ "⅕": true,
+ "⅙": true,
+ "⅛": true,
+ "⅔": true,
+ "⅖": true,
+ "¾": true,
+ "¾": true,
+ "⅗": true,
+ "⅜": true,
+ "⅘": true,
+ "⅚": true,
+ "⅝": true,
+ "⅞": true,
+ "⁄": true,
+ "⌢": true,
+ "𝒻": true,
+ "≧": true,
+ "⪌": true,
+ "ǵ": true,
+ "γ": true,
+ "ϝ": true,
+ "⪆": true,
+ "ğ": true,
+ "ĝ": true,
+ "г": true,
+ "ġ": true,
+ "≥": true,
+ "⋛": true,
+ "≥": true,
+ "≧": true,
+ "⩾": true,
+ "⩾": true,
+ "⪩": true,
+ "⪀": true,
+ "⪂": true,
+ "⪄": true,
+ "⋛︀": true,
+ "⪔": true,
+ "𝔤": true,
+ "≫": true,
+ "⋙": true,
+ "ℷ": true,
+ "ѓ": true,
+ "≷": true,
+ "⪒": true,
+ "⪥": true,
+ "⪤": true,
+ "≩": true,
+ "⪊": true,
+ "⪊": true,
+ "⪈": true,
+ "⪈": true,
+ "≩": true,
+ "⋧": true,
+ "𝕘": true,
+ "`": true,
+ "ℊ": true,
+ "≳": true,
+ "⪎": true,
+ "⪐": true,
+ ">": true,
+ ">": true,
+ "⪧": true,
+ "⩺": true,
+ "⋗": true,
+ "⦕": true,
+ "⩼": true,
+ "⪆": true,
+ "⥸": true,
+ "⋗": true,
+ "⋛": true,
+ "⪌": true,
+ "≷": true,
+ "≳": true,
+ "≩︀": true,
+ "≩︀": true,
+ "⇔": true,
+ " ": true,
+ "½": true,
+ "ℋ": true,
+ "ъ": true,
+ "↔": true,
+ "⥈": true,
+ "↭": true,
+ "ℏ": true,
+ "ĥ": true,
+ "♥": true,
+ "♥": true,
+ "…": true,
+ "⊹": true,
+ "𝔥": true,
+ "⤥": true,
+ "⤦": true,
+ "⇿": true,
+ "∻": true,
+ "↩": true,
+ "↪": true,
+ "𝕙": true,
+ "―": true,
+ "𝒽": true,
+ "ℏ": true,
+ "ħ": true,
+ "⁃": true,
+ "‐": true,
+ "í": true,
+ "í": true,
+ "⁣": true,
+ "î": true,
+ "î": true,
+ "и": true,
+ "е": true,
+ "¡": true,
+ "¡": true,
+ "⇔": true,
+ "𝔦": true,
+ "ì": true,
+ "ì": true,
+ "ⅈ": true,
+ "⨌": true,
+ "∭": true,
+ "⧜": true,
+ "℩": true,
+ "ij": true,
+ "ī": true,
+ "ℑ": true,
+ "ℐ": true,
+ "ℑ": true,
+ "ı": true,
+ "⊷": true,
+ "Ƶ": true,
+ "∈": true,
+ "℅": true,
+ "∞": true,
+ "⧝": true,
+ "ı": true,
+ "∫": true,
+ "⊺": true,
+ "ℤ": true,
+ "⊺": true,
+ "⨗": true,
+ "⨼": true,
+ "ё": true,
+ "į": true,
+ "𝕚": true,
+ "ι": true,
+ "⨼": true,
+ "¿": true,
+ "¿": true,
+ "𝒾": true,
+ "∈": true,
+ "⋹": true,
+ "⋵": true,
+ "⋴": true,
+ "⋳": true,
+ "∈": true,
+ "⁢": true,
+ "ĩ": true,
+ "і": true,
+ "ï": true,
+ "ï": true,
+ "ĵ": true,
+ "й": true,
+ "𝔧": true,
+ "ȷ": true,
+ "𝕛": true,
+ "𝒿": true,
+ "ј": true,
+ "є": true,
+ "κ": true,
+ "ϰ": true,
+ "ķ": true,
+ "к": true,
+ "𝔨": true,
+ "ĸ": true,
+ "х": true,
+ "ќ": true,
+ "𝕜": true,
+ "𝓀": true,
+ "⇚": true,
+ "⇐": true,
+ "⤛": true,
+ "⤎": true,
+ "≦": true,
+ "⪋": true,
+ "⥢": true,
+ "ĺ": true,
+ "⦴": true,
+ "ℒ": true,
+ "λ": true,
+ "〈": true,
+ "⦑": true,
+ "⟨": true,
+ "⪅": true,
+ "«": true,
+ "«": true,
+ "←": true,
+ "⇤": true,
+ "⤟": true,
+ "⤝": true,
+ "↩": true,
+ "↫": true,
+ "⤹": true,
+ "⥳": true,
+ "↢": true,
+ "⪫": true,
+ "⤙": true,
+ "⪭": true,
+ "⪭︀": true,
+ "⤌": true,
+ "❲": true,
+ "{": true,
+ "[": true,
+ "⦋": true,
+ "⦏": true,
+ "⦍": true,
+ "ľ": true,
+ "ļ": true,
+ "⌈": true,
+ "{": true,
+ "л": true,
+ "⤶": true,
+ "“": true,
+ "„": true,
+ "⥧": true,
+ "⥋": true,
+ "↲": true,
+ "≤": true,
+ "←": true,
+ "↢": true,
+ "↽": true,
+ "↼": true,
+ "⇇": true,
+ "↔": true,
+ "⇆": true,
+ "⇋": true,
+ "↭": true,
+ "⋋": true,
+ "⋚": true,
+ "≤": true,
+ "≦": true,
+ "⩽": true,
+ "⩽": true,
+ "⪨": true,
+ "⩿": true,
+ "⪁": true,
+ "⪃": true,
+ "⋚︀": true,
+ "⪓": true,
+ "⪅": true,
+ "⋖": true,
+ "⋚": true,
+ "⪋": true,
+ "≶": true,
+ "≲": true,
+ "⥼": true,
+ "⌊": true,
+ "𝔩": true,
+ "≶": true,
+ "⪑": true,
+ "↽": true,
+ "↼": true,
+ "⥪": true,
+ "▄": true,
+ "љ": true,
+ "≪": true,
+ "⇇": true,
+ "⌞": true,
+ "⥫": true,
+ "◺": true,
+ "ŀ": true,
+ "⎰": true,
+ "⎰": true,
+ "≨": true,
+ "⪉": true,
+ "⪉": true,
+ "⪇": true,
+ "⪇": true,
+ "≨": true,
+ "⋦": true,
+ "⟬": true,
+ "⇽": true,
+ "⟦": true,
+ "⟵": true,
+ "⟷": true,
+ "⟼": true,
+ "⟶": true,
+ "↫": true,
+ "↬": true,
+ "⦅": true,
+ "𝕝": true,
+ "⨭": true,
+ "⨴": true,
+ "∗": true,
+ "_": true,
+ "◊": true,
+ "◊": true,
+ "⧫": true,
+ "(": true,
+ "⦓": true,
+ "⇆": true,
+ "⌟": true,
+ "⇋": true,
+ "⥭": true,
+ "": true,
+ "⊿": true,
+ "‹": true,
+ "𝓁": true,
+ "↰": true,
+ "≲": true,
+ "⪍": true,
+ "⪏": true,
+ "[": true,
+ "‘": true,
+ "‚": true,
+ "ł": true,
+ "<": true,
+ "<": true,
+ "⪦": true,
+ "⩹": true,
+ "⋖": true,
+ "⋋": true,
+ "⋉": true,
+ "⥶": true,
+ "⩻": true,
+ "⦖": true,
+ "◃": true,
+ "⊴": true,
+ "◂": true,
+ "⥊": true,
+ "⥦": true,
+ "≨︀": true,
+ "≨︀": true,
+ "∺": true,
+ "¯": true,
+ "¯": true,
+ "♂": true,
+ "✠": true,
+ "✠": true,
+ "↦": true,
+ "↦": true,
+ "↧": true,
+ "↤": true,
+ "↥": true,
+ "▮": true,
+ "⨩": true,
+ "м": true,
+ "—": true,
+ "∡": true,
+ "𝔪": true,
+ "℧": true,
+ "µ": true,
+ "µ": true,
+ "∣": true,
+ "*": true,
+ "⫰": true,
+ "·": true,
+ "·": true,
+ "−": true,
+ "⊟": true,
+ "∸": true,
+ "⨪": true,
+ "⫛": true,
+ "…": true,
+ "∓": true,
+ "⊧": true,
+ "𝕞": true,
+ "∓": true,
+ "𝓂": true,
+ "∾": true,
+ "μ": true,
+ "⊸": true,
+ "⊸": true,
+ "⋙̸": true,
+ "≫⃒": true,
+ "≫̸": true,
+ "⇍": true,
+ "⇎": true,
+ "⋘̸": true,
+ "≪⃒": true,
+ "≪̸": true,
+ "⇏": true,
+ "⊯": true,
+ "⊮": true,
+ "∇": true,
+ "ń": true,
+ "∠⃒": true,
+ "≉": true,
+ "⩰̸": true,
+ "≋̸": true,
+ "ʼn": true,
+ "≉": true,
+ "♮": true,
+ "♮": true,
+ "ℕ": true,
+ " ": true,
+ " ": true,
+ "≎̸": true,
+ "≏̸": true,
+ "⩃": true,
+ "ň": true,
+ "ņ": true,
+ "≇": true,
+ "⩭̸": true,
+ "⩂": true,
+ "н": true,
+ "–": true,
+ "≠": true,
+ "⇗": true,
+ "⤤": true,
+ "↗": true,
+ "↗": true,
+ "≐̸": true,
+ "≢": true,
+ "⤨": true,
+ "≂̸": true,
+ "∄": true,
+ "∄": true,
+ "𝔫": true,
+ "≧̸": true,
+ "≱": true,
+ "≱": true,
+ "≧̸": true,
+ "⩾̸": true,
+ "⩾̸": true,
+ "≵": true,
+ "≯": true,
+ "≯": true,
+ "⇎": true,
+ "↮": true,
+ "⫲": true,
+ "∋": true,
+ "⋼": true,
+ "⋺": true,
+ "∋": true,
+ "њ": true,
+ "⇍": true,
+ "≦̸": true,
+ "↚": true,
+ "‥": true,
+ "≰": true,
+ "↚": true,
+ "↮": true,
+ "≰": true,
+ "≦̸": true,
+ "⩽̸": true,
+ "⩽̸": true,
+ "≮": true,
+ "≴": true,
+ "≮": true,
+ "⋪": true,
+ "⋬": true,
+ "∤": true,
+ "𝕟": true,
+ "¬": true,
+ "¬": true,
+ "∉": true,
+ "⋹̸": true,
+ "⋵̸": true,
+ "∉": true,
+ "⋷": true,
+ "⋶": true,
+ "∌": true,
+ "∌": true,
+ "⋾": true,
+ "⋽": true,
+ "∦": true,
+ "∦": true,
+ "⫽⃥": true,
+ "∂̸": true,
+ "⨔": true,
+ "⊀": true,
+ "⋠": true,
+ "⪯̸": true,
+ "⊀": true,
+ "⪯̸": true,
+ "⇏": true,
+ "↛": true,
+ "⤳̸": true,
+ "↝̸": true,
+ "↛": true,
+ "⋫": true,
+ "⋭": true,
+ "⊁": true,
+ "⋡": true,
+ "⪰̸": true,
+ "𝓃": true,
+ "∤": true,
+ "∦": true,
+ "≁": true,
+ "≄": true,
+ "≄": true,
+ "∤": true,
+ "∦": true,
+ "⋢": true,
+ "⋣": true,
+ "⊄": true,
+ "⫅̸": true,
+ "⊈": true,
+ "⊂⃒": true,
+ "⊈": true,
+ "⫅̸": true,
+ "⊁": true,
+ "⪰̸": true,
+ "⊅": true,
+ "⫆̸": true,
+ "⊉": true,
+ "⊃⃒": true,
+ "⊉": true,
+ "⫆̸": true,
+ "≹": true,
+ "ñ": true,
+ "ñ": true,
+ "≸": true,
+ "⋪": true,
+ "⋬": true,
+ "⋫": true,
+ "⋭": true,
+ "ν": true,
+ "#": true,
+ "№": true,
+ " ": true,
+ "⊭": true,
+ "⤄": true,
+ "≍⃒": true,
+ "⊬": true,
+ "≥⃒": true,
+ ">⃒": true,
+ "⧞": true,
+ "⤂": true,
+ "≤⃒": true,
+ "<⃒": true,
+ "⊴⃒": true,
+ "⤃": true,
+ "⊵⃒": true,
+ "∼⃒": true,
+ "⇖": true,
+ "⤣": true,
+ "↖": true,
+ "↖": true,
+ "⤧": true,
+ "Ⓢ": true,
+ "ó": true,
+ "ó": true,
+ "⊛": true,
+ "⊚": true,
+ "ô": true,
+ "ô": true,
+ "о": true,
+ "⊝": true,
+ "ő": true,
+ "⨸": true,
+ "⊙": true,
+ "⦼": true,
+ "œ": true,
+ "⦿": true,
+ "𝔬": true,
+ "˛": true,
+ "ò": true,
+ "ò": true,
+ "⧁": true,
+ "⦵": true,
+ "Ω": true,
+ "∮": true,
+ "↺": true,
+ "⦾": true,
+ "⦻": true,
+ "‾": true,
+ "⧀": true,
+ "ō": true,
+ "ω": true,
+ "ο": true,
+ "⦶": true,
+ "⊖": true,
+ "𝕠": true,
+ "⦷": true,
+ "⦹": true,
+ "⊕": true,
+ "∨": true,
+ "↻": true,
+ "⩝": true,
+ "ℴ": true,
+ "ℴ": true,
+ "ª": true,
+ "ª": true,
+ "º": true,
+ "º": true,
+ "⊶": true,
+ "⩖": true,
+ "⩗": true,
+ "⩛": true,
+ "ℴ": true,
+ "ø": true,
+ "ø": true,
+ "⊘": true,
+ "õ": true,
+ "õ": true,
+ "⊗": true,
+ "⨶": true,
+ "ö": true,
+ "ö": true,
+ "⌽": true,
+ "∥": true,
+ "¶": true,
+ "¶": true,
+ "∥": true,
+ "⫳": true,
+ "⫽": true,
+ "∂": true,
+ "п": true,
+ "%": true,
+ ".": true,
+ "‰": true,
+ "⊥": true,
+ "‱": true,
+ "𝔭": true,
+ "φ": true,
+ "ϕ": true,
+ "ℳ": true,
+ "☎": true,
+ "π": true,
+ "⋔": true,
+ "ϖ": true,
+ "ℏ": true,
+ "ℎ": true,
+ "ℏ": true,
+ "+": true,
+ "⨣": true,
+ "⊞": true,
+ "⨢": true,
+ "∔": true,
+ "⨥": true,
+ "⩲": true,
+ "±": true,
+ "±": true,
+ "⨦": true,
+ "⨧": true,
+ "±": true,
+ "⨕": true,
+ "𝕡": true,
+ "£": true,
+ "£": true,
+ "≺": true,
+ "⪳": true,
+ "⪷": true,
+ "≼": true,
+ "⪯": true,
+ "≺": true,
+ "⪷": true,
+ "≼": true,
+ "⪯": true,
+ "⪹": true,
+ "⪵": true,
+ "⋨": true,
+ "≾": true,
+ "′": true,
+ "ℙ": true,
+ "⪵": true,
+ "⪹": true,
+ "⋨": true,
+ "∏": true,
+ "⌮": true,
+ "⌒": true,
+ "⌓": true,
+ "∝": true,
+ "∝": true,
+ "≾": true,
+ "⊰": true,
+ "𝓅": true,
+ "ψ": true,
+ " ": true,
+ "𝔮": true,
+ "⨌": true,
+ "𝕢": true,
+ "⁗": true,
+ "𝓆": true,
+ "ℍ": true,
+ "⨖": true,
+ "?": true,
+ "≟": true,
+ """: true,
+ """: true,
+ "⇛": true,
+ "⇒": true,
+ "⤜": true,
+ "⤏": true,
+ "⥤": true,
+ "∽̱": true,
+ "ŕ": true,
+ "√": true,
+ "⦳": true,
+ "〉": true,
+ "⦒": true,
+ "⦥": true,
+ "⟩": true,
+ "»": true,
+ "»": true,
+ "→": true,
+ "⥵": true,
+ "⇥": true,
+ "⤠": true,
+ "⤳": true,
+ "⤞": true,
+ "↪": true,
+ "↬": true,
+ "⥅": true,
+ "⥴": true,
+ "↣": true,
+ "↝": true,
+ "⤚": true,
+ "∶": true,
+ "ℚ": true,
+ "⤍": true,
+ "❳": true,
+ "}": true,
+ "]": true,
+ "⦌": true,
+ "⦎": true,
+ "⦐": true,
+ "ř": true,
+ "ŗ": true,
+ "⌉": true,
+ "}": true,
+ "р": true,
+ "⤷": true,
+ "⥩": true,
+ "”": true,
+ "”": true,
+ "↳": true,
+ "ℜ": true,
+ "ℛ": true,
+ "ℜ": true,
+ "ℝ": true,
+ "▭": true,
+ "®": true,
+ "®": true,
+ "⥽": true,
+ "⌋": true,
+ "𝔯": true,
+ "⇁": true,
+ "⇀": true,
+ "⥬": true,
+ "ρ": true,
+ "ϱ": true,
+ "→": true,
+ "↣": true,
+ "⇁": true,
+ "⇀": true,
+ "⇄": true,
+ "⇌": true,
+ "⇉": true,
+ "↝": true,
+ "⋌": true,
+ "˚": true,
+ "≓": true,
+ "⇄": true,
+ "⇌": true,
+ "": true,
+ "⎱": true,
+ "⎱": true,
+ "⫮": true,
+ "⟭": true,
+ "⇾": true,
+ "⟧": true,
+ "⦆": true,
+ "𝕣": true,
+ "⨮": true,
+ "⨵": true,
+ ")": true,
+ "⦔": true,
+ "⨒": true,
+ "⇉": true,
+ "›": true,
+ "𝓇": true,
+ "↱": true,
+ "]": true,
+ "’": true,
+ "’": true,
+ "⋌": true,
+ "⋊": true,
+ "▹": true,
+ "⊵": true,
+ "▸": true,
+ "⧎": true,
+ "⥨": true,
+ "℞": true,
+ "ś": true,
+ "‚": true,
+ "≻": true,
+ "⪴": true,
+ "⪸": true,
+ "š": true,
+ "≽": true,
+ "⪰": true,
+ "ş": true,
+ "ŝ": true,
+ "⪶": true,
+ "⪺": true,
+ "⋩": true,
+ "⨓": true,
+ "≿": true,
+ "с": true,
+ "⋅": true,
+ "⊡": true,
+ "⩦": true,
+ "⇘": true,
+ "⤥": true,
+ "↘": true,
+ "↘": true,
+ "§": true,
+ "§": true,
+ ";": true,
+ "⤩": true,
+ "∖": true,
+ "∖": true,
+ "✶": true,
+ "𝔰": true,
+ "⌢": true,
+ "♯": true,
+ "щ": true,
+ "ш": true,
+ "∣": true,
+ "∥": true,
+ "­": true,
+ "": true,
+ "σ": true,
+ "ς": true,
+ "ς": true,
+ "∼": true,
+ "⩪": true,
+ "≃": true,
+ "≃": true,
+ "⪞": true,
+ "⪠": true,
+ "⪝": true,
+ "⪟": true,
+ "≆": true,
+ "⨤": true,
+ "⥲": true,
+ "←": true,
+ "∖": true,
+ "⨳": true,
+ "⧤": true,
+ "∣": true,
+ "⌣": true,
+ "⪪": true,
+ "⪬": true,
+ "⪬︀": true,
+ "ь": true,
+ "/": true,
+ "⧄": true,
+ "⌿": true,
+ "𝕤": true,
+ "♠": true,
+ "♠": true,
+ "∥": true,
+ "⊓": true,
+ "⊓︀": true,
+ "⊔": true,
+ "⊔︀": true,
+ "⊏": true,
+ "⊑": true,
+ "⊏": true,
+ "⊑": true,
+ "⊐": true,
+ "⊒": true,
+ "⊐": true,
+ "⊒": true,
+ "□": true,
+ "□": true,
+ "▪": true,
+ "▪": true,
+ "→": true,
+ "𝓈": true,
+ "∖": true,
+ "⌣": true,
+ "⋆": true,
+ "☆": true,
+ "★": true,
+ "ϵ": true,
+ "ϕ": true,
+ "¯": true,
+ "⊂": true,
+ "⫅": true,
+ "⪽": true,
+ "⊆": true,
+ "⫃": true,
+ "⫁": true,
+ "⫋": true,
+ "⊊": true,
+ "⪿": true,
+ "⥹": true,
+ "⊂": true,
+ "⊆": true,
+ "⫅": true,
+ "⊊": true,
+ "⫋": true,
+ "⫇": true,
+ "⫕": true,
+ "⫓": true,
+ "≻": true,
+ "⪸": true,
+ "≽": true,
+ "⪰": true,
+ "⪺": true,
+ "⪶": true,
+ "⋩": true,
+ "≿": true,
+ "∑": true,
+ "♪": true,
+ "¹": true,
+ "¹": true,
+ "²": true,
+ "²": true,
+ "³": true,
+ "³": true,
+ "⊃": true,
+ "⫆": true,
+ "⪾": true,
+ "⫘": true,
+ "⊇": true,
+ "⫄": true,
+ "⟉": true,
+ "⫗": true,
+ "⥻": true,
+ "⫂": true,
+ "⫌": true,
+ "⊋": true,
+ "⫀": true,
+ "⊃": true,
+ "⊇": true,
+ "⫆": true,
+ "⊋": true,
+ "⫌": true,
+ "⫈": true,
+ "⫔": true,
+ "⫖": true,
+ "⇙": true,
+ "⤦": true,
+ "↙": true,
+ "↙": true,
+ "⤪": true,
+ "ß": true,
+ "ß": true,
+ "⌖": true,
+ "τ": true,
+ "⎴": true,
+ "ť": true,
+ "ţ": true,
+ "т": true,
+ "⃛": true,
+ "⌕": true,
+ "𝔱": true,
+ "∴": true,
+ "∴": true,
+ "θ": true,
+ "ϑ": true,
+ "ϑ": true,
+ "≈": true,
+ "∼": true,
+ " ": true,
+ "≈": true,
+ "∼": true,
+ "þ": true,
+ "þ": true,
+ "˜": true,
+ "×": true,
+ "×": true,
+ "⊠": true,
+ "⨱": true,
+ "⨰": true,
+ "∭": true,
+ "⤨": true,
+ "⊤": true,
+ "⌶": true,
+ "⫱": true,
+ "𝕥": true,
+ "⫚": true,
+ "⤩": true,
+ "‴": true,
+ "™": true,
+ "▵": true,
+ "▿": true,
+ "◃": true,
+ "⊴": true,
+ "≜": true,
+ "▹": true,
+ "⊵": true,
+ "◬": true,
+ "≜": true,
+ "⨺": true,
+ "⨹": true,
+ "⧍": true,
+ "⨻": true,
+ "⏢": true,
+ "𝓉": true,
+ "ц": true,
+ "ћ": true,
+ "ŧ": true,
+ "≬": true,
+ "↞": true,
+ "↠": true,
+ "⇑": true,
+ "⥣": true,
+ "ú": true,
+ "ú": true,
+ "↑": true,
+ "ў": true,
+ "ŭ": true,
+ "û": true,
+ "û": true,
+ "у": true,
+ "⇅": true,
+ "ű": true,
+ "⥮": true,
+ "⥾": true,
+ "𝔲": true,
+ "ù": true,
+ "ù": true,
+ "↿": true,
+ "↾": true,
+ "▀": true,
+ "⌜": true,
+ "⌜": true,
+ "⌏": true,
+ "◸": true,
+ "ū": true,
+ "¨": true,
+ "¨": true,
+ "ų": true,
+ "𝕦": true,
+ "↑": true,
+ "↕": true,
+ "↿": true,
+ "↾": true,
+ "⊎": true,
+ "υ": true,
+ "ϒ": true,
+ "υ": true,
+ "⇈": true,
+ "⌝": true,
+ "⌝": true,
+ "⌎": true,
+ "ů": true,
+ "◹": true,
+ "𝓊": true,
+ "⋰": true,
+ "ũ": true,
+ "▵": true,
+ "▴": true,
+ "⇈": true,
+ "ü": true,
+ "ü": true,
+ "⦧": true,
+ "⇕": true,
+ "⫨": true,
+ "⫩": true,
+ "⊨": true,
+ "⦜": true,
+ "ϵ": true,
+ "ϰ": true,
+ "∅": true,
+ "ϕ": true,
+ "ϖ": true,
+ "∝": true,
+ "↕": true,
+ "ϱ": true,
+ "ς": true,
+ "⊊︀": true,
+ "⫋︀": true,
+ "⊋︀": true,
+ "⫌︀": true,
+ "ϑ": true,
+ "⊲": true,
+ "⊳": true,
+ "в": true,
+ "⊢": true,
+ "∨": true,
+ "⊻": true,
+ "≚": true,
+ "⋮": true,
+ "|": true,
+ "|": true,
+ "𝔳": true,
+ "⊲": true,
+ "⊂⃒": true,
+ "⊃⃒": true,
+ "𝕧": true,
+ "∝": true,
+ "⊳": true,
+ "𝓋": true,
+ "⫋︀": true,
+ "⊊︀": true,
+ "⫌︀": true,
+ "⊋︀": true,
+ "⦚": true,
+ "ŵ": true,
+ "⩟": true,
+ "∧": true,
+ "≙": true,
+ "℘": true,
+ "𝔴": true,
+ "𝕨": true,
+ "℘": true,
+ "≀": true,
+ "≀": true,
+ "𝓌": true,
+ "⋂": true,
+ "◯": true,
+ "⋃": true,
+ "▽": true,
+ "𝔵": true,
+ "⟺": true,
+ "⟷": true,
+ "ξ": true,
+ "⟸": true,
+ "⟵": true,
+ "⟼": true,
+ "⋻": true,
+ "⨀": true,
+ "𝕩": true,
+ "⨁": true,
+ "⨂": true,
+ "⟹": true,
+ "⟶": true,
+ "𝓍": true,
+ "⨆": true,
+ "⨄": true,
+ "△": true,
+ "⋁": true,
+ "⋀": true,
+ "ý": true,
+ "ý": true,
+ "я": true,
+ "ŷ": true,
+ "ы": true,
+ "¥": true,
+ "¥": true,
+ "𝔶": true,
+ "ї": true,
+ "𝕪": true,
+ "𝓎": true,
+ "ю": true,
+ "ÿ": true,
+ "ÿ": true,
+ "ź": true,
+ "ž": true,
+ "з": true,
+ "ż": true,
+ "ℨ": true,
+ "ζ": true,
+ "𝔷": true,
+ "ж": true,
+ "⇝": true,
+ "𝕫": true,
+ "𝓏": true,
+ "": true,
+ "": true,
+}
diff --git a/vendor/github.com/russross/blackfriday/v2/esc.go b/vendor/github.com/russross/blackfriday/v2/esc.go
new file mode 100644
index 0000000..6ab6010
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/esc.go
@@ -0,0 +1,70 @@
+package blackfriday
+
+import (
+ "html"
+ "io"
+)
+
+var htmlEscaper = [256][]byte{
+ '&': []byte("&"),
+ '<': []byte("<"),
+ '>': []byte(">"),
+ '"': []byte("""),
+}
+
+func escapeHTML(w io.Writer, s []byte) {
+ escapeEntities(w, s, false)
+}
+
+func escapeAllHTML(w io.Writer, s []byte) {
+ escapeEntities(w, s, true)
+}
+
+func escapeEntities(w io.Writer, s []byte, escapeValidEntities bool) {
+ var start, end int
+ for end < len(s) {
+ escSeq := htmlEscaper[s[end]]
+ if escSeq != nil {
+ isEntity, entityEnd := nodeIsEntity(s, end)
+ if isEntity && !escapeValidEntities {
+ w.Write(s[start : entityEnd+1])
+ start = entityEnd + 1
+ } else {
+ w.Write(s[start:end])
+ w.Write(escSeq)
+ start = end + 1
+ }
+ }
+ end++
+ }
+ if start < len(s) && end <= len(s) {
+ w.Write(s[start:end])
+ }
+}
+
+func nodeIsEntity(s []byte, end int) (isEntity bool, endEntityPos int) {
+ isEntity = false
+ endEntityPos = end + 1
+
+ if s[end] == '&' {
+ for endEntityPos < len(s) {
+ if s[endEntityPos] == ';' {
+ if entities[string(s[end:endEntityPos+1])] {
+ isEntity = true
+ break
+ }
+ }
+ if !isalnum(s[endEntityPos]) && s[endEntityPos] != '&' && s[endEntityPos] != '#' {
+ break
+ }
+ endEntityPos++
+ }
+ }
+
+ return isEntity, endEntityPos
+}
+
+func escLink(w io.Writer, text []byte) {
+ unesc := html.UnescapeString(string(text))
+ escapeHTML(w, []byte(unesc))
+}
diff --git a/vendor/github.com/russross/blackfriday/v2/html.go b/vendor/github.com/russross/blackfriday/v2/html.go
new file mode 100644
index 0000000..cb4f26e
--- /dev/null
+++ b/vendor/github.com/russross/blackfriday/v2/html.go
@@ -0,0 +1,952 @@
+//
+// Blackfriday Markdown Processor
+// Available at http://github.com/russross/blackfriday
+//
+// Copyright © 2011 Russ Ross .
+// Distributed under the Simplified BSD License.
+// See README.md for details.
+//
+
+//
+//
+// HTML rendering backend
+//
+//
+
+package blackfriday
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "regexp"
+ "strings"
+)
+
+// HTMLFlags control optional behavior of HTML renderer.
+type HTMLFlags int
+
+// HTML renderer configuration options.
+const (
+ HTMLFlagsNone HTMLFlags = 0
+ SkipHTML HTMLFlags = 1 << iota // Skip preformatted HTML blocks
+ SkipImages // Skip embedded images
+ SkipLinks // Skip all links
+ Safelink // Only link to trusted protocols
+ NofollowLinks // Only link with rel="nofollow"
+ NoreferrerLinks // Only link with rel="noreferrer"
+ NoopenerLinks // Only link with rel="noopener"
+ HrefTargetBlank // Add a blank target
+ CompletePage // Generate a complete HTML page
+ UseXHTML // Generate XHTML output instead of HTML
+ FootnoteReturnLinks // Generate a link at the end of a footnote to return to the source
+ Smartypants // Enable smart punctuation substitutions
+ SmartypantsFractions // Enable smart fractions (with Smartypants)
+ SmartypantsDashes // Enable smart dashes (with Smartypants)
+ SmartypantsLatexDashes // Enable LaTeX-style dashes (with Smartypants)
+ SmartypantsAngledQuotes // Enable angled double quotes (with Smartypants) for double quotes rendering
+ SmartypantsQuotesNBSP // Enable « French guillemets » (with Smartypants)
+ TOC // Generate a table of contents
+)
+
+var (
+ htmlTagRe = regexp.MustCompile("(?i)^" + htmlTag)
+)
+
+const (
+ htmlTag = "(?:" + openTag + "|" + closeTag + "|" + htmlComment + "|" +
+ processingInstruction + "|" + declaration + "|" + cdata + ")"
+ closeTag = "" + tagName + "\\s*[>]"
+ openTag = "<" + tagName + attribute + "*" + "\\s*/?>"
+ attribute = "(?:" + "\\s+" + attributeName + attributeValueSpec + "?)"
+ attributeValue = "(?:" + unquotedValue + "|" + singleQuotedValue + "|" + doubleQuotedValue + ")"
+ attributeValueSpec = "(?:" + "\\s*=" + "\\s*" + attributeValue + ")"
+ attributeName = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
+ cdata = ""
+ declaration = "]*>"
+ doubleQuotedValue = "\"[^\"]*\""
+ htmlComment = "|"
+ processingInstruction = "[<][?].*?[?][>]"
+ singleQuotedValue = "'[^']*'"
+ tagName = "[A-Za-z][A-Za-z0-9-]*"
+ unquotedValue = "[^\"'=<>`\\x00-\\x20]+"
+)
+
+// HTMLRendererParameters is a collection of supplementary parameters tweaking
+// the behavior of various parts of HTML renderer.
+type HTMLRendererParameters struct {
+ // Prepend this text to each relative URL.
+ AbsolutePrefix string
+ // Add this text to each footnote anchor, to ensure uniqueness.
+ FootnoteAnchorPrefix string
+ // Show this text inside the tag for a footnote return link, if the
+ // HTML_FOOTNOTE_RETURN_LINKS flag is enabled. If blank, the string
+ // [return] is used.
+ FootnoteReturnLinkContents string
+ // If set, add this text to the front of each Heading ID, to ensure
+ // uniqueness.
+ HeadingIDPrefix string
+ // If set, add this text to the back of each Heading ID, to ensure uniqueness.
+ HeadingIDSuffix string
+ // Increase heading levels: if the offset is 1, becomes etc.
+ // Negative offset is also valid.
+ // Resulting levels are clipped between 1 and 6.
+ HeadingLevelOffset int
+
+ Title string // Document title (used if CompletePage is set)
+ CSS string // Optional CSS file URL (used if CompletePage is set)
+ Icon string // Optional icon file URL (used if CompletePage is set)
+
+ Flags HTMLFlags // Flags allow customizing this renderer's behavior
+}
+
+// HTMLRenderer is a type that implements the Renderer interface for HTML output.
+//
+// Do not create this directly, instead use the NewHTMLRenderer function.
+type HTMLRenderer struct {
+ HTMLRendererParameters
+
+ closeTag string // how to end singleton tags: either " />" or ">"
+
+ // Track heading IDs to prevent ID collision in a single generation.
+ headingIDs map[string]int
+
+ lastOutputLen int
+ disableTags int
+
+ sr *SPRenderer
+}
+
+const (
+ xhtmlClose = " />"
+ htmlClose = ">"
+)
+
+// NewHTMLRenderer creates and configures an HTMLRenderer object, which
+// satisfies the Renderer interface.
+func NewHTMLRenderer(params HTMLRendererParameters) *HTMLRenderer {
+ // configure the rendering engine
+ closeTag := htmlClose
+ if params.Flags&UseXHTML != 0 {
+ closeTag = xhtmlClose
+ }
+
+ if params.FootnoteReturnLinkContents == "" {
+ // U+FE0E is VARIATION SELECTOR-15.
+ // It suppresses automatic emoji presentation of the preceding
+ // U+21A9 LEFTWARDS ARROW WITH HOOK on iOS and iPadOS.
+ params.FootnoteReturnLinkContents = "↩\ufe0e"
+ }
+
+ return &HTMLRenderer{
+ HTMLRendererParameters: params,
+
+ closeTag: closeTag,
+ headingIDs: make(map[string]int),
+
+ sr: NewSmartypantsRenderer(params.Flags),
+ }
+}
+
+func isHTMLTag(tag []byte, tagname string) bool {
+ found, _ := findHTMLTagPos(tag, tagname)
+ return found
+}
+
+// Look for a character, but ignore it when it's in any kind of quotes, it
+// might be JavaScript
+func skipUntilCharIgnoreQuotes(html []byte, start int, char byte) int {
+ inSingleQuote := false
+ inDoubleQuote := false
+ inGraveQuote := false
+ i := start
+ for i < len(html) {
+ switch {
+ case html[i] == char && !inSingleQuote && !inDoubleQuote && !inGraveQuote:
+ return i
+ case html[i] == '\'':
+ inSingleQuote = !inSingleQuote
+ case html[i] == '"':
+ inDoubleQuote = !inDoubleQuote
+ case html[i] == '`':
+ inGraveQuote = !inGraveQuote
+ }
+ i++
+ }
+ return start
+}
+
+func findHTMLTagPos(tag []byte, tagname string) (bool, int) {
+ i := 0
+ if i < len(tag) && tag[0] != '<' {
+ return false, -1
+ }
+ i++
+ i = skipSpace(tag, i)
+
+ if i < len(tag) && tag[i] == '/' {
+ i++
+ }
+
+ i = skipSpace(tag, i)
+ j := 0
+ for ; i < len(tag); i, j = i+1, j+1 {
+ if j >= len(tagname) {
+ break
+ }
+
+ if strings.ToLower(string(tag[i]))[0] != tagname[j] {
+ return false, -1
+ }
+ }
+
+ if i == len(tag) {
+ return false, -1
+ }
+
+ rightAngle := skipUntilCharIgnoreQuotes(tag, i, '>')
+ if rightAngle >= i {
+ return true, rightAngle
+ }
+
+ return false, -1
+}
+
+func skipSpace(tag []byte, i int) int {
+ for i < len(tag) && isspace(tag[i]) {
+ i++
+ }
+ return i
+}
+
+func isRelativeLink(link []byte) (yes bool) {
+ // a tag begin with '#'
+ if link[0] == '#' {
+ return true
+ }
+
+ // link begin with '/' but not '//', the second maybe a protocol relative link
+ if len(link) >= 2 && link[0] == '/' && link[1] != '/' {
+ return true
+ }
+
+ // only the root '/'
+ if len(link) == 1 && link[0] == '/' {
+ return true
+ }
+
+ // current directory : begin with "./"
+ if bytes.HasPrefix(link, []byte("./")) {
+ return true
+ }
+
+ // parent directory : begin with "../"
+ if bytes.HasPrefix(link, []byte("../")) {
+ return true
+ }
+
+ return false
+}
+
+func (r *HTMLRenderer) ensureUniqueHeadingID(id string) string {
+ for count, found := r.headingIDs[id]; found; count, found = r.headingIDs[id] {
+ tmp := fmt.Sprintf("%s-%d", id, count+1)
+
+ if _, tmpFound := r.headingIDs[tmp]; !tmpFound {
+ r.headingIDs[id] = count + 1
+ id = tmp
+ } else {
+ id = id + "-1"
+ }
+ }
+
+ if _, found := r.headingIDs[id]; !found {
+ r.headingIDs[id] = 0
+ }
+
+ return id
+}
+
+func (r *HTMLRenderer) addAbsPrefix(link []byte) []byte {
+ if r.AbsolutePrefix != "" && isRelativeLink(link) && link[0] != '.' {
+ newDest := r.AbsolutePrefix
+ if link[0] != '/' {
+ newDest += "/"
+ }
+ newDest += string(link)
+ return []byte(newDest)
+ }
+ return link
+}
+
+func appendLinkAttrs(attrs []string, flags HTMLFlags, link []byte) []string {
+ if isRelativeLink(link) {
+ return attrs
+ }
+ val := []string{}
+ if flags&NofollowLinks != 0 {
+ val = append(val, "nofollow")
+ }
+ if flags&NoreferrerLinks != 0 {
+ val = append(val, "noreferrer")
+ }
+ if flags&NoopenerLinks != 0 {
+ val = append(val, "noopener")
+ }
+ if flags&HrefTargetBlank != 0 {
+ attrs = append(attrs, "target=\"_blank\"")
+ }
+ if len(val) == 0 {
+ return attrs
+ }
+ attr := fmt.Sprintf("rel=%q", strings.Join(val, " "))
+ return append(attrs, attr)
+}
+
+func isMailto(link []byte) bool {
+ return bytes.HasPrefix(link, []byte("mailto:"))
+}
+
+func needSkipLink(flags HTMLFlags, dest []byte) bool {
+ if flags&SkipLinks != 0 {
+ return true
+ }
+ return flags&Safelink != 0 && !isSafeLink(dest) && !isMailto(dest)
+}
+
+func isSmartypantable(node *Node) bool {
+ pt := node.Parent.Type
+ return pt != Link && pt != CodeBlock && pt != Code
+}
+
+func appendLanguageAttr(attrs []string, info []byte) []string {
+ if len(info) == 0 {
+ return attrs
+ }
+ endOfLang := bytes.IndexAny(info, "\t ")
+ if endOfLang < 0 {
+ endOfLang = len(info)
+ }
+ return append(attrs, fmt.Sprintf("class=\"language-%s\"", info[:endOfLang]))
+}
+
+func (r *HTMLRenderer) tag(w io.Writer, name []byte, attrs []string) {
+ w.Write(name)
+ if len(attrs) > 0 {
+ w.Write(spaceBytes)
+ w.Write([]byte(strings.Join(attrs, " ")))
+ }
+ w.Write(gtBytes)
+ r.lastOutputLen = 1
+}
+
+func footnoteRef(prefix string, node *Node) []byte {
+ urlFrag := prefix + string(slugify(node.Destination))
+ anchor := fmt.Sprintf(`%d`, urlFrag, node.NoteID)
+ return []byte(fmt.Sprintf(`%s`, urlFrag, anchor))
+}
+
+func footnoteItem(prefix string, slug []byte) []byte {
+ return []byte(fmt.Sprintf(`
`, prefix, slug))
+}
+
+func footnoteReturnLink(prefix, returnLink string, slug []byte) []byte {
+ const format = ` %s`
+ return []byte(fmt.Sprintf(format, prefix, slug, returnLink))
+}
+
+func itemOpenCR(node *Node) bool {
+ if node.Prev == nil {
+ return false
+ }
+ ld := node.Parent.ListData
+ return !ld.Tight && ld.ListFlags&ListTypeDefinition == 0
+}
+
+func skipParagraphTags(node *Node) bool {
+ grandparent := node.Parent.Parent
+ if grandparent == nil || grandparent.Type != List {
+ return false
+ }
+ tightOrTerm := grandparent.Tight || node.Parent.ListFlags&ListTypeTerm != 0
+ return grandparent.Type == List && tightOrTerm
+}
+
+func cellAlignment(align CellAlignFlags) string {
+ switch align {
+ case TableAlignmentLeft:
+ return "left"
+ case TableAlignmentRight:
+ return "right"
+ case TableAlignmentCenter:
+ return "center"
+ default:
+ return ""
+ }
+}
+
+func (r *HTMLRenderer) out(w io.Writer, text []byte) {
+ if r.disableTags > 0 {
+ w.Write(htmlTagRe.ReplaceAll(text, []byte{}))
+ } else {
+ w.Write(text)
+ }
+ r.lastOutputLen = len(text)
+}
+
+func (r *HTMLRenderer) cr(w io.Writer) {
+ if r.lastOutputLen > 0 {
+ r.out(w, nlBytes)
+ }
+}
+
+var (
+ nlBytes = []byte{'\n'}
+ gtBytes = []byte{'>'}
+ spaceBytes = []byte{' '}
+)
+
+var (
+ brTag = []byte("
")
+ brXHTMLTag = []byte("
")
+ emTag = []byte("")
+ emCloseTag = []byte("")
+ strongTag = []byte("")
+ strongCloseTag = []byte("")
+ delTag = []byte("")
+ delCloseTag = []byte("")
+ ttTag = []byte("")
+ ttCloseTag = []byte("")
+ aTag = []byte("")
+ preTag = []byte("")
+ preCloseTag = []byte("
")
+ codeTag = []byte("")
+ codeCloseTag = []byte("
")
+ pTag = []byte("")
+ pCloseTag = []byte("
")
+ blockquoteTag = []byte("")
+ blockquoteCloseTag = []byte("
")
+ hrTag = []byte("
")
+ hrXHTMLTag = []byte("
")
+ ulTag = []byte("")
+ ulCloseTag = []byte("
")
+ olTag = []byte("")
+ olCloseTag = []byte("
")
+ dlTag = []byte("")
+ dlCloseTag = []byte("
")
+ liTag = []byte("")
+ liCloseTag = []byte(" ")
+ ddTag = []byte("")
+ ddCloseTag = []byte(" ")
+ dtTag = []byte("")
+ dtCloseTag = []byte(" ")
+ tableTag = []byte("")
+ tableCloseTag = []byte("
")
+ tdTag = []byte("")
+ thTag = []byte(" ")
+ theadTag = []byte("")
+ theadCloseTag = []byte("")
+ tbodyTag = []byte(" ")
+ tbodyCloseTag = []byte("")
+ trTag = []byte("")
+ trCloseTag = []byte(" ")
+ h1Tag = []byte("")
+ h2Tag = []byte("")
+ h3Tag = []byte("")
+ h4Tag = []byte("")
+ h5Tag = []byte("")
+ h6Tag = []byte("")
+
+ footnotesDivBytes = []byte("\n\n\n")
+ footnotesCloseDivBytes = []byte("\n\n")
+)
+
+func headingTagsFromLevel(level int) ([]byte, []byte) {
+ if level <= 1 {
+ return h1Tag, h1CloseTag
+ }
+ switch level {
+ case 2:
+ return h2Tag, h2CloseTag
+ case 3:
+ return h3Tag, h3CloseTag
+ case 4:
+ return h4Tag, h4CloseTag
+ case 5:
+ return h5Tag, h5CloseTag
+ }
+ return h6Tag, h6CloseTag
+}
+
+func (r *HTMLRenderer) outHRTag(w io.Writer) {
+ if r.Flags&UseXHTML == 0 {
+ r.out(w, hrTag)
+ } else {
+ r.out(w, hrXHTMLTag)
+ }
+}
+
+// RenderNode is a default renderer of a single node of a syntax tree. For
+// block nodes it will be called twice: first time with entering=true, second
+// time with entering=false, so that it could know when it's working on an open
+// tag and when on close. It writes the result to w.
+//
+// The return value is a way to tell the calling walker to adjust its walk
+// pattern: e.g. it can terminate the traversal by returning Terminate. Or it
+// can ask the walker to skip a subtree of this node by returning SkipChildren.
+// The typical behavior is to return GoToNext, which asks for the usual
+// traversal to the next node.
+func (r *HTMLRenderer) RenderNode(w io.Writer, node *Node, entering bool) WalkStatus {
+ attrs := []string{}
+ switch node.Type {
+ case Text:
+ if r.Flags&Smartypants != 0 {
+ var tmp bytes.Buffer
+ escapeHTML(&tmp, node.Literal)
+ r.sr.Process(w, tmp.Bytes())
+ } else {
+ if node.Parent.Type == Link {
+ escLink(w, node.Literal)
+ } else {
+ escapeHTML(w, node.Literal)
+ }
+ }
+ case Softbreak:
+ r.cr(w)
+ // TODO: make it configurable via out(renderer.softbreak)
+ case Hardbreak:
+ if r.Flags&UseXHTML == 0 {
+ r.out(w, brTag)
+ } else {
+ r.out(w, brXHTMLTag)
+ }
+ r.cr(w)
+ case Emph:
+ if entering {
+ r.out(w, emTag)
+ } else {
+ r.out(w, emCloseTag)
+ }
+ case Strong:
+ if entering {
+ r.out(w, strongTag)
+ } else {
+ r.out(w, strongCloseTag)
+ }
+ case Del:
+ if entering {
+ r.out(w, delTag)
+ } else {
+ r.out(w, delCloseTag)
+ }
+ case HTMLSpan:
+ if r.Flags&SkipHTML != 0 {
+ break
+ }
+ r.out(w, node.Literal)
+ case Link:
+ // mark it but don't link it if it is not a safe link: no smartypants
+ dest := node.LinkData.Destination
+ if needSkipLink(r.Flags, dest) {
+ if entering {
+ r.out(w, ttTag)
+ } else {
+ r.out(w, ttCloseTag)
+ }
+ } else {
+ if entering {
+ dest = r.addAbsPrefix(dest)
+ var hrefBuf bytes.Buffer
+ hrefBuf.WriteString("href=\"")
+ escLink(&hrefBuf, dest)
+ hrefBuf.WriteByte('"')
+ attrs = append(attrs, hrefBuf.String())
+ if node.NoteID != 0 {
+ r.out(w, footnoteRef(r.FootnoteAnchorPrefix, node))
+ break
+ }
+ attrs = appendLinkAttrs(attrs, r.Flags, dest)
+ if len(node.LinkData.Title) > 0 {
+ var titleBuff bytes.Buffer
+ titleBuff.WriteString("title=\"")
+ escapeHTML(&titleBuff, node.LinkData.Title)
+ titleBuff.WriteByte('"')
+ attrs = append(attrs, titleBuff.String())
+ }
+ r.tag(w, aTag, attrs)
+ } else {
+ if node.NoteID != 0 {
+ break
+ }
+ r.out(w, aCloseTag)
+ }
+ }
+ case Image:
+ if r.Flags&SkipImages != 0 {
+ return SkipChildren
+ }
+ if entering {
+ dest := node.LinkData.Destination
+ dest = r.addAbsPrefix(dest)
+ if r.disableTags == 0 {
+ //if options.safe && potentiallyUnsafe(dest) {
+ //out(w, ``))
+ }
+ }
+ case Code:
+ r.out(w, codeTag)
+ escapeAllHTML(w, node.Literal)
+ r.out(w, codeCloseTag)
+ case Document:
+ break
+ case Paragraph:
+ if skipParagraphTags(node) {
+ break
+ }
+ if entering {
+ // TODO: untangle this clusterfuck about when the newlines need
+ // to be added and when not.
+ if node.Prev != nil {
+ switch node.Prev.Type {
+ case HTMLBlock, List, Paragraph, Heading, CodeBlock, BlockQuote, HorizontalRule:
+ r.cr(w)
+ }
+ }
+ if node.Parent.Type == BlockQuote && node.Prev == nil {
+ r.cr(w)
+ }
+ r.out(w, pTag)
+ } else {
+ r.out(w, pCloseTag)
+ if !(node.Parent.Type == Item && node.Next == nil) {
+ r.cr(w)
+ }
+ }
+ case BlockQuote:
+ if entering {
+ r.cr(w)
+ r.out(w, blockquoteTag)
+ } else {
+ r.out(w, blockquoteCloseTag)
+ r.cr(w)
+ }
+ case HTMLBlock:
+ if r.Flags&SkipHTML != 0 {
+ break
+ }
+ r.cr(w)
+ r.out(w, node.Literal)
+ r.cr(w)
+ case Heading:
+ headingLevel := r.HTMLRendererParameters.HeadingLevelOffset + node.Level
+ openTag, closeTag := headingTagsFromLevel(headingLevel)
+ if entering {
+ if node.IsTitleblock {
+ attrs = append(attrs, `class="title"`)
+ }
+ if node.HeadingID != "" {
+ id := r.ensureUniqueHeadingID(node.HeadingID)
+ if r.HeadingIDPrefix != "" {
+ id = r.HeadingIDPrefix + id
+ }
+ if r.HeadingIDSuffix != "" {
+ id = id + r.HeadingIDSuffix
+ }
+ attrs = append(attrs, fmt.Sprintf(`id="%s"`, id))
+ }
+ r.cr(w)
+ r.tag(w, openTag, attrs)
+ } else {
+ r.out(w, closeTag)
+ if !(node.Parent.Type == Item && node.Next == nil) {
+ r.cr(w)
+ }
+ }
+ case HorizontalRule:
+ r.cr(w)
+ r.outHRTag(w)
+ r.cr(w)
+ case List:
+ openTag := ulTag
+ closeTag := ulCloseTag
+ if node.ListFlags&ListTypeOrdered != 0 {
+ openTag = olTag
+ closeTag = olCloseTag
+ }
+ if node.ListFlags&ListTypeDefinition != 0 {
+ openTag = dlTag
+ closeTag = dlCloseTag
+ }
+ if entering {
+ if node.IsFootnotesList {
+ r.out(w, footnotesDivBytes)
+ r.outHRTag(w)
+ r.cr(w)
+ }
+ r.cr(w)
+ if node.Parent.Type == Item && node.Parent.Parent.Tight {
+ r.cr(w)
+ }
+ r.tag(w, openTag[:len(openTag)-1], attrs)
+ r.cr(w)
+ } else {
+ r.out(w, closeTag)
+ //cr(w)
+ //if node.parent.Type != Item {
+ // cr(w)
+ //}
+ if node.Parent.Type == Item && node.Next != nil {
+ r.cr(w)
+ }
+ if node.Parent.Type == Document || node.Parent.Type == BlockQuote {
+ r.cr(w)
+ }
+ if node.IsFootnotesList {
+ r.out(w, footnotesCloseDivBytes)
+ }
+ }
+ case Item:
+ openTag := liTag
+ closeTag := liCloseTag
+ if node.ListFlags&ListTypeDefinition != 0 {
+ openTag = ddTag
+ closeTag = ddCloseTag
+ }
+ if node.ListFlags&ListTypeTerm != 0 {
+ openTag = dtTag
+ closeTag = dtCloseTag
+ }
+ if entering {
+ if itemOpenCR(node) {
+ r.cr(w)
+ }
+ if node.ListData.RefLink != nil {
+ slug := slugify(node.ListData.RefLink)
+ r.out(w, footnoteItem(r.FootnoteAnchorPrefix, slug))
+ break
+ }
+ r.out(w, openTag)
+ } else {
+ if node.ListData.RefLink != nil {
+ slug := slugify(node.ListData.RefLink)
+ if r.Flags&FootnoteReturnLinks != 0 {
+ r.out(w, footnoteReturnLink(r.FootnoteAnchorPrefix, r.FootnoteReturnLinkContents, slug))
+ }
+ }
+ r.out(w, closeTag)
+ r.cr(w)
+ }
+ case CodeBlock:
+ attrs = appendLanguageAttr(attrs, node.Info)
+ r.cr(w)
+ r.out(w, preTag)
+ r.tag(w, codeTag[:len(codeTag)-1], attrs)
+ escapeAllHTML(w, node.Literal)
+ r.out(w, codeCloseTag)
+ r.out(w, preCloseTag)
+ if node.Parent.Type != Item {
+ r.cr(w)
+ }
+ case Table:
+ if entering {
+ r.cr(w)
+ r.out(w, tableTag)
+ } else {
+ r.out(w, tableCloseTag)
+ r.cr(w)
+ }
+ case TableCell:
+ openTag := tdTag
+ closeTag := tdCloseTag
+ if node.IsHeader {
+ openTag = thTag
+ closeTag = thCloseTag
+ }
+ if entering {
+ align := cellAlignment(node.Align)
+ if align != "" {
+ attrs = append(attrs, fmt.Sprintf(`align="%s"`, align))
+ }
+ if node.Prev == nil {
+ r.cr(w)
+ }
+ r.tag(w, openTag, attrs)
+ } else {
+ r.out(w, closeTag)
+ r.cr(w)
+ }
+ case TableHead:
+ if entering {
+ r.cr(w)
+ r.out(w, theadTag)
+ } else {
+ r.out(w, theadCloseTag)
+ r.cr(w)
+ }
+ case TableBody:
+ if entering {
+ r.cr(w)
+ r.out(w, tbodyTag)
+ // XXX: this is to adhere to a rather silly test. Should fix test.
+ if node.FirstChild == nil {
+ r.cr(w)
+ }
+ } else {
+ r.out(w, tbodyCloseTag)
+ r.cr(w)
+ }
+ case TableRow:
+ if entering {
+ r.cr(w)
+ r.out(w, trTag)
+ } else {
+ r.out(w, trCloseTag)
+ r.cr(w)
+ }
+ default:
+ panic("Unknown node type " + node.Type.String())
+ }
+ return GoToNext
+}
+
+// RenderHeader writes HTML document preamble and TOC if requested.
+func (r *HTMLRenderer) RenderHeader(w io.Writer, ast *Node) {
+ r.writeDocumentHeader(w)
+ if r.Flags&TOC != 0 {
+ r.writeTOC(w, ast)
+ }
+}
+
+// RenderFooter writes HTML document footer.
+func (r *HTMLRenderer) RenderFooter(w io.Writer, ast *Node) {
+ if r.Flags&CompletePage == 0 {
+ return
+ }
+ io.WriteString(w, "\n