From 04567c765e92ad60c685c1b2fe7e77c46e065645 Mon Sep 17 00:00:00 2001 From: Wim Date: Sun, 6 Jan 2019 22:25:19 +0100 Subject: [PATCH] Add support for markdown to HTML conversion (matrix). Closes #663 (#670) This uses our own gomatrix lib with the SendHTML function which adds HTML to formatted_body in matrix. golang-commonmark is used to convert markdown into valid HTML. --- bridge/helper/helper.go | 6 + bridge/matrix/matrix.go | 5 +- go.mod | 6 + go.sum | 16 +- .../golang-commonmark/html/.gitlab-ci.yml | 16 + .../gitlab.com/golang-commonmark/html/LICENSE | 10 + .../golang-commonmark/html/README.md | 8 + .../gitlab.com/golang-commonmark/html/html.go | 211 + .../golang-commonmark/html/html5_entities.go | 2133 ++ .../golang-commonmark/linkify/.gitlab-ci.yml | 19 + .../golang-commonmark/linkify/LICENSE | 10 + .../golang-commonmark/linkify/README.md | 12 + .../golang-commonmark/linkify/charset.go | 51 + .../golang-commonmark/linkify/email.go | 93 + .../golang-commonmark/linkify/generated.go | 18175 ++++++++++++++++ .../golang-commonmark/linkify/linkify.go | 462 + .../golang-commonmark/linkify/url.go | 404 + .../golang-commonmark/linkify/util.go | 20 + .../golang-commonmark/markdown/.gitlab-ci.yml | 25 + .../golang-commonmark/markdown/AUTHORS | 1 + .../golang-commonmark/markdown/LICENSE | 10 + .../golang-commonmark/markdown/README.md | 64 + .../golang-commonmark/markdown/align.go | 26 + .../golang-commonmark/markdown/autolink.go | 70 + .../golang-commonmark/markdown/backticks.go | 60 + .../markdown/balance_pairs.go | 43 + .../golang-commonmark/markdown/blockquote.go | 233 + .../golang-commonmark/markdown/code.go | 37 + .../golang-commonmark/markdown/emphasis.go | 89 + .../golang-commonmark/markdown/entity.go | 35 + .../golang-commonmark/markdown/escape.go | 61 + .../golang-commonmark/markdown/fence.go | 102 + .../golang-commonmark/markdown/fuzz.go | 9 + .../golang-commonmark/markdown/heading.go | 59 + .../golang-commonmark/markdown/helpers.go | 164 + .../golang-commonmark/markdown/hr.go | 54 + .../golang-commonmark/markdown/html_block.go | 222 + .../golang-commonmark/markdown/html_inline.go | 57 + .../golang-commonmark/markdown/image.go | 131 + .../golang-commonmark/markdown/inline.go | 13 + .../golang-commonmark/markdown/lheading.go | 80 + .../golang-commonmark/markdown/link.go | 132 + .../golang-commonmark/markdown/linkify.go | 131 + .../golang-commonmark/markdown/list.go | 285 + .../golang-commonmark/markdown/markdown.go | 112 + .../golang-commonmark/markdown/newline.go | 46 + .../golang-commonmark/markdown/options.go | 77 + .../golang-commonmark/markdown/paragraph.go | 51 + .../markdown/parser_block.go | 159 + .../markdown/parser_inline.go | 106 + .../golang-commonmark/markdown/plugins.go | 158 + .../golang-commonmark/markdown/reference.go | 173 + .../golang-commonmark/markdown/render.go | 333 + .../markdown/replacements.go | 229 + .../golang-commonmark/markdown/smartquotes.go | 256 + .../golang-commonmark/markdown/state_block.go | 141 + .../golang-commonmark/markdown/state_core.go | 13 + .../markdown/state_inline.go | 116 + .../markdown/strikethrough.go | 101 + .../golang-commonmark/markdown/table.go | 229 + .../golang-commonmark/markdown/table_fsm.go | 108 + .../golang-commonmark/markdown/text.go | 52 + .../markdown/text_collapse.go | 42 + .../golang-commonmark/markdown/token.go | 753 + .../golang-commonmark/markdown/urlschema.go | 185 + .../golang-commonmark/markdown/util.go | 264 + .../golang-commonmark/markdown/writer.go | 69 + .../golang-commonmark/mdurl/.gitlab-ci.yml | 16 + .../golang-commonmark/mdurl/LICENSE | 10 + .../golang-commonmark/mdurl/README.md | 8 + .../golang-commonmark/mdurl/decode.go | 80 + .../golang-commonmark/mdurl/encode.go | 53 + .../golang-commonmark/mdurl/parse.go | 146 + .../gitlab.com/golang-commonmark/mdurl/url.go | 101 + .../golang-commonmark/mdurl/util.go | 36 + .../golang-commonmark/puny/.gitlab-ci.yml | 16 + .../gitlab.com/golang-commonmark/puny/LICENSE | 10 + .../golang-commonmark/puny/README.md | 8 + .../gitlab.com/golang-commonmark/puny/puny.go | 287 + .../x/text/unicode/rangetable/gen.go | 115 + .../x/text/unicode/rangetable/merge.go | 260 + .../x/text/unicode/rangetable/rangetable.go | 70 + .../x/text/unicode/rangetable/tables10.0.0.go | 6378 ++++++ .../x/text/unicode/rangetable/tables9.0.0.go | 5737 +++++ vendor/modules.txt | 11 + 85 files changed, 40959 insertions(+), 6 deletions(-) create mode 100644 vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml create mode 100644 vendor/gitlab.com/golang-commonmark/html/LICENSE create mode 100644 vendor/gitlab.com/golang-commonmark/html/README.md create mode 100644 vendor/gitlab.com/golang-commonmark/html/html.go create mode 100644 vendor/gitlab.com/golang-commonmark/html/html5_entities.go create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/LICENSE create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/README.md create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/charset.go create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/email.go create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/generated.go create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/linkify.go create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/url.go create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/util.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/AUTHORS create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/LICENSE create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/README.md create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/align.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/autolink.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/backticks.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/blockquote.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/code.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/emphasis.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/entity.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/escape.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/fence.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/fuzz.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/heading.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/helpers.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/hr.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/html_block.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/html_inline.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/image.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/inline.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/lheading.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/link.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/linkify.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/list.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/markdown.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/newline.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/options.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/paragraph.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/parser_block.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/plugins.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/reference.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/render.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/replacements.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/smartquotes.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/state_block.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/state_core.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/state_inline.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/strikethrough.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/table.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/table_fsm.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/text.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/text_collapse.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/token.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/urlschema.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/util.go create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/writer.go create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/.gitlab-ci.yml create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/LICENSE create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/README.md create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/decode.go create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/encode.go create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/parse.go create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/url.go create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/util.go create mode 100644 vendor/gitlab.com/golang-commonmark/puny/.gitlab-ci.yml create mode 100644 vendor/gitlab.com/golang-commonmark/puny/LICENSE create mode 100644 vendor/gitlab.com/golang-commonmark/puny/README.md create mode 100644 vendor/gitlab.com/golang-commonmark/puny/puny.go create mode 100644 vendor/golang.org/x/text/unicode/rangetable/gen.go create mode 100644 vendor/golang.org/x/text/unicode/rangetable/merge.go create mode 100644 vendor/golang.org/x/text/unicode/rangetable/rangetable.go create mode 100644 vendor/golang.org/x/text/unicode/rangetable/tables10.0.0.go create mode 100644 vendor/golang.org/x/text/unicode/rangetable/tables9.0.0.go diff --git a/bridge/helper/helper.go b/bridge/helper/helper.go index d9acb3d5..12a587f0 100644 --- a/bridge/helper/helper.go +++ b/bridge/helper/helper.go @@ -12,6 +12,7 @@ import ( "github.com/42wim/matterbridge/bridge/config" "github.com/sirupsen/logrus" + "gitlab.com/golang-commonmark/markdown" ) func DownloadFile(url string) (*[]byte, error) { @@ -151,3 +152,8 @@ func ClipMessage(text string, length int) string { } return text } + +func ParseMarkdown(input string) string { + md := markdown.New(markdown.XHTMLOutput(true), markdown.Breaks(true)) + return (md.RenderToString([]byte(input))) +} diff --git a/bridge/matrix/matrix.go b/bridge/matrix/matrix.go index 6ac41d53..12f50e8d 100644 --- a/bridge/matrix/matrix.go +++ b/bridge/matrix/matrix.go @@ -3,6 +3,7 @@ package bmatrix import ( "bytes" "fmt" + "html" "mime" "regexp" "strings" @@ -112,8 +113,8 @@ func (b *Bmatrix) Send(msg config.Message) (string, error) { // Edit message if we have an ID // matrix has no editing support - // Post normal message - resp, err := b.mc.SendText(channel, msg.Username+msg.Text) + // Post normal message with HTML support (eg riot.im) + resp, err := b.mc.SendHTML(channel, msg.Text, html.EscapeString(msg.Username)+helper.ParseMarkdown(msg.Text)) if err != nil { return "", err } diff --git a/go.mod b/go.mod index 744e52e8..85006d47 100644 --- a/go.mod +++ b/go.mod @@ -61,6 +61,12 @@ require ( github.com/valyala/fasttemplate v0.0.0-20170224212429-dcecefd839c4 // indirect github.com/x-cray/logrus-prefixed-formatter v0.5.2 // indirect github.com/zfjagann/golang-ring v0.0.0-20141111230621-17637388c9f6 + gitlab.com/golang-commonmark/html v0.0.0-20180917080848-cfaf75183c4a // indirect + gitlab.com/golang-commonmark/linkify v0.0.0-20180917065525-c22b7bdb1179 // indirect + gitlab.com/golang-commonmark/markdown v0.0.0-20181102083822-772775880e1f + gitlab.com/golang-commonmark/mdurl v0.0.0-20180912090424-e5bce34c34f2 // indirect + gitlab.com/golang-commonmark/puny v0.0.0-20180912090636-2cd490539afe // indirect + gitlab.com/opennota/wd v0.0.0-20180912061657-c5d65f63c638 // indirect go.uber.org/atomic v1.3.2 // indirect go.uber.org/multierr v1.1.0 // indirect go.uber.org/zap v1.9.1 // indirect diff --git a/go.sum b/go.sum index 317240e2..7cc22f1b 100644 --- a/go.sum +++ b/go.sum @@ -16,8 +16,6 @@ github.com/dgrijalva/jwt-go v0.0.0-20170508165458-6c8dedd55f8a h1:MuHMeSsXbNEeUy github.com/dgrijalva/jwt-go v0.0.0-20170508165458-6c8dedd55f8a/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible h1:2cauKuaELYAEARXRkq2LrJ0yDDv1rW7+wrTEdVL3uaU= -github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible/go.mod h1:qf9acutJ8cwBUhm1bqgz6Bei9/C/c93FPDljKWwsOgM= github.com/go-telegram-bot-api/telegram-bot-api v4.6.5-0.20181225215658-ec221ba9ea45+incompatible h1:i64CCJcSqkRIkm5OSdZQjZq84/gJsk2zNwHWIRYWlKE= github.com/go-telegram-bot-api/telegram-bot-api v4.6.5-0.20181225215658-ec221ba9ea45+incompatible/go.mod h1:qf9acutJ8cwBUhm1bqgz6Bei9/C/c93FPDljKWwsOgM= github.com/golang/protobuf v0.0.0-20170613224224-e325f446bebc h1:wdhDSKrkYy24mcfzuA3oYm58h0QkyXjwERCkzJDP5kA= @@ -55,8 +53,6 @@ github.com/labstack/echo v3.3.5+incompatible h1:9PfxPUmasKzeJor9uQTaXLT6WUG/r+vS github.com/labstack/echo v3.3.5+incompatible/go.mod h1:0INS7j/VjnFxD4E2wkz67b8cVwCLbBmJyDaka6Cmk1s= github.com/labstack/gommon v0.2.1 h1:C+I4NYknueQncqKYZQ34kHsLZJVeB5KwPUhnO0nmbpU= github.com/labstack/gommon v0.2.1/go.mod h1:/tj9csK2iPSBvn+3NLM9e52usepMtrd5ilFYA+wQNJ4= -github.com/lrstanley/girc v0.0.0-20181114171214-3aee8c249519 h1:o7duXxs4nxplgWrFRJoyGrPAS+U9Sk5eQyc2mflk6/Q= -github.com/lrstanley/girc v0.0.0-20181114171214-3aee8c249519/go.mod h1:7cRs1SIBfKQ7e3Tam6GKTILSNHzR862JD0JpINaZoJk= github.com/lrstanley/girc v0.0.0-20190102153329-c1e59a02f488 h1:dDEQN5oaa0WOzEiPDSbOugW/e2I/SWY98HYRdcwmGfY= github.com/lrstanley/girc v0.0.0-20190102153329-c1e59a02f488/go.mod h1:7cRs1SIBfKQ7e3Tam6GKTILSNHzR862JD0JpINaZoJk= github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5 h1:AsEBgzv3DhuYHI/GiQh2HxvTP71HCCE9E/tzGUzGdtU= @@ -153,6 +149,18 @@ github.com/x-cray/logrus-prefixed-formatter v0.5.2 h1:00txxvfBM9muc0jiLIEAkAcIMJ github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE= github.com/zfjagann/golang-ring v0.0.0-20141111230621-17637388c9f6 h1:/WULP+6asFz569UbOwg87f3iDT7T+GF5/vjLmL51Pdk= github.com/zfjagann/golang-ring v0.0.0-20141111230621-17637388c9f6/go.mod h1:0MsIttMJIF/8Y7x0XjonJP7K99t3sR6bjj4m5S4JmqU= +gitlab.com/golang-commonmark/html v0.0.0-20180917080848-cfaf75183c4a h1:Ax7kdHNICZiIeFpmevmaEWb0Ae3BUj3zCTKhZHZ+zd0= +gitlab.com/golang-commonmark/html v0.0.0-20180917080848-cfaf75183c4a/go.mod h1:JT4uoTz0tfPoyVH88GZoWDNm5NHJI2VbUW+eyPClueI= +gitlab.com/golang-commonmark/linkify v0.0.0-20180917065525-c22b7bdb1179 h1:rbON2KwBnWuFMlSHM8LELLlwroDRZw6xv0e6il6e5dk= +gitlab.com/golang-commonmark/linkify v0.0.0-20180917065525-c22b7bdb1179/go.mod h1:Gn+LZmCrhPECMD3SOKlE+BOHwhOYD9j7WT9NUtkCrC8= +gitlab.com/golang-commonmark/markdown v0.0.0-20181102083822-772775880e1f h1:jwXy/CsM4xS2aoiF2fHAlukmInWhd2TlWB+HDCyvzKc= +gitlab.com/golang-commonmark/markdown v0.0.0-20181102083822-772775880e1f/go.mod h1:SIHlEr9462fpIfTrVWf3GqQDxnA65Vm3BMMsUtuA6W0= +gitlab.com/golang-commonmark/mdurl v0.0.0-20180912090424-e5bce34c34f2 h1:wD/sPUgx2QJFPTyXZpJnLaROolfeKuruh06U4pRV0WY= +gitlab.com/golang-commonmark/mdurl v0.0.0-20180912090424-e5bce34c34f2/go.mod h1:wQk4rLkWrdOPjUAtqJRJ10hIlseLSVYWP95PLrjDF9s= +gitlab.com/golang-commonmark/puny v0.0.0-20180912090636-2cd490539afe h1:5kUPFAF52umOUPH12MuNUmyVTseJRNBftDl/KfsvX3I= +gitlab.com/golang-commonmark/puny v0.0.0-20180912090636-2cd490539afe/go.mod h1:P9LSM1KVzrIstFgUaveuwiAm8PK5VTB3yJEU8kqlbrU= +gitlab.com/opennota/wd v0.0.0-20180912061657-c5d65f63c638 h1:uPZaMiz6Sz0PZs3IZJWpU5qHKGNy///1pacZC9txiUI= +gitlab.com/opennota/wd v0.0.0-20180912061657-c5d65f63c638/go.mod h1:EGRJaqe2eO9XGmFtQCvV3Lm9NLico3UhFwUpCG/+mVU= go.uber.org/atomic v1.3.2 h1:2Oa65PReHzfn29GpvgsYwloV9AVFHPDk8tYxt2c2tr4= go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI= diff --git a/vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml new file mode 100644 index 00000000..aaf2cbdd --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml @@ -0,0 +1,16 @@ +image: golang:1.11 + +stages: + - build + - test + +build: + stage: build + script: + - go build ./... + +test: + stage: test + script: + - test -z "$(gofmt -l . | tee /dev/stderr)" + - go test ./... diff --git a/vendor/gitlab.com/golang-commonmark/html/LICENSE b/vendor/gitlab.com/golang-commonmark/html/LICENSE new file mode 100644 index 00000000..9cdcd201 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/html/LICENSE @@ -0,0 +1,10 @@ +Copyright (c) 2015, The 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: + +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/gitlab.com/golang-commonmark/html/README.md b/vendor/gitlab.com/golang-commonmark/html/README.md new file mode 100644 index 00000000..1fbc8ea8 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/html/README.md @@ -0,0 +1,8 @@ +html [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/html?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/html) [![Pipeline status](https://gitlab.com/golang-commonmark/html/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/html/commits/master) +==== + +Package html provides functions for escaping/unescaping HTML text and for parsing HTML entities. + +## Install + + go get -u gitlab.com/golang-commonmark/html diff --git a/vendor/gitlab.com/golang-commonmark/html/html.go b/vendor/gitlab.com/golang-commonmark/html/html.go new file mode 100644 index 00000000..25bf7d82 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/html/html.go @@ -0,0 +1,211 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package html provides functions for escaping/unescaping HTML text and for parsing HTML entities. +package html + +import ( + "io" + "strconv" + "strings" + "unicode/utf8" +) + +const BadEntity = string(utf8.RuneError) + +var htmlEscapeReplacer = strings.NewReplacer( + "&", "&", + "<", "<", + ">", ">", + `"`, """, +) + +func EscapeString(s string) string { + return htmlEscapeReplacer.Replace(s) +} + +func WriteEscapedString(w io.Writer, s string) error { + _, err := htmlEscapeReplacer.WriteString(w, s) + return err +} + +func isValidEntityCode(c int64) bool { + switch { + case !utf8.ValidRune(rune(c)): + return false + + // never used + case c >= 0xfdd0 && c <= 0xfdef: + return false + case c&0xffff == 0xffff || c&0xffff == 0xfffe: + return false + // control codes + case c >= 0x00 && c <= 0x08: + return false + case c == 0x0b: + return false + case c >= 0x0e && c <= 0x1f: + return false + case c >= 0x7f && c <= 0x9f: + return false + } + + return true +} + +func letter(b byte) bool { return b >= 'a' && b <= 'z' || b >= 'A' && b <= 'Z' } + +func digit(b byte) bool { return b >= '0' && b <= '9' } + +func alphanum(b byte) bool { return letter(b) || digit(b) } + +func hexDigit(b byte) bool { + return digit(b) || b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F' +} + +func ParseEntity(s string) (string, int) { + st := 0 + var n int + + for i := 1; i < len(s); i++ { + b := s[i] + + switch st { + case 0: // initial state + switch { + case b == '#': + st = 1 + case letter(b): + n = 1 + st = 2 + default: + return "", 0 + } + + case 1: // &# + switch { + case b == 'x' || b == 'X': + st = 3 + case digit(b): + n = 1 + st = 4 + default: + return "", 0 + } + + case 2: // &q + switch { + case alphanum(b): + n++ + if n > 31 { + return "", 0 + } + case b == ';': + if e, ok := entities[s[i-n:i]]; ok { + return e, i + 1 + } + return "", 0 + default: + return "", 0 + } + + case 3: // &#x + switch { + case hexDigit(b): + n = 1 + st = 5 + default: + return "", 0 + } + + case 4: // � + switch { + case digit(b): + n++ + if n > 8 { + return "", 0 + } + case b == ';': + c, _ := strconv.ParseInt(s[i-n:i], 10, 32) + if !isValidEntityCode(c) { + return BadEntity, i + 1 + } + return string(rune(c)), i + 1 + default: + return "", 0 + } + + case 5: // � + switch { + case hexDigit(b): + n++ + if n > 8 { + return "", 0 + } + case b == ';': + c, err := strconv.ParseInt(s[i-n:i], 16, 32) + if err != nil { + return BadEntity, i + 1 + } + if !isValidEntityCode(c) { + return BadEntity, i + 1 + } + return string(rune(c)), i + 1 + default: + return "", 0 + } + } + } + + return "", 0 +} + +func UnescapeString(s string) string { + i := strings.IndexByte(s, '&') + if i < 0 { + return s + } + + anyChanges := false + var entityStr string + var entityLen int + for i < len(s) { + if s[i] == '&' { + entityStr, entityLen = ParseEntity(s[i:]) + if entityLen > 0 { + anyChanges = true + break + } + } + i++ + } + + if !anyChanges { + return s + } + + buf := make([]byte, len(s)-entityLen+len(entityStr)) + copy(buf[:i], s) + n := copy(buf[i:], entityStr) + j := i + n + i += entityLen + for i < len(s) { + b := s[i] + if b == '&' { + entityStr, entityLen = ParseEntity(s[i:]) + if entityLen > 0 { + n = copy(buf[j:], entityStr) + j += n + i += entityLen + continue + } + } + + buf[j] = b + j++ + i++ + } + + return string(buf[:j]) +} diff --git a/vendor/gitlab.com/golang-commonmark/html/html5_entities.go b/vendor/gitlab.com/golang-commonmark/html/html5_entities.go new file mode 100644 index 00000000..200512ab --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/html/html5_entities.go @@ -0,0 +1,2133 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package html + +var entities = map[string]string{ + "AElig": "\u00C6", + "AMP": "\u0026", + "Aacute": "\u00C1", + "Abreve": "\u0102", + "Acirc": "\u00C2", + "Acy": "\u0410", + "Afr": "\U0001D504", + "Agrave": "\u00C0", + "Alpha": "\u0391", + "Amacr": "\u0100", + "And": "\u2A53", + "Aogon": "\u0104", + "Aopf": "\U0001D538", + "ApplyFunction": "\u2061", + "Aring": "\u00C5", + "Ascr": "\U0001D49C", + "Assign": "\u2254", + "Atilde": "\u00C3", + "Auml": "\u00C4", + "Backslash": "\u2216", + "Barv": "\u2AE7", + "Barwed": "\u2306", + "Bcy": "\u0411", + "Because": "\u2235", + "Bernoullis": "\u212C", + "Beta": "\u0392", + "Bfr": "\U0001D505", + "Bopf": "\U0001D539", + "Breve": "\u02D8", + "Bscr": "\u212C", + "Bumpeq": "\u224E", + "CHcy": "\u0427", + "COPY": "\u00A9", + "Cacute": "\u0106", + "Cap": "\u22D2", + "CapitalDifferentialD": "\u2145", + "Cayleys": "\u212D", + "Ccaron": "\u010C", + "Ccedil": "\u00C7", + "Ccirc": "\u0108", + "Cconint": "\u2230", + "Cdot": "\u010A", + "Cedilla": "\u00B8", + "CenterDot": "\u00B7", + "Cfr": "\u212D", + "Chi": "\u03A7", + "CircleDot": "\u2299", + "CircleMinus": "\u2296", + "CirclePlus": "\u2295", + "CircleTimes": "\u2297", + "ClockwiseContourIntegral": "\u2232", + "CloseCurlyDoubleQuote": "\u201D", + "CloseCurlyQuote": "\u2019", + "Colon": "\u2237", + "Colone": "\u2A74", + "Congruent": "\u2261", + "Conint": "\u222F", + "ContourIntegral": "\u222E", + "Copf": "\u2102", + "Coproduct": "\u2210", + "CounterClockwiseContourIntegral": "\u2233", + "Cross": "\u2A2F", + "Cscr": "\U0001D49E", + "Cup": "\u22D3", + "CupCap": "\u224D", + "DD": "\u2145", + "DDotrahd": "\u2911", + "DJcy": "\u0402", + "DScy": "\u0405", + "DZcy": "\u040F", + "Dagger": "\u2021", + "Darr": "\u21A1", + "Dashv": "\u2AE4", + "Dcaron": "\u010E", + "Dcy": "\u0414", + "Del": "\u2207", + "Delta": "\u0394", + "Dfr": "\U0001D507", + "DiacriticalAcute": "\u00B4", + "DiacriticalDot": "\u02D9", + "DiacriticalDoubleAcute": "\u02DD", + "DiacriticalGrave": "\u0060", + "DiacriticalTilde": "\u02DC", + "Diamond": "\u22C4", + "DifferentialD": "\u2146", + "Dopf": "\U0001D53B", + "Dot": "\u00A8", + "DotDot": "\u20DC", + "DotEqual": "\u2250", + "DoubleContourIntegral": "\u222F", + "DoubleDot": "\u00A8", + "DoubleDownArrow": "\u21D3", + "DoubleLeftArrow": "\u21D0", + "DoubleLeftRightArrow": "\u21D4", + "DoubleLeftTee": "\u2AE4", + "DoubleLongLeftArrow": "\u27F8", + "DoubleLongLeftRightArrow": "\u27FA", + "DoubleLongRightArrow": "\u27F9", + "DoubleRightArrow": "\u21D2", + "DoubleRightTee": "\u22A8", + "DoubleUpArrow": "\u21D1", + "DoubleUpDownArrow": "\u21D5", + "DoubleVerticalBar": "\u2225", + "DownArrow": "\u2193", + "DownArrowBar": "\u2913", + "DownArrowUpArrow": "\u21F5", + "DownBreve": "\u0311", + "DownLeftRightVector": "\u2950", + "DownLeftTeeVector": "\u295E", + "DownLeftVector": "\u21BD", + "DownLeftVectorBar": "\u2956", + "DownRightTeeVector": "\u295F", + "DownRightVector": "\u21C1", + "DownRightVectorBar": "\u2957", + "DownTee": "\u22A4", + "DownTeeArrow": "\u21A7", + "Downarrow": "\u21D3", + "Dscr": "\U0001D49F", + "Dstrok": "\u0110", + "ENG": "\u014A", + "ETH": "\u00D0", + "Eacute": "\u00C9", + "Ecaron": "\u011A", + "Ecirc": "\u00CA", + "Ecy": "\u042D", + "Edot": "\u0116", + "Efr": "\U0001D508", + "Egrave": "\u00C8", + "Element": "\u2208", + "Emacr": "\u0112", + "EmptySmallSquare": "\u25FB", + "EmptyVerySmallSquare": "\u25AB", + "Eogon": "\u0118", + "Eopf": "\U0001D53C", + "Epsilon": "\u0395", + "Equal": "\u2A75", + "EqualTilde": "\u2242", + "Equilibrium": "\u21CC", + "Escr": "\u2130", + "Esim": "\u2A73", + "Eta": "\u0397", + "Euml": "\u00CB", + "Exists": "\u2203", + "ExponentialE": "\u2147", + "Fcy": "\u0424", + "Ffr": "\U0001D509", + "FilledSmallSquare": "\u25FC", + "FilledVerySmallSquare": "\u25AA", + "Fopf": "\U0001D53D", + "ForAll": "\u2200", + "Fouriertrf": "\u2131", + "Fscr": "\u2131", + "GJcy": "\u0403", + "GT": "\u003E", + "Gamma": "\u0393", + "Gammad": "\u03DC", + "Gbreve": "\u011E", + "Gcedil": "\u0122", + "Gcirc": "\u011C", + "Gcy": "\u0413", + "Gdot": "\u0120", + "Gfr": "\U0001D50A", + "Gg": "\u22D9", + "Gopf": "\U0001D53E", + "GreaterEqual": "\u2265", + "GreaterEqualLess": "\u22DB", + "GreaterFullEqual": "\u2267", + "GreaterGreater": "\u2AA2", + "GreaterLess": "\u2277", + "GreaterSlantEqual": "\u2A7E", + "GreaterTilde": "\u2273", + "Gscr": "\U0001D4A2", + "Gt": "\u226B", + "HARDcy": "\u042A", + "Hacek": "\u02C7", + "Hat": "\u005E", + "Hcirc": "\u0124", + "Hfr": "\u210C", + "HilbertSpace": "\u210B", + "Hopf": "\u210D", + "HorizontalLine": "\u2500", + "Hscr": "\u210B", + "Hstrok": "\u0126", + "HumpDownHump": "\u224E", + "HumpEqual": "\u224F", + "IEcy": "\u0415", + "IJlig": "\u0132", + "IOcy": "\u0401", + "Iacute": "\u00CD", + "Icirc": "\u00CE", + "Icy": "\u0418", + "Idot": "\u0130", + "Ifr": "\u2111", + "Igrave": "\u00CC", + "Im": "\u2111", + "Imacr": "\u012A", + "ImaginaryI": "\u2148", + "Implies": "\u21D2", + "Int": "\u222C", + "Integral": "\u222B", + "Intersection": "\u22C2", + "InvisibleComma": "\u2063", + "InvisibleTimes": "\u2062", + "Iogon": "\u012E", + "Iopf": "\U0001D540", + "Iota": "\u0399", + "Iscr": "\u2110", + "Itilde": "\u0128", + "Iukcy": "\u0406", + "Iuml": "\u00CF", + "Jcirc": "\u0134", + "Jcy": "\u0419", + "Jfr": "\U0001D50D", + "Jopf": "\U0001D541", + "Jscr": "\U0001D4A5", + "Jsercy": "\u0408", + "Jukcy": "\u0404", + "KHcy": "\u0425", + "KJcy": "\u040C", + "Kappa": "\u039A", + "Kcedil": "\u0136", + "Kcy": "\u041A", + "Kfr": "\U0001D50E", + "Kopf": "\U0001D542", + "Kscr": "\U0001D4A6", + "LJcy": "\u0409", + "LT": "\u003C", + "Lacute": "\u0139", + "Lambda": "\u039B", + "Lang": "\u27EA", + "Laplacetrf": "\u2112", + "Larr": "\u219E", + "Lcaron": "\u013D", + "Lcedil": "\u013B", + "Lcy": "\u041B", + "LeftAngleBracket": "\u27E8", + "LeftArrow": "\u2190", + "LeftArrowBar": "\u21E4", + "LeftArrowRightArrow": "\u21C6", + "LeftCeiling": "\u2308", + "LeftDoubleBracket": "\u27E6", + "LeftDownTeeVector": "\u2961", + "LeftDownVector": "\u21C3", + "LeftDownVectorBar": "\u2959", + "LeftFloor": "\u230A", + "LeftRightArrow": "\u2194", + "LeftRightVector": "\u294E", + "LeftTee": "\u22A3", + "LeftTeeArrow": "\u21A4", + "LeftTeeVector": "\u295A", + "LeftTriangle": "\u22B2", + "LeftTriangleBar": "\u29CF", + "LeftTriangleEqual": "\u22B4", + "LeftUpDownVector": "\u2951", + "LeftUpTeeVector": "\u2960", + "LeftUpVector": "\u21BF", + "LeftUpVectorBar": "\u2958", + "LeftVector": "\u21BC", + "LeftVectorBar": "\u2952", + "Leftarrow": "\u21D0", + "Leftrightarrow": "\u21D4", + "LessEqualGreater": "\u22DA", + "LessFullEqual": "\u2266", + "LessGreater": "\u2276", + "LessLess": "\u2AA1", + "LessSlantEqual": "\u2A7D", + "LessTilde": "\u2272", + "Lfr": "\U0001D50F", + "Ll": "\u22D8", + "Lleftarrow": "\u21DA", + "Lmidot": "\u013F", + "LongLeftArrow": "\u27F5", + "LongLeftRightArrow": "\u27F7", + "LongRightArrow": "\u27F6", + "Longleftarrow": "\u27F8", + "Longleftrightarrow": "\u27FA", + "Longrightarrow": "\u27F9", + "Lopf": "\U0001D543", + "LowerLeftArrow": "\u2199", + "LowerRightArrow": "\u2198", + "Lscr": "\u2112", + "Lsh": "\u21B0", + "Lstrok": "\u0141", + "Lt": "\u226A", + "Map": "\u2905", + "Mcy": "\u041C", + "MediumSpace": "\u205F", + "Mellintrf": "\u2133", + "Mfr": "\U0001D510", + "MinusPlus": "\u2213", + "Mopf": "\U0001D544", + "Mscr": "\u2133", + "Mu": "\u039C", + "NJcy": "\u040A", + "Nacute": "\u0143", + "Ncaron": "\u0147", + "Ncedil": "\u0145", + "Ncy": "\u041D", + "NegativeMediumSpace": "\u200B", + "NegativeThickSpace": "\u200B", + "NegativeThinSpace": "\u200B", + "NegativeVeryThinSpace": "\u200B", + "NestedGreaterGreater": "\u226B", + "NestedLessLess": "\u226A", + "NewLine": "\u000A", + "Nfr": "\U0001D511", + "NoBreak": "\u2060", + "NonBreakingSpace": "\u00A0", + "Nopf": "\u2115", + "Not": "\u2AEC", + "NotCongruent": "\u2262", + "NotCupCap": "\u226D", + "NotDoubleVerticalBar": "\u2226", + "NotElement": "\u2209", + "NotEqual": "\u2260", + "NotEqualTilde": "\u2242\u0338", + "NotExists": "\u2204", + "NotGreater": "\u226F", + "NotGreaterEqual": "\u2271", + "NotGreaterFullEqual": "\u2267\u0338", + "NotGreaterGreater": "\u226B\u0338", + "NotGreaterLess": "\u2279", + "NotGreaterSlantEqual": "\u2A7E\u0338", + "NotGreaterTilde": "\u2275", + "NotHumpDownHump": "\u224E\u0338", + "NotHumpEqual": "\u224F\u0338", + "NotLeftTriangle": "\u22EA", + "NotLeftTriangleBar": "\u29CF\u0338", + "NotLeftTriangleEqual": "\u22EC", + "NotLess": "\u226E", + "NotLessEqual": "\u2270", + "NotLessGreater": "\u2278", + "NotLessLess": "\u226A\u0338", + "NotLessSlantEqual": "\u2A7D\u0338", + "NotLessTilde": "\u2274", + "NotNestedGreaterGreater": "\u2AA2\u0338", + "NotNestedLessLess": "\u2AA1\u0338", + "NotPrecedes": "\u2280", + "NotPrecedesEqual": "\u2AAF\u0338", + "NotPrecedesSlantEqual": "\u22E0", + "NotReverseElement": "\u220C", + "NotRightTriangle": "\u22EB", + "NotRightTriangleBar": "\u29D0\u0338", + "NotRightTriangleEqual": "\u22ED", + "NotSquareSubset": "\u228F\u0338", + "NotSquareSubsetEqual": "\u22E2", + "NotSquareSuperset": "\u2290\u0338", + "NotSquareSupersetEqual": "\u22E3", + "NotSubset": "\u2282\u20D2", + "NotSubsetEqual": "\u2288", + "NotSucceeds": "\u2281", + "NotSucceedsEqual": "\u2AB0\u0338", + "NotSucceedsSlantEqual": "\u22E1", + "NotSucceedsTilde": "\u227F\u0338", + "NotSuperset": "\u2283\u20D2", + "NotSupersetEqual": "\u2289", + "NotTilde": "\u2241", + "NotTildeEqual": "\u2244", + "NotTildeFullEqual": "\u2247", + "NotTildeTilde": "\u2249", + "NotVerticalBar": "\u2224", + "Nscr": "\U0001D4A9", + "Ntilde": "\u00D1", + "Nu": "\u039D", + "OElig": "\u0152", + "Oacute": "\u00D3", + "Ocirc": "\u00D4", + "Ocy": "\u041E", + "Odblac": "\u0150", + "Ofr": "\U0001D512", + "Ograve": "\u00D2", + "Omacr": "\u014C", + "Omega": "\u03A9", + "Omicron": "\u039F", + "Oopf": "\U0001D546", + "OpenCurlyDoubleQuote": "\u201C", + "OpenCurlyQuote": "\u2018", + "Or": "\u2A54", + "Oscr": "\U0001D4AA", + "Oslash": "\u00D8", + "Otilde": "\u00D5", + "Otimes": "\u2A37", + "Ouml": "\u00D6", + "OverBar": "\u203E", + "OverBrace": "\u23DE", + "OverBracket": "\u23B4", + "OverParenthesis": "\u23DC", + "PartialD": "\u2202", + "Pcy": "\u041F", + "Pfr": "\U0001D513", + "Phi": "\u03A6", + "Pi": "\u03A0", + "PlusMinus": "\u00B1", + "Poincareplane": "\u210C", + "Popf": "\u2119", + "Pr": "\u2ABB", + "Precedes": "\u227A", + "PrecedesEqual": "\u2AAF", + "PrecedesSlantEqual": "\u227C", + "PrecedesTilde": "\u227E", + "Prime": "\u2033", + "Product": "\u220F", + "Proportion": "\u2237", + "Proportional": "\u221D", + "Pscr": "\U0001D4AB", + "Psi": "\u03A8", + "QUOT": "\u0022", + "Qfr": "\U0001D514", + "Qopf": "\u211A", + "Qscr": "\U0001D4AC", + "RBarr": "\u2910", + "REG": "\u00AE", + "Racute": "\u0154", + "Rang": "\u27EB", + "Rarr": "\u21A0", + "Rarrtl": "\u2916", + "Rcaron": "\u0158", + "Rcedil": "\u0156", + "Rcy": "\u0420", + "Re": "\u211C", + "ReverseElement": "\u220B", + "ReverseEquilibrium": "\u21CB", + "ReverseUpEquilibrium": "\u296F", + "Rfr": "\u211C", + "Rho": "\u03A1", + "RightAngleBracket": "\u27E9", + "RightArrow": "\u2192", + "RightArrowBar": "\u21E5", + "RightArrowLeftArrow": "\u21C4", + "RightCeiling": "\u2309", + "RightDoubleBracket": "\u27E7", + "RightDownTeeVector": "\u295D", + "RightDownVector": "\u21C2", + "RightDownVectorBar": "\u2955", + "RightFloor": "\u230B", + "RightTee": "\u22A2", + "RightTeeArrow": "\u21A6", + "RightTeeVector": "\u295B", + "RightTriangle": "\u22B3", + "RightTriangleBar": "\u29D0", + "RightTriangleEqual": "\u22B5", + "RightUpDownVector": "\u294F", + "RightUpTeeVector": "\u295C", + "RightUpVector": "\u21BE", + "RightUpVectorBar": "\u2954", + "RightVector": "\u21C0", + "RightVectorBar": "\u2953", + "Rightarrow": "\u21D2", + "Ropf": "\u211D", + "RoundImplies": "\u2970", + "Rrightarrow": "\u21DB", + "Rscr": "\u211B", + "Rsh": "\u21B1", + "RuleDelayed": "\u29F4", + "SHCHcy": "\u0429", + "SHcy": "\u0428", + "SOFTcy": "\u042C", + "Sacute": "\u015A", + "Sc": "\u2ABC", + "Scaron": "\u0160", + "Scedil": "\u015E", + "Scirc": "\u015C", + "Scy": "\u0421", + "Sfr": "\U0001D516", + "ShortDownArrow": "\u2193", + "ShortLeftArrow": "\u2190", + "ShortRightArrow": "\u2192", + "ShortUpArrow": "\u2191", + "Sigma": "\u03A3", + "SmallCircle": "\u2218", + "Sopf": "\U0001D54A", + "Sqrt": "\u221A", + "Square": "\u25A1", + "SquareIntersection": "\u2293", + "SquareSubset": "\u228F", + "SquareSubsetEqual": "\u2291", + "SquareSuperset": "\u2290", + "SquareSupersetEqual": "\u2292", + "SquareUnion": "\u2294", + "Sscr": "\U0001D4AE", + "Star": "\u22C6", + "Sub": "\u22D0", + "Subset": "\u22D0", + "SubsetEqual": "\u2286", + "Succeeds": "\u227B", + "SucceedsEqual": "\u2AB0", + "SucceedsSlantEqual": "\u227D", + "SucceedsTilde": "\u227F", + "SuchThat": "\u220B", + "Sum": "\u2211", + "Sup": "\u22D1", + "Superset": "\u2283", + "SupersetEqual": "\u2287", + "Supset": "\u22D1", + "THORN": "\u00DE", + "TRADE": "\u2122", + "TSHcy": "\u040B", + "TScy": "\u0426", + "Tab": "\u0009", + "Tau": "\u03A4", + "Tcaron": "\u0164", + "Tcedil": "\u0162", + "Tcy": "\u0422", + "Tfr": "\U0001D517", + "Therefore": "\u2234", + "Theta": "\u0398", + "ThickSpace": "\u205F\u200A", + "ThinSpace": "\u2009", + "Tilde": "\u223C", + "TildeEqual": "\u2243", + "TildeFullEqual": "\u2245", + "TildeTilde": "\u2248", + "Topf": "\U0001D54B", + "TripleDot": "\u20DB", + "Tscr": "\U0001D4AF", + "Tstrok": "\u0166", + "Uacute": "\u00DA", + "Uarr": "\u219F", + "Uarrocir": "\u2949", + "Ubrcy": "\u040E", + "Ubreve": "\u016C", + "Ucirc": "\u00DB", + "Ucy": "\u0423", + "Udblac": "\u0170", + "Ufr": "\U0001D518", + "Ugrave": "\u00D9", + "Umacr": "\u016A", + "UnderBar": "\u005F", + "UnderBrace": "\u23DF", + "UnderBracket": "\u23B5", + "UnderParenthesis": "\u23DD", + "Union": "\u22C3", + "UnionPlus": "\u228E", + "Uogon": "\u0172", + "Uopf": "\U0001D54C", + "UpArrow": "\u2191", + "UpArrowBar": "\u2912", + "UpArrowDownArrow": "\u21C5", + "UpDownArrow": "\u2195", + "UpEquilibrium": "\u296E", + "UpTee": "\u22A5", + "UpTeeArrow": "\u21A5", + "Uparrow": "\u21D1", + "Updownarrow": "\u21D5", + "UpperLeftArrow": "\u2196", + "UpperRightArrow": "\u2197", + "Upsi": "\u03D2", + "Upsilon": "\u03A5", + "Uring": "\u016E", + "Uscr": "\U0001D4B0", + "Utilde": "\u0168", + "Uuml": "\u00DC", + "VDash": "\u22AB", + "Vbar": "\u2AEB", + "Vcy": "\u0412", + "Vdash": "\u22A9", + "Vdashl": "\u2AE6", + "Vee": "\u22C1", + "Verbar": "\u2016", + "Vert": "\u2016", + "VerticalBar": "\u2223", + "VerticalLine": "\u007C", + "VerticalSeparator": "\u2758", + "VerticalTilde": "\u2240", + "VeryThinSpace": "\u200A", + "Vfr": "\U0001D519", + "Vopf": "\U0001D54D", + "Vscr": "\U0001D4B1", + "Vvdash": "\u22AA", + "Wcirc": "\u0174", + "Wedge": "\u22C0", + "Wfr": "\U0001D51A", + "Wopf": "\U0001D54E", + "Wscr": "\U0001D4B2", + "Xfr": "\U0001D51B", + "Xi": "\u039E", + "Xopf": "\U0001D54F", + "Xscr": "\U0001D4B3", + "YAcy": "\u042F", + "YIcy": "\u0407", + "YUcy": "\u042E", + "Yacute": "\u00DD", + "Ycirc": "\u0176", + "Ycy": "\u042B", + "Yfr": "\U0001D51C", + "Yopf": "\U0001D550", + "Yscr": "\U0001D4B4", + "Yuml": "\u0178", + "ZHcy": "\u0416", + "Zacute": "\u0179", + "Zcaron": "\u017D", + "Zcy": "\u0417", + "Zdot": "\u017B", + "ZeroWidthSpace": "\u200B", + "Zeta": "\u0396", + "Zfr": "\u2128", + "Zopf": "\u2124", + "Zscr": "\U0001D4B5", + "aacute": "\u00E1", + "abreve": "\u0103", + "ac": "\u223E", + "acE": "\u223E\u0333", + "acd": "\u223F", + "acirc": "\u00E2", + "acute": "\u00B4", + "acy": "\u0430", + "aelig": "\u00E6", + "af": "\u2061", + "afr": "\U0001D51E", + "agrave": "\u00E0", + "alefsym": "\u2135", + "aleph": "\u2135", + "alpha": "\u03B1", + "amacr": "\u0101", + "amalg": "\u2A3F", + "amp": "\u0026", + "and": "\u2227", + "andand": "\u2A55", + "andd": "\u2A5C", + "andslope": "\u2A58", + "andv": "\u2A5A", + "ang": "\u2220", + "ange": "\u29A4", + "angle": "\u2220", + "angmsd": "\u2221", + "angmsdaa": "\u29A8", + "angmsdab": "\u29A9", + "angmsdac": "\u29AA", + "angmsdad": "\u29AB", + "angmsdae": "\u29AC", + "angmsdaf": "\u29AD", + "angmsdag": "\u29AE", + "angmsdah": "\u29AF", + "angrt": "\u221F", + "angrtvb": "\u22BE", + "angrtvbd": "\u299D", + "angsph": "\u2222", + "angst": "\u00C5", + "angzarr": "\u237C", + "aogon": "\u0105", + "aopf": "\U0001D552", + "ap": "\u2248", + "apE": "\u2A70", + "apacir": "\u2A6F", + "ape": "\u224A", + "apid": "\u224B", + "apos": "\u0027", + "approx": "\u2248", + "approxeq": "\u224A", + "aring": "\u00E5", + "ascr": "\U0001D4B6", + "ast": "\u002A", + "asymp": "\u2248", + "asympeq": "\u224D", + "atilde": "\u00E3", + "auml": "\u00E4", + "awconint": "\u2233", + "awint": "\u2A11", + "bNot": "\u2AED", + "backcong": "\u224C", + "backepsilon": "\u03F6", + "backprime": "\u2035", + "backsim": "\u223D", + "backsimeq": "\u22CD", + "barvee": "\u22BD", + "barwed": "\u2305", + "barwedge": "\u2305", + "bbrk": "\u23B5", + "bbrktbrk": "\u23B6", + "bcong": "\u224C", + "bcy": "\u0431", + "bdquo": "\u201E", + "becaus": "\u2235", + "because": "\u2235", + "bemptyv": "\u29B0", + "bepsi": "\u03F6", + "bernou": "\u212C", + "beta": "\u03B2", + "beth": "\u2136", + "between": "\u226C", + "bfr": "\U0001D51F", + "bigcap": "\u22C2", + "bigcirc": "\u25EF", + "bigcup": "\u22C3", + "bigodot": "\u2A00", + "bigoplus": "\u2A01", + "bigotimes": "\u2A02", + "bigsqcup": "\u2A06", + "bigstar": "\u2605", + "bigtriangledown": "\u25BD", + "bigtriangleup": "\u25B3", + "biguplus": "\u2A04", + "bigvee": "\u22C1", + "bigwedge": "\u22C0", + "bkarow": "\u290D", + "blacklozenge": "\u29EB", + "blacksquare": "\u25AA", + "blacktriangle": "\u25B4", + "blacktriangledown": "\u25BE", + "blacktriangleleft": "\u25C2", + "blacktriangleright": "\u25B8", + "blank": "\u2423", + "blk12": "\u2592", + "blk14": "\u2591", + "blk34": "\u2593", + "block": "\u2588", + "bne": "\u003D\u20E5", + "bnequiv": "\u2261\u20E5", + "bnot": "\u2310", + "bopf": "\U0001D553", + "bot": "\u22A5", + "bottom": "\u22A5", + "bowtie": "\u22C8", + "boxDL": "\u2557", + "boxDR": "\u2554", + "boxDl": "\u2556", + "boxDr": "\u2553", + "boxH": "\u2550", + "boxHD": "\u2566", + "boxHU": "\u2569", + "boxHd": "\u2564", + "boxHu": "\u2567", + "boxUL": "\u255D", + "boxUR": "\u255A", + "boxUl": "\u255C", + "boxUr": "\u2559", + "boxV": "\u2551", + "boxVH": "\u256C", + "boxVL": "\u2563", + "boxVR": "\u2560", + "boxVh": "\u256B", + "boxVl": "\u2562", + "boxVr": "\u255F", + "boxbox": "\u29C9", + "boxdL": "\u2555", + "boxdR": "\u2552", + "boxdl": "\u2510", + "boxdr": "\u250C", + "boxh": "\u2500", + "boxhD": "\u2565", + "boxhU": "\u2568", + "boxhd": "\u252C", + "boxhu": "\u2534", + "boxminus": "\u229F", + "boxplus": "\u229E", + "boxtimes": "\u22A0", + "boxuL": "\u255B", + "boxuR": "\u2558", + "boxul": "\u2518", + "boxur": "\u2514", + "boxv": "\u2502", + "boxvH": "\u256A", + "boxvL": "\u2561", + "boxvR": "\u255E", + "boxvh": "\u253C", + "boxvl": "\u2524", + "boxvr": "\u251C", + "bprime": "\u2035", + "breve": "\u02D8", + "brvbar": "\u00A6", + "bscr": "\U0001D4B7", + "bsemi": "\u204F", + "bsim": "\u223D", + "bsime": "\u22CD", + "bsol": "\u005C", + "bsolb": "\u29C5", + "bsolhsub": "\u27C8", + "bull": "\u2022", + "bullet": "\u2022", + "bump": "\u224E", + "bumpE": "\u2AAE", + "bumpe": "\u224F", + "bumpeq": "\u224F", + "cacute": "\u0107", + "cap": "\u2229", + "capand": "\u2A44", + "capbrcup": "\u2A49", + "capcap": "\u2A4B", + "capcup": "\u2A47", + "capdot": "\u2A40", + "caps": "\u2229\uFE00", + "caret": "\u2041", + "caron": "\u02C7", + "ccaps": "\u2A4D", + "ccaron": "\u010D", + "ccedil": "\u00E7", + "ccirc": "\u0109", + "ccups": "\u2A4C", + "ccupssm": "\u2A50", + "cdot": "\u010B", + "cedil": "\u00B8", + "cemptyv": "\u29B2", + "cent": "\u00A2", + "centerdot": "\u00B7", + "cfr": "\U0001D520", + "chcy": "\u0447", + "check": "\u2713", + "checkmark": "\u2713", + "chi": "\u03C7", + "cir": "\u25CB", + "cirE": "\u29C3", + "circ": "\u02C6", + "circeq": "\u2257", + "circlearrowleft": "\u21BA", + "circlearrowright": "\u21BB", + "circledR": "\u00AE", + "circledS": "\u24C8", + "circledast": "\u229B", + "circledcirc": "\u229A", + "circleddash": "\u229D", + "cire": "\u2257", + "cirfnint": "\u2A10", + "cirmid": "\u2AEF", + "cirscir": "\u29C2", + "clubs": "\u2663", + "clubsuit": "\u2663", + "colon": "\u003A", + "colone": "\u2254", + "coloneq": "\u2254", + "comma": "\u002C", + "commat": "\u0040", + "comp": "\u2201", + "compfn": "\u2218", + "complement": "\u2201", + "complexes": "\u2102", + "cong": "\u2245", + "congdot": "\u2A6D", + "conint": "\u222E", + "copf": "\U0001D554", + "coprod": "\u2210", + "copy": "\u00A9", + "copysr": "\u2117", + "crarr": "\u21B5", + "cross": "\u2717", + "cscr": "\U0001D4B8", + "csub": "\u2ACF", + "csube": "\u2AD1", + "csup": "\u2AD0", + "csupe": "\u2AD2", + "ctdot": "\u22EF", + "cudarrl": "\u2938", + "cudarrr": "\u2935", + "cuepr": "\u22DE", + "cuesc": "\u22DF", + "cularr": "\u21B6", + "cularrp": "\u293D", + "cup": "\u222A", + "cupbrcap": "\u2A48", + "cupcap": "\u2A46", + "cupcup": "\u2A4A", + "cupdot": "\u228D", + "cupor": "\u2A45", + "cups": "\u222A\uFE00", + "curarr": "\u21B7", + "curarrm": "\u293C", + "curlyeqprec": "\u22DE", + "curlyeqsucc": "\u22DF", + "curlyvee": "\u22CE", + "curlywedge": "\u22CF", + "curren": "\u00A4", + "curvearrowleft": "\u21B6", + "curvearrowright": "\u21B7", + "cuvee": "\u22CE", + "cuwed": "\u22CF", + "cwconint": "\u2232", + "cwint": "\u2231", + "cylcty": "\u232D", + "dArr": "\u21D3", + "dHar": "\u2965", + "dagger": "\u2020", + "daleth": "\u2138", + "darr": "\u2193", + "dash": "\u2010", + "dashv": "\u22A3", + "dbkarow": "\u290F", + "dblac": "\u02DD", + "dcaron": "\u010F", + "dcy": "\u0434", + "dd": "\u2146", + "ddagger": "\u2021", + "ddarr": "\u21CA", + "ddotseq": "\u2A77", + "deg": "\u00B0", + "delta": "\u03B4", + "demptyv": "\u29B1", + "dfisht": "\u297F", + "dfr": "\U0001D521", + "dharl": "\u21C3", + "dharr": "\u21C2", + "diam": "\u22C4", + "diamond": "\u22C4", + "diamondsuit": "\u2666", + "diams": "\u2666", + "die": "\u00A8", + "digamma": "\u03DD", + "disin": "\u22F2", + "div": "\u00F7", + "divide": "\u00F7", + "divideontimes": "\u22C7", + "divonx": "\u22C7", + "djcy": "\u0452", + "dlcorn": "\u231E", + "dlcrop": "\u230D", + "dollar": "\u0024", + "dopf": "\U0001D555", + "dot": "\u02D9", + "doteq": "\u2250", + "doteqdot": "\u2251", + "dotminus": "\u2238", + "dotplus": "\u2214", + "dotsquare": "\u22A1", + "doublebarwedge": "\u2306", + "downarrow": "\u2193", + "downdownarrows": "\u21CA", + "downharpoonleft": "\u21C3", + "downharpoonright": "\u21C2", + "drbkarow": "\u2910", + "drcorn": "\u231F", + "drcrop": "\u230C", + "dscr": "\U0001D4B9", + "dscy": "\u0455", + "dsol": "\u29F6", + "dstrok": "\u0111", + "dtdot": "\u22F1", + "dtri": "\u25BF", + "dtrif": "\u25BE", + "duarr": "\u21F5", + "duhar": "\u296F", + "dwangle": "\u29A6", + "dzcy": "\u045F", + "dzigrarr": "\u27FF", + "eDDot": "\u2A77", + "eDot": "\u2251", + "eacute": "\u00E9", + "easter": "\u2A6E", + "ecaron": "\u011B", + "ecir": "\u2256", + "ecirc": "\u00EA", + "ecolon": "\u2255", + "ecy": "\u044D", + "edot": "\u0117", + "ee": "\u2147", + "efDot": "\u2252", + "efr": "\U0001D522", + "eg": "\u2A9A", + "egrave": "\u00E8", + "egs": "\u2A96", + "egsdot": "\u2A98", + "el": "\u2A99", + "elinters": "\u23E7", + "ell": "\u2113", + "els": "\u2A95", + "elsdot": "\u2A97", + "emacr": "\u0113", + "empty": "\u2205", + "emptyset": "\u2205", + "emptyv": "\u2205", + "emsp": "\u2003", + "emsp13": "\u2004", + "emsp14": "\u2005", + "eng": "\u014B", + "ensp": "\u2002", + "eogon": "\u0119", + "eopf": "\U0001D556", + "epar": "\u22D5", + "eparsl": "\u29E3", + "eplus": "\u2A71", + "epsi": "\u03B5", + "epsilon": "\u03B5", + "epsiv": "\u03F5", + "eqcirc": "\u2256", + "eqcolon": "\u2255", + "eqsim": "\u2242", + "eqslantgtr": "\u2A96", + "eqslantless": "\u2A95", + "equals": "\u003D", + "equest": "\u225F", + "equiv": "\u2261", + "equivDD": "\u2A78", + "eqvparsl": "\u29E5", + "erDot": "\u2253", + "erarr": "\u2971", + "escr": "\u212F", + "esdot": "\u2250", + "esim": "\u2242", + "eta": "\u03B7", + "eth": "\u00F0", + "euml": "\u00EB", + "euro": "\u20AC", + "excl": "\u0021", + "exist": "\u2203", + "expectation": "\u2130", + "exponentiale": "\u2147", + "fallingdotseq": "\u2252", + "fcy": "\u0444", + "female": "\u2640", + "ffilig": "\uFB03", + "fflig": "\uFB00", + "ffllig": "\uFB04", + "ffr": "\U0001D523", + "filig": "\uFB01", + "fjlig": "\u0066\u006A fj", + "flat": "\u266D", + "fllig": "\uFB02", + "fltns": "\u25B1", + "fnof": "\u0192", + "fopf": "\U0001D557", + "forall": "\u2200", + "fork": "\u22D4", + "forkv": "\u2AD9", + "fpartint": "\u2A0D", + "frac12": "\u00BD", + "frac13": "\u2153", + "frac14": "\u00BC", + "frac15": "\u2155", + "frac16": "\u2159", + "frac18": "\u215B", + "frac23": "\u2154", + "frac25": "\u2156", + "frac34": "\u00BE", + "frac35": "\u2157", + "frac38": "\u215C", + "frac45": "\u2158", + "frac56": "\u215A", + "frac58": "\u215D", + "frac78": "\u215E", + "frasl": "\u2044", + "frown": "\u2322", + "fscr": "\U0001D4BB", + "gE": "\u2267", + "gEl": "\u2A8C", + "gacute": "\u01F5", + "gamma": "\u03B3", + "gammad": "\u03DD", + "gap": "\u2A86", + "gbreve": "\u011F", + "gcirc": "\u011D", + "gcy": "\u0433", + "gdot": "\u0121", + "ge": "\u2265", + "gel": "\u22DB", + "geq": "\u2265", + "geqq": "\u2267", + "geqslant": "\u2A7E", + "ges": "\u2A7E", + "gescc": "\u2AA9", + "gesdot": "\u2A80", + "gesdoto": "\u2A82", + "gesdotol": "\u2A84", + "gesl": "\u22DB\uFE00", + "gesles": "\u2A94", + "gfr": "\U0001D524", + "gg": "\u226B", + "ggg": "\u22D9", + "gimel": "\u2137", + "gjcy": "\u0453", + "gl": "\u2277", + "glE": "\u2A92", + "gla": "\u2AA5", + "glj": "\u2AA4", + "gnE": "\u2269", + "gnap": "\u2A8A", + "gnapprox": "\u2A8A", + "gne": "\u2A88", + "gneq": "\u2A88", + "gneqq": "\u2269", + "gnsim": "\u22E7", + "gopf": "\U0001D558", + "grave": "\u0060", + "gscr": "\u210A", + "gsim": "\u2273", + "gsime": "\u2A8E", + "gsiml": "\u2A90", + "gt": "\u003E", + "gtcc": "\u2AA7", + "gtcir": "\u2A7A", + "gtdot": "\u22D7", + "gtlPar": "\u2995", + "gtquest": "\u2A7C", + "gtrapprox": "\u2A86", + "gtrarr": "\u2978", + "gtrdot": "\u22D7", + "gtreqless": "\u22DB", + "gtreqqless": "\u2A8C", + "gtrless": "\u2277", + "gtrsim": "\u2273", + "gvertneqq": "\u2269\uFE00", + "gvnE": "\u2269\uFE00", + "hArr": "\u21D4", + "hairsp": "\u200A", + "half": "\u00BD", + "hamilt": "\u210B", + "hardcy": "\u044A", + "harr": "\u2194", + "harrcir": "\u2948", + "harrw": "\u21AD", + "hbar": "\u210F", + "hcirc": "\u0125", + "hearts": "\u2665", + "heartsuit": "\u2665", + "hellip": "\u2026", + "hercon": "\u22B9", + "hfr": "\U0001D525", + "hksearow": "\u2925", + "hkswarow": "\u2926", + "hoarr": "\u21FF", + "homtht": "\u223B", + "hookleftarrow": "\u21A9", + "hookrightarrow": "\u21AA", + "hopf": "\U0001D559", + "horbar": "\u2015", + "hscr": "\U0001D4BD", + "hslash": "\u210F", + "hstrok": "\u0127", + "hybull": "\u2043", + "hyphen": "\u2010", + "iacute": "\u00ED", + "ic": "\u2063", + "icirc": "\u00EE", + "icy": "\u0438", + "iecy": "\u0435", + "iexcl": "\u00A1", + "iff": "\u21D4", + "ifr": "\U0001D526", + "igrave": "\u00EC", + "ii": "\u2148", + "iiiint": "\u2A0C", + "iiint": "\u222D", + "iinfin": "\u29DC", + "iiota": "\u2129", + "ijlig": "\u0133", + "imacr": "\u012B", + "image": "\u2111", + "imagline": "\u2110", + "imagpart": "\u2111", + "imath": "\u0131", + "imof": "\u22B7", + "imped": "\u01B5", + "in": "\u2208", + "incare": "\u2105", + "infin": "\u221E", + "infintie": "\u29DD", + "inodot": "\u0131", + "int": "\u222B", + "intcal": "\u22BA", + "integers": "\u2124", + "intercal": "\u22BA", + "intlarhk": "\u2A17", + "intprod": "\u2A3C", + "iocy": "\u0451", + "iogon": "\u012F", + "iopf": "\U0001D55A", + "iota": "\u03B9", + "iprod": "\u2A3C", + "iquest": "\u00BF", + "iscr": "\U0001D4BE", + "isin": "\u2208", + "isinE": "\u22F9", + "isindot": "\u22F5", + "isins": "\u22F4", + "isinsv": "\u22F3", + "isinv": "\u2208", + "it": "\u2062", + "itilde": "\u0129", + "iukcy": "\u0456", + "iuml": "\u00EF", + "jcirc": "\u0135", + "jcy": "\u0439", + "jfr": "\U0001D527", + "jmath": "\u0237", + "jopf": "\U0001D55B", + "jscr": "\U0001D4BF", + "jsercy": "\u0458", + "jukcy": "\u0454", + "kappa": "\u03BA", + "kappav": "\u03F0", + "kcedil": "\u0137", + "kcy": "\u043A", + "kfr": "\U0001D528", + "kgreen": "\u0138", + "khcy": "\u0445", + "kjcy": "\u045C", + "kopf": "\U0001D55C", + "kscr": "\U0001D4C0", + "lAarr": "\u21DA", + "lArr": "\u21D0", + "lAtail": "\u291B", + "lBarr": "\u290E", + "lE": "\u2266", + "lEg": "\u2A8B", + "lHar": "\u2962", + "lacute": "\u013A", + "laemptyv": "\u29B4", + "lagran": "\u2112", + "lambda": "\u03BB", + "lang": "\u27E8", + "langd": "\u2991", + "langle": "\u27E8", + "lap": "\u2A85", + "laquo": "\u00AB", + "larr": "\u2190", + "larrb": "\u21E4", + "larrbfs": "\u291F", + "larrfs": "\u291D", + "larrhk": "\u21A9", + "larrlp": "\u21AB", + "larrpl": "\u2939", + "larrsim": "\u2973", + "larrtl": "\u21A2", + "lat": "\u2AAB", + "latail": "\u2919", + "late": "\u2AAD", + "lates": "\u2AAD\uFE00", + "lbarr": "\u290C", + "lbbrk": "\u2772", + "lbrace": "\u007B", + "lbrack": "\u005B", + "lbrke": "\u298B", + "lbrksld": "\u298F", + "lbrkslu": "\u298D", + "lcaron": "\u013E", + "lcedil": "\u013C", + "lceil": "\u2308", + "lcub": "\u007B", + "lcy": "\u043B", + "ldca": "\u2936", + "ldquo": "\u201C", + "ldquor": "\u201E", + "ldrdhar": "\u2967", + "ldrushar": "\u294B", + "ldsh": "\u21B2", + "le": "\u2264", + "leftarrow": "\u2190", + "leftarrowtail": "\u21A2", + "leftharpoondown": "\u21BD", + "leftharpoonup": "\u21BC", + "leftleftarrows": "\u21C7", + "leftrightarrow": "\u2194", + "leftrightarrows": "\u21C6", + "leftrightharpoons": "\u21CB", + "leftrightsquigarrow": "\u21AD", + "leftthreetimes": "\u22CB", + "leg": "\u22DA", + "leq": "\u2264", + "leqq": "\u2266", + "leqslant": "\u2A7D", + "les": "\u2A7D", + "lescc": "\u2AA8", + "lesdot": "\u2A7F", + "lesdoto": "\u2A81", + "lesdotor": "\u2A83", + "lesg": "\u22DA\uFE00", + "lesges": "\u2A93", + "lessapprox": "\u2A85", + "lessdot": "\u22D6", + "lesseqgtr": "\u22DA", + "lesseqqgtr": "\u2A8B", + "lessgtr": "\u2276", + "lesssim": "\u2272", + "lfisht": "\u297C", + "lfloor": "\u230A", + "lfr": "\U0001D529", + "lg": "\u2276", + "lgE": "\u2A91", + "lhard": "\u21BD", + "lharu": "\u21BC", + "lharul": "\u296A", + "lhblk": "\u2584", + "ljcy": "\u0459", + "ll": "\u226A", + "llarr": "\u21C7", + "llcorner": "\u231E", + "llhard": "\u296B", + "lltri": "\u25FA", + "lmidot": "\u0140", + "lmoust": "\u23B0", + "lmoustache": "\u23B0", + "lnE": "\u2268", + "lnap": "\u2A89", + "lnapprox": "\u2A89", + "lne": "\u2A87", + "lneq": "\u2A87", + "lneqq": "\u2268", + "lnsim": "\u22E6", + "loang": "\u27EC", + "loarr": "\u21FD", + "lobrk": "\u27E6", + "longleftarrow": "\u27F5", + "longleftrightarrow": "\u27F7", + "longmapsto": "\u27FC", + "longrightarrow": "\u27F6", + "looparrowleft": "\u21AB", + "looparrowright": "\u21AC", + "lopar": "\u2985", + "lopf": "\U0001D55D", + "loplus": "\u2A2D", + "lotimes": "\u2A34", + "lowast": "\u2217", + "lowbar": "\u005F", + "loz": "\u25CA", + "lozenge": "\u25CA", + "lozf": "\u29EB", + "lpar": "\u0028", + "lparlt": "\u2993", + "lrarr": "\u21C6", + "lrcorner": "\u231F", + "lrhar": "\u21CB", + "lrhard": "\u296D", + "lrm": "\u200E", + "lrtri": "\u22BF", + "lsaquo": "\u2039", + "lscr": "\U0001D4C1", + "lsh": "\u21B0", + "lsim": "\u2272", + "lsime": "\u2A8D", + "lsimg": "\u2A8F", + "lsqb": "\u005B", + "lsquo": "\u2018", + "lsquor": "\u201A", + "lstrok": "\u0142", + "lt": "\u003C", + "ltcc": "\u2AA6", + "ltcir": "\u2A79", + "ltdot": "\u22D6", + "lthree": "\u22CB", + "ltimes": "\u22C9", + "ltlarr": "\u2976", + "ltquest": "\u2A7B", + "ltrPar": "\u2996", + "ltri": "\u25C3", + "ltrie": "\u22B4", + "ltrif": "\u25C2", + "lurdshar": "\u294A", + "luruhar": "\u2966", + "lvertneqq": "\u2268\uFE00", + "lvnE": "\u2268\uFE00", + "mDDot": "\u223A", + "macr": "\u00AF", + "male": "\u2642", + "malt": "\u2720", + "maltese": "\u2720", + "map": "\u21A6", + "mapsto": "\u21A6", + "mapstodown": "\u21A7", + "mapstoleft": "\u21A4", + "mapstoup": "\u21A5", + "marker": "\u25AE", + "mcomma": "\u2A29", + "mcy": "\u043C", + "mdash": "\u2014", + "measuredangle": "\u2221", + "mfr": "\U0001D52A", + "mho": "\u2127", + "micro": "\u00B5", + "mid": "\u2223", + "midast": "\u002A", + "midcir": "\u2AF0", + "middot": "\u00B7", + "minus": "\u2212", + "minusb": "\u229F", + "minusd": "\u2238", + "minusdu": "\u2A2A", + "mlcp": "\u2ADB", + "mldr": "\u2026", + "mnplus": "\u2213", + "models": "\u22A7", + "mopf": "\U0001D55E", + "mp": "\u2213", + "mscr": "\U0001D4C2", + "mstpos": "\u223E", + "mu": "\u03BC", + "multimap": "\u22B8", + "mumap": "\u22B8", + "nGg": "\u22D9\u0338", + "nGt": "\u226B\u20D2", + "nGtv": "\u226B\u0338", + "nLeftarrow": "\u21CD", + "nLeftrightarrow": "\u21CE", + "nLl": "\u22D8\u0338", + "nLt": "\u226A\u20D2", + "nLtv": "\u226A\u0338", + "nRightarrow": "\u21CF", + "nVDash": "\u22AF", + "nVdash": "\u22AE", + "nabla": "\u2207", + "nacute": "\u0144", + "nang": "\u2220\u20D2", + "nap": "\u2249", + "napE": "\u2A70\u0338", + "napid": "\u224B\u0338", + "napos": "\u0149", + "napprox": "\u2249", + "natur": "\u266E", + "natural": "\u266E", + "naturals": "\u2115", + "nbsp": "\u00A0", + "nbump": "\u224E\u0338", + "nbumpe": "\u224F\u0338", + "ncap": "\u2A43", + "ncaron": "\u0148", + "ncedil": "\u0146", + "ncong": "\u2247", + "ncongdot": "\u2A6D\u0338", + "ncup": "\u2A42", + "ncy": "\u043D", + "ndash": "\u2013", + "ne": "\u2260", + "neArr": "\u21D7", + "nearhk": "\u2924", + "nearr": "\u2197", + "nearrow": "\u2197", + "nedot": "\u2250\u0338", + "nequiv": "\u2262", + "nesear": "\u2928", + "nesim": "\u2242\u0338", + "nexist": "\u2204", + "nexists": "\u2204", + "nfr": "\U0001D52B", + "ngE": "\u2267\u0338", + "nge": "\u2271", + "ngeq": "\u2271", + "ngeqq": "\u2267\u0338", + "ngeqslant": "\u2A7E\u0338", + "nges": "\u2A7E\u0338", + "ngsim": "\u2275", + "ngt": "\u226F", + "ngtr": "\u226F", + "nhArr": "\u21CE", + "nharr": "\u21AE", + "nhpar": "\u2AF2", + "ni": "\u220B", + "nis": "\u22FC", + "nisd": "\u22FA", + "niv": "\u220B", + "njcy": "\u045A", + "nlArr": "\u21CD", + "nlE": "\u2266\u0338", + "nlarr": "\u219A", + "nldr": "\u2025", + "nle": "\u2270", + "nleftarrow": "\u219A", + "nleftrightarrow": "\u21AE", + "nleq": "\u2270", + "nleqq": "\u2266\u0338", + "nleqslant": "\u2A7D\u0338", + "nles": "\u2A7D\u0338", + "nless": "\u226E", + "nlsim": "\u2274", + "nlt": "\u226E", + "nltri": "\u22EA", + "nltrie": "\u22EC", + "nmid": "\u2224", + "nopf": "\U0001D55F", + "not": "\u00AC", + "notin": "\u2209", + "notinE": "\u22F9\u0338", + "notindot": "\u22F5\u0338", + "notinva": "\u2209", + "notinvb": "\u22F7", + "notinvc": "\u22F6", + "notni": "\u220C", + "notniva": "\u220C", + "notnivb": "\u22FE", + "notnivc": "\u22FD", + "npar": "\u2226", + "nparallel": "\u2226", + "nparsl": "\u2AFD\u20E5", + "npart": "\u2202\u0338", + "npolint": "\u2A14", + "npr": "\u2280", + "nprcue": "\u22E0", + "npre": "\u2AAF\u0338", + "nprec": "\u2280", + "npreceq": "\u2AAF\u0338", + "nrArr": "\u21CF", + "nrarr": "\u219B", + "nrarrc": "\u2933\u0338", + "nrarrw": "\u219D\u0338", + "nrightarrow": "\u219B", + "nrtri": "\u22EB", + "nrtrie": "\u22ED", + "nsc": "\u2281", + "nsccue": "\u22E1", + "nsce": "\u2AB0\u0338", + "nscr": "\U0001D4C3", + "nshortmid": "\u2224", + "nshortparallel": "\u2226", + "nsim": "\u2241", + "nsime": "\u2244", + "nsimeq": "\u2244", + "nsmid": "\u2224", + "nspar": "\u2226", + "nsqsube": "\u22E2", + "nsqsupe": "\u22E3", + "nsub": "\u2284", + "nsubE": "\u2AC5\u0338", + "nsube": "\u2288", + "nsubset": "\u2282\u20D2", + "nsubseteq": "\u2288", + "nsubseteqq": "\u2AC5\u0338", + "nsucc": "\u2281", + "nsucceq": "\u2AB0\u0338", + "nsup": "\u2285", + "nsupE": "\u2AC6\u0338", + "nsupe": "\u2289", + "nsupset": "\u2283\u20D2", + "nsupseteq": "\u2289", + "nsupseteqq": "\u2AC6\u0338", + "ntgl": "\u2279", + "ntilde": "\u00F1", + "ntlg": "\u2278", + "ntriangleleft": "\u22EA", + "ntrianglelefteq": "\u22EC", + "ntriangleright": "\u22EB", + "ntrianglerighteq": "\u22ED", + "nu": "\u03BD", + "num": "\u0023", + "numero": "\u2116", + "numsp": "\u2007", + "nvDash": "\u22AD", + "nvHarr": "\u2904", + "nvap": "\u224D\u20D2", + "nvdash": "\u22AC", + "nvge": "\u2265\u20D2", + "nvgt": "\u003E\u20D2", + "nvinfin": "\u29DE", + "nvlArr": "\u2902", + "nvle": "\u2264\u20D2", + "nvlt": "\u003C\u20D2", + "nvltrie": "\u22B4\u20D2", + "nvrArr": "\u2903", + "nvrtrie": "\u22B5\u20D2", + "nvsim": "\u223C\u20D2", + "nwArr": "\u21D6", + "nwarhk": "\u2923", + "nwarr": "\u2196", + "nwarrow": "\u2196", + "nwnear": "\u2927", + "oS": "\u24C8", + "oacute": "\u00F3", + "oast": "\u229B", + "ocir": "\u229A", + "ocirc": "\u00F4", + "ocy": "\u043E", + "odash": "\u229D", + "odblac": "\u0151", + "odiv": "\u2A38", + "odot": "\u2299", + "odsold": "\u29BC", + "oelig": "\u0153", + "ofcir": "\u29BF", + "ofr": "\U0001D52C", + "ogon": "\u02DB", + "ograve": "\u00F2", + "ogt": "\u29C1", + "ohbar": "\u29B5", + "ohm": "\u03A9", + "oint": "\u222E", + "olarr": "\u21BA", + "olcir": "\u29BE", + "olcross": "\u29BB", + "oline": "\u203E", + "olt": "\u29C0", + "omacr": "\u014D", + "omega": "\u03C9", + "omicron": "\u03BF", + "omid": "\u29B6", + "ominus": "\u2296", + "oopf": "\U0001D560", + "opar": "\u29B7", + "operp": "\u29B9", + "oplus": "\u2295", + "or": "\u2228", + "orarr": "\u21BB", + "ord": "\u2A5D", + "order": "\u2134", + "orderof": "\u2134", + "ordf": "\u00AA", + "ordm": "\u00BA", + "origof": "\u22B6", + "oror": "\u2A56", + "orslope": "\u2A57", + "orv": "\u2A5B", + "oscr": "\u2134", + "oslash": "\u00F8", + "osol": "\u2298", + "otilde": "\u00F5", + "otimes": "\u2297", + "otimesas": "\u2A36", + "ouml": "\u00F6", + "ovbar": "\u233D", + "par": "\u2225", + "para": "\u00B6", + "parallel": "\u2225", + "parsim": "\u2AF3", + "parsl": "\u2AFD", + "part": "\u2202", + "pcy": "\u043F", + "percnt": "\u0025", + "period": "\u002E", + "permil": "\u2030", + "perp": "\u22A5", + "pertenk": "\u2031", + "pfr": "\U0001D52D", + "phi": "\u03C6", + "phiv": "\u03D5", + "phmmat": "\u2133", + "phone": "\u260E", + "pi": "\u03C0", + "pitchfork": "\u22D4", + "piv": "\u03D6", + "planck": "\u210F", + "planckh": "\u210E", + "plankv": "\u210F", + "plus": "\u002B", + "plusacir": "\u2A23", + "plusb": "\u229E", + "pluscir": "\u2A22", + "plusdo": "\u2214", + "plusdu": "\u2A25", + "pluse": "\u2A72", + "plusmn": "\u00B1", + "plussim": "\u2A26", + "plustwo": "\u2A27", + "pm": "\u00B1", + "pointint": "\u2A15", + "popf": "\U0001D561", + "pound": "\u00A3", + "pr": "\u227A", + "prE": "\u2AB3", + "prap": "\u2AB7", + "prcue": "\u227C", + "pre": "\u2AAF", + "prec": "\u227A", + "precapprox": "\u2AB7", + "preccurlyeq": "\u227C", + "preceq": "\u2AAF", + "precnapprox": "\u2AB9", + "precneqq": "\u2AB5", + "precnsim": "\u22E8", + "precsim": "\u227E", + "prime": "\u2032", + "primes": "\u2119", + "prnE": "\u2AB5", + "prnap": "\u2AB9", + "prnsim": "\u22E8", + "prod": "\u220F", + "profalar": "\u232E", + "profline": "\u2312", + "profsurf": "\u2313", + "prop": "\u221D", + "propto": "\u221D", + "prsim": "\u227E", + "prurel": "\u22B0", + "pscr": "\U0001D4C5", + "psi": "\u03C8", + "puncsp": "\u2008", + "qfr": "\U0001D52E", + "qint": "\u2A0C", + "qopf": "\U0001D562", + "qprime": "\u2057", + "qscr": "\U0001D4C6", + "quaternions": "\u210D", + "quatint": "\u2A16", + "quest": "\u003F", + "questeq": "\u225F", + "quot": "\u0022", + "rAarr": "\u21DB", + "rArr": "\u21D2", + "rAtail": "\u291C", + "rBarr": "\u290F", + "rHar": "\u2964", + "race": "\u223D\u0331", + "racute": "\u0155", + "radic": "\u221A", + "raemptyv": "\u29B3", + "rang": "\u27E9", + "rangd": "\u2992", + "range": "\u29A5", + "rangle": "\u27E9", + "raquo": "\u00BB", + "rarr": "\u2192", + "rarrap": "\u2975", + "rarrb": "\u21E5", + "rarrbfs": "\u2920", + "rarrc": "\u2933", + "rarrfs": "\u291E", + "rarrhk": "\u21AA", + "rarrlp": "\u21AC", + "rarrpl": "\u2945", + "rarrsim": "\u2974", + "rarrtl": "\u21A3", + "rarrw": "\u219D", + "ratail": "\u291A", + "ratio": "\u2236", + "rationals": "\u211A", + "rbarr": "\u290D", + "rbbrk": "\u2773", + "rbrace": "\u007D", + "rbrack": "\u005D", + "rbrke": "\u298C", + "rbrksld": "\u298E", + "rbrkslu": "\u2990", + "rcaron": "\u0159", + "rcedil": "\u0157", + "rceil": "\u2309", + "rcub": "\u007D", + "rcy": "\u0440", + "rdca": "\u2937", + "rdldhar": "\u2969", + "rdquo": "\u201D", + "rdquor": "\u201D", + "rdsh": "\u21B3", + "real": "\u211C", + "realine": "\u211B", + "realpart": "\u211C", + "reals": "\u211D", + "rect": "\u25AD", + "reg": "\u00AE", + "rfisht": "\u297D", + "rfloor": "\u230B", + "rfr": "\U0001D52F", + "rhard": "\u21C1", + "rharu": "\u21C0", + "rharul": "\u296C", + "rho": "\u03C1", + "rhov": "\u03F1", + "rightarrow": "\u2192", + "rightarrowtail": "\u21A3", + "rightharpoondown": "\u21C1", + "rightharpoonup": "\u21C0", + "rightleftarrows": "\u21C4", + "rightleftharpoons": "\u21CC", + "rightrightarrows": "\u21C9", + "rightsquigarrow": "\u219D", + "rightthreetimes": "\u22CC", + "ring": "\u02DA", + "risingdotseq": "\u2253", + "rlarr": "\u21C4", + "rlhar": "\u21CC", + "rlm": "\u200F", + "rmoust": "\u23B1", + "rmoustache": "\u23B1", + "rnmid": "\u2AEE", + "roang": "\u27ED", + "roarr": "\u21FE", + "robrk": "\u27E7", + "ropar": "\u2986", + "ropf": "\U0001D563", + "roplus": "\u2A2E", + "rotimes": "\u2A35", + "rpar": "\u0029", + "rpargt": "\u2994", + "rppolint": "\u2A12", + "rrarr": "\u21C9", + "rsaquo": "\u203A", + "rscr": "\U0001D4C7", + "rsh": "\u21B1", + "rsqb": "\u005D", + "rsquo": "\u2019", + "rsquor": "\u2019", + "rthree": "\u22CC", + "rtimes": "\u22CA", + "rtri": "\u25B9", + "rtrie": "\u22B5", + "rtrif": "\u25B8", + "rtriltri": "\u29CE", + "ruluhar": "\u2968", + "rx": "\u211E", + "sacute": "\u015B", + "sbquo": "\u201A", + "sc": "\u227B", + "scE": "\u2AB4", + "scap": "\u2AB8", + "scaron": "\u0161", + "sccue": "\u227D", + "sce": "\u2AB0", + "scedil": "\u015F", + "scirc": "\u015D", + "scnE": "\u2AB6", + "scnap": "\u2ABA", + "scnsim": "\u22E9", + "scpolint": "\u2A13", + "scsim": "\u227F", + "scy": "\u0441", + "sdot": "\u22C5", + "sdotb": "\u22A1", + "sdote": "\u2A66", + "seArr": "\u21D8", + "searhk": "\u2925", + "searr": "\u2198", + "searrow": "\u2198", + "sect": "\u00A7", + "semi": "\u003B", + "seswar": "\u2929", + "setminus": "\u2216", + "setmn": "\u2216", + "sext": "\u2736", + "sfr": "\U0001D530", + "sfrown": "\u2322", + "sharp": "\u266F", + "shchcy": "\u0449", + "shcy": "\u0448", + "shortmid": "\u2223", + "shortparallel": "\u2225", + "shy": "\u00AD", + "sigma": "\u03C3", + "sigmaf": "\u03C2", + "sigmav": "\u03C2", + "sim": "\u223C", + "simdot": "\u2A6A", + "sime": "\u2243", + "simeq": "\u2243", + "simg": "\u2A9E", + "simgE": "\u2AA0", + "siml": "\u2A9D", + "simlE": "\u2A9F", + "simne": "\u2246", + "simplus": "\u2A24", + "simrarr": "\u2972", + "slarr": "\u2190", + "smallsetminus": "\u2216", + "smashp": "\u2A33", + "smeparsl": "\u29E4", + "smid": "\u2223", + "smile": "\u2323", + "smt": "\u2AAA", + "smte": "\u2AAC", + "smtes": "\u2AAC\uFE00", + "softcy": "\u044C", + "sol": "\u002F", + "solb": "\u29C4", + "solbar": "\u233F", + "sopf": "\U0001D564", + "spades": "\u2660", + "spadesuit": "\u2660", + "spar": "\u2225", + "sqcap": "\u2293", + "sqcaps": "\u2293\uFE00", + "sqcup": "\u2294", + "sqcups": "\u2294\uFE00", + "sqsub": "\u228F", + "sqsube": "\u2291", + "sqsubset": "\u228F", + "sqsubseteq": "\u2291", + "sqsup": "\u2290", + "sqsupe": "\u2292", + "sqsupset": "\u2290", + "sqsupseteq": "\u2292", + "squ": "\u25A1", + "square": "\u25A1", + "squarf": "\u25AA", + "squf": "\u25AA", + "srarr": "\u2192", + "sscr": "\U0001D4C8", + "ssetmn": "\u2216", + "ssmile": "\u2323", + "sstarf": "\u22C6", + "star": "\u2606", + "starf": "\u2605", + "straightepsilon": "\u03F5", + "straightphi": "\u03D5", + "strns": "\u00AF", + "sub": "\u2282", + "subE": "\u2AC5", + "subdot": "\u2ABD", + "sube": "\u2286", + "subedot": "\u2AC3", + "submult": "\u2AC1", + "subnE": "\u2ACB", + "subne": "\u228A", + "subplus": "\u2ABF", + "subrarr": "\u2979", + "subset": "\u2282", + "subseteq": "\u2286", + "subseteqq": "\u2AC5", + "subsetneq": "\u228A", + "subsetneqq": "\u2ACB", + "subsim": "\u2AC7", + "subsub": "\u2AD5", + "subsup": "\u2AD3", + "succ": "\u227B", + "succapprox": "\u2AB8", + "succcurlyeq": "\u227D", + "succeq": "\u2AB0", + "succnapprox": "\u2ABA", + "succneqq": "\u2AB6", + "succnsim": "\u22E9", + "succsim": "\u227F", + "sum": "\u2211", + "sung": "\u266A", + "sup": "\u2283", + "sup1": "\u00B9", + "sup2": "\u00B2", + "sup3": "\u00B3", + "supE": "\u2AC6", + "supdot": "\u2ABE", + "supdsub": "\u2AD8", + "supe": "\u2287", + "supedot": "\u2AC4", + "suphsol": "\u27C9", + "suphsub": "\u2AD7", + "suplarr": "\u297B", + "supmult": "\u2AC2", + "supnE": "\u2ACC", + "supne": "\u228B", + "supplus": "\u2AC0", + "supset": "\u2283", + "supseteq": "\u2287", + "supseteqq": "\u2AC6", + "supsetneq": "\u228B", + "supsetneqq": "\u2ACC", + "supsim": "\u2AC8", + "supsub": "\u2AD4", + "supsup": "\u2AD6", + "swArr": "\u21D9", + "swarhk": "\u2926", + "swarr": "\u2199", + "swarrow": "\u2199", + "swnwar": "\u292A", + "szlig": "\u00DF", + "target": "\u2316", + "tau": "\u03C4", + "tbrk": "\u23B4", + "tcaron": "\u0165", + "tcedil": "\u0163", + "tcy": "\u0442", + "tdot": "\u20DB", + "telrec": "\u2315", + "tfr": "\U0001D531", + "there4": "\u2234", + "therefore": "\u2234", + "theta": "\u03B8", + "thetasym": "\u03D1", + "thetav": "\u03D1", + "thickapprox": "\u2248", + "thicksim": "\u223C", + "thinsp": "\u2009", + "thkap": "\u2248", + "thksim": "\u223C", + "thorn": "\u00FE", + "tilde": "\u02DC", + "times": "\u00D7", + "timesb": "\u22A0", + "timesbar": "\u2A31", + "timesd": "\u2A30", + "tint": "\u222D", + "toea": "\u2928", + "top": "\u22A4", + "topbot": "\u2336", + "topcir": "\u2AF1", + "topf": "\U0001D565", + "topfork": "\u2ADA", + "tosa": "\u2929", + "tprime": "\u2034", + "trade": "\u2122", + "triangle": "\u25B5", + "triangledown": "\u25BF", + "triangleleft": "\u25C3", + "trianglelefteq": "\u22B4", + "triangleq": "\u225C", + "triangleright": "\u25B9", + "trianglerighteq": "\u22B5", + "tridot": "\u25EC", + "trie": "\u225C", + "triminus": "\u2A3A", + "triplus": "\u2A39", + "trisb": "\u29CD", + "tritime": "\u2A3B", + "trpezium": "\u23E2", + "tscr": "\U0001D4C9", + "tscy": "\u0446", + "tshcy": "\u045B", + "tstrok": "\u0167", + "twixt": "\u226C", + "twoheadleftarrow": "\u219E", + "twoheadrightarrow": "\u21A0", + "uArr": "\u21D1", + "uHar": "\u2963", + "uacute": "\u00FA", + "uarr": "\u2191", + "ubrcy": "\u045E", + "ubreve": "\u016D", + "ucirc": "\u00FB", + "ucy": "\u0443", + "udarr": "\u21C5", + "udblac": "\u0171", + "udhar": "\u296E", + "ufisht": "\u297E", + "ufr": "\U0001D532", + "ugrave": "\u00F9", + "uharl": "\u21BF", + "uharr": "\u21BE", + "uhblk": "\u2580", + "ulcorn": "\u231C", + "ulcorner": "\u231C", + "ulcrop": "\u230F", + "ultri": "\u25F8", + "umacr": "\u016B", + "uml": "\u00A8", + "uogon": "\u0173", + "uopf": "\U0001D566", + "uparrow": "\u2191", + "updownarrow": "\u2195", + "upharpoonleft": "\u21BF", + "upharpoonright": "\u21BE", + "uplus": "\u228E", + "upsi": "\u03C5", + "upsih": "\u03D2", + "upsilon": "\u03C5", + "upuparrows": "\u21C8", + "urcorn": "\u231D", + "urcorner": "\u231D", + "urcrop": "\u230E", + "uring": "\u016F", + "urtri": "\u25F9", + "uscr": "\U0001D4CA", + "utdot": "\u22F0", + "utilde": "\u0169", + "utri": "\u25B5", + "utrif": "\u25B4", + "uuarr": "\u21C8", + "uuml": "\u00FC", + "uwangle": "\u29A7", + "vArr": "\u21D5", + "vBar": "\u2AE8", + "vBarv": "\u2AE9", + "vDash": "\u22A8", + "vangrt": "\u299C", + "varepsilon": "\u03F5", + "varkappa": "\u03F0", + "varnothing": "\u2205", + "varphi": "\u03D5", + "varpi": "\u03D6", + "varpropto": "\u221D", + "varr": "\u2195", + "varrho": "\u03F1", + "varsigma": "\u03C2", + "varsubsetneq": "\u228A\uFE00", + "varsubsetneqq": "\u2ACB\uFE00", + "varsupsetneq": "\u228B\uFE00", + "varsupsetneqq": "\u2ACC\uFE00", + "vartheta": "\u03D1", + "vartriangleleft": "\u22B2", + "vartriangleright": "\u22B3", + "vcy": "\u0432", + "vdash": "\u22A2", + "vee": "\u2228", + "veebar": "\u22BB", + "veeeq": "\u225A", + "vellip": "\u22EE", + "verbar": "\u007C", + "vert": "\u007C", + "vfr": "\U0001D533", + "vltri": "\u22B2", + "vnsub": "\u2282\u20D2", + "vnsup": "\u2283\u20D2", + "vopf": "\U0001D567", + "vprop": "\u221D", + "vrtri": "\u22B3", + "vscr": "\U0001D4CB", + "vsubnE": "\u2ACB\uFE00", + "vsubne": "\u228A\uFE00", + "vsupnE": "\u2ACC\uFE00", + "vsupne": "\u228B\uFE00", + "vzigzag": "\u299A", + "wcirc": "\u0175", + "wedbar": "\u2A5F", + "wedge": "\u2227", + "wedgeq": "\u2259", + "weierp": "\u2118", + "wfr": "\U0001D534", + "wopf": "\U0001D568", + "wp": "\u2118", + "wr": "\u2240", + "wreath": "\u2240", + "wscr": "\U0001D4CC", + "xcap": "\u22C2", + "xcirc": "\u25EF", + "xcup": "\u22C3", + "xdtri": "\u25BD", + "xfr": "\U0001D535", + "xhArr": "\u27FA", + "xharr": "\u27F7", + "xi": "\u03BE", + "xlArr": "\u27F8", + "xlarr": "\u27F5", + "xmap": "\u27FC", + "xnis": "\u22FB", + "xodot": "\u2A00", + "xopf": "\U0001D569", + "xoplus": "\u2A01", + "xotime": "\u2A02", + "xrArr": "\u27F9", + "xrarr": "\u27F6", + "xscr": "\U0001D4CD", + "xsqcup": "\u2A06", + "xuplus": "\u2A04", + "xutri": "\u25B3", + "xvee": "\u22C1", + "xwedge": "\u22C0", + "yacute": "\u00FD", + "yacy": "\u044F", + "ycirc": "\u0177", + "ycy": "\u044B", + "yen": "\u00A5", + "yfr": "\U0001D536", + "yicy": "\u0457", + "yopf": "\U0001D56A", + "yscr": "\U0001D4CE", + "yucy": "\u044E", + "yuml": "\u00FF", + "zacute": "\u017A", + "zcaron": "\u017E", + "zcy": "\u0437", + "zdot": "\u017C", + "zeetrf": "\u2128", + "zeta": "\u03B6", + "zfr": "\U0001D537", + "zhcy": "\u0436", + "zigrarr": "\u21DD", + "zopf": "\U0001D56B", + "zscr": "\U0001D4CF", + "zwj": "\u200D", + "zwnj": "\u200C", +} diff --git a/vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml new file mode 100644 index 00000000..c873ca36 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml @@ -0,0 +1,19 @@ +image: golang:1.11 + +stages: + - build + - test + +before_script: + - go get golang.org/x/text/unicode/rangetable + +build: + stage: build + script: + - go build ./... + +test: + stage: test + script: + - test -z "$(gofmt -l . | tee /dev/stderr)" + - go test ./... diff --git a/vendor/gitlab.com/golang-commonmark/linkify/LICENSE b/vendor/gitlab.com/golang-commonmark/linkify/LICENSE new file mode 100644 index 00000000..9cdcd201 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/LICENSE @@ -0,0 +1,10 @@ +Copyright (c) 2015, The 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: + +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/gitlab.com/golang-commonmark/linkify/README.md b/vendor/gitlab.com/golang-commonmark/linkify/README.md new file mode 100644 index 00000000..8b791113 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/README.md @@ -0,0 +1,12 @@ +linkify [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/linkify?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/linkify) [![Pipeline status](https://gitlab.com/golang-commonmark/linkify/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/linkify/commits/master) +======= + +Package linkify provides a way to find what looks like links in plain text. + +## Install + + go get -u gitlab.com/golang-commonmark/linkify + +## Use + +See an [example](https://gitlab.com/golang-commonmark/linkify/blob/master/linkify_example_test.go). diff --git a/vendor/gitlab.com/golang-commonmark/linkify/charset.go b/vendor/gitlab.com/golang-commonmark/linkify/charset.go new file mode 100644 index 00000000..7ea3b625 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/charset.go @@ -0,0 +1,51 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package linkify + +import ( + "unicode" + + "golang.org/x/text/unicode/rangetable" +) + +var ( + unreserved = [256]bool{'-': true, '.': true, '_': true, '~': true} + basicPunct = [256]bool{'.': true, ',': true, '?': true, '!': true, ';': true, ':': true} + subdelims = [256]bool{'!': true, '$': true, '&': true, '\'': true, '(': true, ')': true, + '*': true, '+': true, ',': true, ';': true, '=': true} + emailcs = [256]bool{'a': true, 'b': true, 'c': true, 'd': true, 'e': true, 'f': true, 'g': true, + 'h': true, 'i': true, 'j': true, 'k': true, 'l': true, 'm': true, 'n': true, 'o': true, + 'p': true, 'q': true, 'r': true, 's': true, 't': true, 'u': true, 'v': true, 'w': true, + 'x': true, 'y': true, 'z': true, 'A': true, 'B': true, 'C': true, 'D': true, 'E': true, + 'F': true, 'G': true, 'H': true, 'I': true, 'J': true, 'K': true, 'L': true, 'M': true, + 'N': true, 'O': true, 'P': true, 'Q': true, 'R': true, 'S': true, 'T': true, 'U': true, + 'V': true, 'W': true, 'X': true, 'Y': true, 'Z': true, '0': true, '1': true, '2': true, + '3': true, '4': true, '5': true, '6': true, '7': true, '8': true, '9': true, '!': true, + '#': true, '$': true, '%': true, '&': true, '\'': true, '*': true, '+': true, '/': true, + '=': true, '?': true, '^': true, '_': true, '`': true, '{': true, '|': true, '}': true, + '~': true, '-': true} + letterOrDigit = rangetable.Merge(unicode.Letter, unicode.Digit) + punctSpaceCc = rangetable.Merge(unicode.Punct, unicode.Space, unicode.Cc) +) + +func isAllowedInEmail(r rune) bool { + return r < 0x7f && emailcs[r] +} + +func isLetterOrDigit(r rune) bool { + return unicode.Is(letterOrDigit, r) +} + +func isPunctOrSpaceOrControl(r rune) bool { + return r == '<' || r == '>' || r == '\uff5c' || unicode.Is(punctSpaceCc, r) +} + +func isUnreserved(r rune) bool { + return (r < 0x7f && unreserved[r]) || unicode.Is(letterOrDigit, r) +} + +func isSubDelimiter(r rune) bool { + return r < 0x7f && subdelims[r] +} diff --git a/vendor/gitlab.com/golang-commonmark/linkify/email.go b/vendor/gitlab.com/golang-commonmark/linkify/email.go new file mode 100644 index 00000000..35bfb679 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/email.go @@ -0,0 +1,93 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package linkify + +import ( + "unicode" + "unicode/utf8" +) + +func findEmailStart(s string, start int) (_ int, _ bool) { + end := start + allowDot := false + for end >= 0 { + b := s[end] + switch { + case emailcs[b]: + allowDot = true + case b == '.': + if !allowDot { + return + } + allowDot = false + default: + if end == start { + return + } + if s[end+1] == '.' { + return + } + r, _ := utf8.DecodeLastRuneInString(s[:end+1]) + if r == utf8.RuneError { + return + } + if !unicode.IsSpace(r) { + return + } + return end + 1, true + } + end-- + } + if end < start && s[end+1] == '.' { + return + } + return end + 1, true +} + +func findEmailEnd(s string, start int) (_ int, _ bool) { + end := start + allowDot := false +loop: + for end < len(s) { + b := s[end] + switch { + case emailcs[b]: + allowDot = true + case b == '.': + if !allowDot { + return + } + allowDot = false + case b == '@': + break loop + default: + return + } + end++ + } + if end >= len(s)-5 { + return + } + if end > start && s[end-1] == '.' { + return + } + + var dot int + var ok bool + end, dot, ok = findHostnameEnd(s, end+1) + if !ok || dot == -1 { + return + } + + if dot+5 <= len(s) && s[dot+1:dot+5] == "xn--" { + return end, true + } + + if length := match(s[dot+1:]); dot+length+1 != end { + return + } + + return end, true +} diff --git a/vendor/gitlab.com/golang-commonmark/linkify/generated.go b/vendor/gitlab.com/golang-commonmark/linkify/generated.go new file mode 100644 index 00000000..0fbd3cba --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/generated.go @@ -0,0 +1,18175 @@ +// Code generated by genfsm.go. DO NOT EDIT + +package linkify + +func match(s string) int { + st := 0 + length := -1 + + for i := 0; i < len(s); i++ { + b := s[i] + + switch st { + case 0: + switch byteToLower(b) { + case 'a': + st = 1 + case 'b': + st = 148 + case 'c': + st = 303 + case 'd': + st = 571 + case 'e': + st = 686 + case 'f': + st = 797 + case 'g': + st = 916 + case 'h': + st = 1014 + case 'i': + st = 1099 + case 'j': + st = 1180 + case 'k': + st = 1210 + case 'l': + st = 1253 + case 'm': + st = 1349 + case 'n': + st = 1478 + case 'o': + st = 1536 + case 'p': + st = 1577 + case 'q': + st = 1699 + case 'r': + st = 1709 + case 's': + st = 1797 + case 't': + st = 2010 + case 'u': + st = 2128 + case 'v': + st = 2147 + case 'w': + st = 2220 + case 'x': + st = 2283 + case 'y': + st = 2297 + case 'z': + st = 2330 + case '0': + st = 2348 + case '1': + st = 2350 + case '2': + st = 2352 + case '3': + st = 2354 + case '4': + st = 2356 + case '5': + st = 2358 + case '6': + st = 2360 + case '7': + st = 2362 + case '8': + st = 2364 + case '9': + st = 2366 + default: + return length + } + + case 1: + switch byteToLower(b) { + case 'b': + st = 2 + case 'c': + length = i + 1 + st = 12 + case 'd': + length = i + 1 + st = 39 + case 'e': + length = i + 1 + st = 44 + case 'f': + length = i + 1 + st = 47 + case 'g': + length = i + 1 + st = 49 + case 'i': + length = i + 1 + st = 54 + case 'l': + length = i + 1 + st = 62 + case 'm': + length = i + 1 + st = 74 + case 'n': + length = i + 1 + st = 82 + case 'o': + length = i + 1 + st = 88 + case 'p': + st = 89 + case 'q': + length = i + 1 + st = 98 + case 'r': + length = i + 1 + st = 106 + case 's': + length = i + 1 + st = 114 + case 't': + length = i + 1 + st = 125 + case 'u': + length = i + 1 + st = 132 + case 'w': + length = i + 1 + st = 144 + case 'x': + length = i + 1 + st = 145 + case 'z': + length = i + 1 + st = 147 + default: + return length + } + + case 2: + switch byteToLower(b) { + case 'b': + length = i + 1 + st = 3 + case 'o': + st = 7 + default: + return length + } + + case 3: + switch byteToLower(b) { + case 'o': + st = 4 + default: + return length + } + + case 4: + switch byteToLower(b) { + case 't': + st = 5 + default: + return length + } + + case 5: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 6 + default: + return length + } + + case 7: + switch byteToLower(b) { + case 'g': + st = 8 + default: + return length + } + + case 8: + switch byteToLower(b) { + case 'a': + st = 9 + default: + return length + } + + case 9: + switch byteToLower(b) { + case 'd': + st = 10 + default: + return length + } + + case 10: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 11 + default: + return length + } + + case 12: + switch byteToLower(b) { + case 'a': + st = 13 + case 'c': + st = 18 + case 't': + st = 33 + default: + return length + } + + case 13: + switch byteToLower(b) { + case 'd': + st = 14 + default: + return length + } + + case 14: + switch byteToLower(b) { + case 'e': + st = 15 + default: + return length + } + + case 15: + switch byteToLower(b) { + case 'm': + st = 16 + default: + return length + } + + case 16: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 17 + default: + return length + } + + case 18: + switch byteToLower(b) { + case 'e': + st = 19 + case 'o': + st = 25 + default: + return length + } + + case 19: + switch byteToLower(b) { + case 'n': + st = 20 + default: + return length + } + + case 20: + switch byteToLower(b) { + case 't': + st = 21 + default: + return length + } + + case 21: + switch byteToLower(b) { + case 'u': + st = 22 + default: + return length + } + + case 22: + switch byteToLower(b) { + case 'r': + st = 23 + default: + return length + } + + case 23: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 24 + default: + return length + } + + case 25: + switch byteToLower(b) { + case 'u': + st = 26 + default: + return length + } + + case 26: + switch byteToLower(b) { + case 'n': + st = 27 + default: + return length + } + + case 27: + switch byteToLower(b) { + case 't': + st = 28 + default: + return length + } + + case 28: + switch byteToLower(b) { + case 'a': + st = 29 + default: + return length + } + + case 29: + switch byteToLower(b) { + case 'n': + st = 30 + default: + return length + } + + case 30: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 31 + default: + return length + } + + case 31: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 32 + default: + return length + } + + case 33: + switch byteToLower(b) { + case 'i': + st = 34 + case 'o': + st = 37 + default: + return length + } + + case 34: + switch byteToLower(b) { + case 'v': + st = 35 + default: + return length + } + + case 35: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 36 + default: + return length + } + + case 37: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 38 + default: + return length + } + + case 39: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 40 + case 'u': + st = 41 + default: + return length + } + + case 41: + switch byteToLower(b) { + case 'l': + st = 42 + default: + return length + } + + case 42: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 43 + default: + return length + } + + case 44: + switch byteToLower(b) { + case 'r': + st = 45 + default: + return length + } + + case 45: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 46 + default: + return length + } + + case 47: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 48 + default: + return length + } + + case 49: + switch byteToLower(b) { + case 'e': + st = 50 + default: + return length + } + + case 50: + switch byteToLower(b) { + case 'n': + st = 51 + default: + return length + } + + case 51: + switch byteToLower(b) { + case 'c': + st = 52 + default: + return length + } + + case 52: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 53 + default: + return length + } + + case 54: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 55 + case 'r': + st = 56 + default: + return length + } + + case 56: + switch byteToLower(b) { + case 'f': + st = 57 + default: + return length + } + + case 57: + switch byteToLower(b) { + case 'o': + st = 58 + default: + return length + } + + case 58: + switch byteToLower(b) { + case 'r': + st = 59 + default: + return length + } + + case 59: + switch byteToLower(b) { + case 'c': + st = 60 + default: + return length + } + + case 60: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 61 + default: + return length + } + + case 62: + switch byteToLower(b) { + case 'l': + st = 63 + case 's': + st = 70 + default: + return length + } + + case 63: + switch byteToLower(b) { + case 'f': + st = 64 + default: + return length + } + + case 64: + switch byteToLower(b) { + case 'i': + st = 65 + default: + return length + } + + case 65: + switch byteToLower(b) { + case 'n': + st = 66 + default: + return length + } + + case 66: + switch byteToLower(b) { + case 'a': + st = 67 + default: + return length + } + + case 67: + switch byteToLower(b) { + case 'n': + st = 68 + default: + return length + } + + case 68: + switch byteToLower(b) { + case 'z': + length = i + 1 + st = 69 + default: + return length + } + + case 70: + switch byteToLower(b) { + case 'a': + st = 71 + default: + return length + } + + case 71: + switch byteToLower(b) { + case 'c': + st = 72 + default: + return length + } + + case 72: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 73 + default: + return length + } + + case 74: + switch byteToLower(b) { + case 's': + st = 75 + default: + return length + } + + case 75: + switch byteToLower(b) { + case 't': + st = 76 + default: + return length + } + + case 76: + switch byteToLower(b) { + case 'e': + st = 77 + default: + return length + } + + case 77: + switch byteToLower(b) { + case 'r': + st = 78 + default: + return length + } + + case 78: + switch byteToLower(b) { + case 'd': + st = 79 + default: + return length + } + + case 79: + switch byteToLower(b) { + case 'a': + st = 80 + default: + return length + } + + case 80: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 81 + default: + return length + } + + case 82: + switch byteToLower(b) { + case 'd': + st = 83 + default: + return length + } + + case 83: + switch byteToLower(b) { + case 'r': + st = 84 + default: + return length + } + + case 84: + switch byteToLower(b) { + case 'o': + st = 85 + default: + return length + } + + case 85: + switch byteToLower(b) { + case 'i': + st = 86 + default: + return length + } + + case 86: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 87 + default: + return length + } + + case 89: + switch byteToLower(b) { + case 'a': + st = 90 + default: + return length + } + + case 90: + switch byteToLower(b) { + case 'r': + st = 91 + default: + return length + } + + case 91: + switch byteToLower(b) { + case 't': + st = 92 + default: + return length + } + + case 92: + switch byteToLower(b) { + case 'm': + st = 93 + default: + return length + } + + case 93: + switch byteToLower(b) { + case 'e': + st = 94 + default: + return length + } + + case 94: + switch byteToLower(b) { + case 'n': + st = 95 + default: + return length + } + + case 95: + switch byteToLower(b) { + case 't': + st = 96 + default: + return length + } + + case 96: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 97 + default: + return length + } + + case 98: + switch byteToLower(b) { + case 'u': + st = 99 + default: + return length + } + + case 99: + switch byteToLower(b) { + case 'a': + st = 100 + default: + return length + } + + case 100: + switch byteToLower(b) { + case 'r': + st = 101 + default: + return length + } + + case 101: + switch byteToLower(b) { + case 'e': + st = 102 + default: + return length + } + + case 102: + switch byteToLower(b) { + case 'l': + st = 103 + default: + return length + } + + case 103: + switch byteToLower(b) { + case 'l': + st = 104 + default: + return length + } + + case 104: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 105 + default: + return length + } + + case 106: + switch byteToLower(b) { + case 'c': + st = 107 + case 'm': + st = 110 + case 'p': + st = 112 + default: + return length + } + + case 107: + switch byteToLower(b) { + case 'h': + st = 108 + default: + return length + } + + case 108: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 109 + default: + return length + } + + case 110: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 111 + default: + return length + } + + case 112: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 113 + default: + return length + } + + case 114: + switch byteToLower(b) { + case 'i': + st = 115 + case 's': + st = 117 + default: + return length + } + + case 115: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 116 + default: + return length + } + + case 117: + switch byteToLower(b) { + case 'o': + st = 118 + default: + return length + } + + case 118: + switch byteToLower(b) { + case 'c': + st = 119 + default: + return length + } + + case 119: + switch byteToLower(b) { + case 'i': + st = 120 + default: + return length + } + + case 120: + switch byteToLower(b) { + case 'a': + st = 121 + default: + return length + } + + case 121: + switch byteToLower(b) { + case 't': + st = 122 + default: + return length + } + + case 122: + switch byteToLower(b) { + case 'e': + st = 123 + default: + return length + } + + case 123: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 124 + default: + return length + } + + case 125: + switch byteToLower(b) { + case 't': + st = 126 + default: + return length + } + + case 126: + switch byteToLower(b) { + case 'o': + st = 127 + default: + return length + } + + case 127: + switch byteToLower(b) { + case 'r': + st = 128 + default: + return length + } + + case 128: + switch byteToLower(b) { + case 'n': + st = 129 + default: + return length + } + + case 129: + switch byteToLower(b) { + case 'e': + st = 130 + default: + return length + } + + case 130: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 131 + default: + return length + } + + case 132: + switch byteToLower(b) { + case 'c': + st = 133 + case 'd': + st = 138 + case 't': + st = 141 + default: + return length + } + + case 133: + switch byteToLower(b) { + case 't': + st = 134 + default: + return length + } + + case 134: + switch byteToLower(b) { + case 'i': + st = 135 + default: + return length + } + + case 135: + switch byteToLower(b) { + case 'o': + st = 136 + default: + return length + } + + case 136: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 137 + default: + return length + } + + case 138: + switch byteToLower(b) { + case 'i': + st = 139 + default: + return length + } + + case 139: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 140 + default: + return length + } + + case 141: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 142 + default: + return length + } + + case 142: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 143 + default: + return length + } + + case 145: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 146 + default: + return length + } + + case 148: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 149 + case 'b': + length = i + 1 + st = 177 + case 'd': + length = i + 1 + st = 181 + case 'e': + length = i + 1 + st = 182 + case 'f': + length = i + 1 + st = 191 + case 'g': + length = i + 1 + st = 192 + case 'h': + length = i + 1 + st = 193 + case 'i': + length = i + 1 + st = 194 + case 'j': + length = i + 1 + st = 207 + case 'l': + st = 208 + case 'm': + length = i + 1 + st = 227 + case 'n': + length = i + 1 + st = 229 + case 'o': + length = i + 1 + st = 238 + case 'r': + length = i + 1 + st = 251 + case 's': + length = i + 1 + st = 275 + case 't': + length = i + 1 + st = 276 + case 'u': + st = 277 + case 'v': + length = i + 1 + st = 298 + case 'w': + length = i + 1 + st = 299 + case 'y': + length = i + 1 + st = 300 + case 'z': + length = i + 1 + st = 301 + default: + return length + } + + case 149: + switch byteToLower(b) { + case 'n': + st = 150 + case 'r': + length = i + 1 + st = 153 + case 'u': + st = 168 + case 'y': + st = 173 + default: + return length + } + + case 150: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 151 + case 'k': + length = i + 1 + st = 152 + default: + return length + } + + case 153: + switch byteToLower(b) { + case 'c': + st = 154 + case 'g': + st = 163 + default: + return length + } + + case 154: + switch byteToLower(b) { + case 'l': + st = 155 + default: + return length + } + + case 155: + switch byteToLower(b) { + case 'a': + st = 156 + default: + return length + } + + case 156: + switch byteToLower(b) { + case 'y': + st = 157 + default: + return length + } + + case 157: + switch byteToLower(b) { + case 'c': + st = 158 + case 's': + length = i + 1 + st = 162 + default: + return length + } + + case 158: + switch byteToLower(b) { + case 'a': + st = 159 + default: + return length + } + + case 159: + switch byteToLower(b) { + case 'r': + st = 160 + default: + return length + } + + case 160: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 161 + default: + return length + } + + case 163: + switch byteToLower(b) { + case 'a': + st = 164 + default: + return length + } + + case 164: + switch byteToLower(b) { + case 'i': + st = 165 + default: + return length + } + + case 165: + switch byteToLower(b) { + case 'n': + st = 166 + default: + return length + } + + case 166: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 167 + default: + return length + } + + case 168: + switch byteToLower(b) { + case 'h': + st = 169 + default: + return length + } + + case 169: + switch byteToLower(b) { + case 'a': + st = 170 + default: + return length + } + + case 170: + switch byteToLower(b) { + case 'u': + st = 171 + default: + return length + } + + case 171: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 172 + default: + return length + } + + case 173: + switch byteToLower(b) { + case 'e': + st = 174 + default: + return length + } + + case 174: + switch byteToLower(b) { + case 'r': + st = 175 + default: + return length + } + + case 175: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 176 + default: + return length + } + + case 177: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 178 + case 'v': + st = 179 + default: + return length + } + + case 179: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 180 + default: + return length + } + + case 182: + switch byteToLower(b) { + case 'e': + st = 183 + case 'r': + st = 185 + case 's': + st = 189 + default: + return length + } + + case 183: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 184 + default: + return length + } + + case 185: + switch byteToLower(b) { + case 'l': + st = 186 + default: + return length + } + + case 186: + switch byteToLower(b) { + case 'i': + st = 187 + default: + return length + } + + case 187: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 188 + default: + return length + } + + case 189: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 190 + default: + return length + } + + case 194: + switch byteToLower(b) { + case 'b': + st = 195 + case 'd': + length = i + 1 + st = 198 + case 'k': + st = 199 + case 'n': + st = 201 + case 'o': + length = i + 1 + st = 204 + case 't': + length = i + 1 + st = 205 + case 'z': + length = i + 1 + st = 206 + default: + return length + } + + case 195: + switch byteToLower(b) { + case 'l': + st = 196 + default: + return length + } + + case 196: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 197 + default: + return length + } + + case 199: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 200 + default: + return length + } + + case 201: + switch byteToLower(b) { + case 'g': + st = 202 + default: + return length + } + + case 202: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 203 + default: + return length + } + + case 208: + switch byteToLower(b) { + case 'a': + st = 209 + case 'o': + st = 218 + case 'u': + st = 225 + default: + return length + } + + case 209: + switch byteToLower(b) { + case 'c': + st = 210 + default: + return length + } + + case 210: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 211 + default: + return length + } + + case 211: + switch byteToLower(b) { + case 'f': + st = 212 + default: + return length + } + + case 212: + switch byteToLower(b) { + case 'r': + st = 213 + default: + return length + } + + case 213: + switch byteToLower(b) { + case 'i': + st = 214 + default: + return length + } + + case 214: + switch byteToLower(b) { + case 'd': + st = 215 + default: + return length + } + + case 215: + switch byteToLower(b) { + case 'a': + st = 216 + default: + return length + } + + case 216: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 217 + default: + return length + } + + case 218: + switch byteToLower(b) { + case 'o': + st = 219 + default: + return length + } + + case 219: + switch byteToLower(b) { + case 'm': + st = 220 + default: + return length + } + + case 220: + switch byteToLower(b) { + case 'b': + st = 221 + default: + return length + } + + case 221: + switch byteToLower(b) { + case 'e': + st = 222 + default: + return length + } + + case 222: + switch byteToLower(b) { + case 'r': + st = 223 + default: + return length + } + + case 223: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 224 + default: + return length + } + + case 225: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 226 + default: + return length + } + + case 227: + switch byteToLower(b) { + case 'w': + length = i + 1 + st = 228 + default: + return length + } + + case 229: + switch byteToLower(b) { + case 'p': + st = 230 + default: + return length + } + + case 230: + switch byteToLower(b) { + case 'p': + st = 231 + default: + return length + } + + case 231: + switch byteToLower(b) { + case 'a': + st = 232 + default: + return length + } + + case 232: + switch byteToLower(b) { + case 'r': + st = 233 + default: + return length + } + + case 233: + switch byteToLower(b) { + case 'i': + st = 234 + default: + return length + } + + case 234: + switch byteToLower(b) { + case 'b': + st = 235 + default: + return length + } + + case 235: + switch byteToLower(b) { + case 'a': + st = 236 + default: + return length + } + + case 236: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 237 + default: + return length + } + + case 238: + switch byteToLower(b) { + case 'a': + st = 239 + case 'n': + st = 242 + case 'o': + length = i + 1 + st = 244 + case 'u': + st = 245 + default: + return length + } + + case 239: + switch byteToLower(b) { + case 't': + st = 240 + default: + return length + } + + case 240: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 241 + default: + return length + } + + case 242: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 243 + default: + return length + } + + case 245: + switch byteToLower(b) { + case 't': + st = 246 + default: + return length + } + + case 246: + switch byteToLower(b) { + case 'i': + st = 247 + default: + return length + } + + case 247: + switch byteToLower(b) { + case 'q': + st = 248 + default: + return length + } + + case 248: + switch byteToLower(b) { + case 'u': + st = 249 + default: + return length + } + + case 249: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 250 + default: + return length + } + + case 251: + switch byteToLower(b) { + case 'i': + st = 252 + case 'o': + st = 261 + case 'u': + st = 269 + default: + return length + } + + case 252: + switch byteToLower(b) { + case 'd': + st = 253 + default: + return length + } + + case 253: + switch byteToLower(b) { + case 'g': + st = 254 + default: + return length + } + + case 254: + switch byteToLower(b) { + case 'e': + st = 255 + default: + return length + } + + case 255: + switch byteToLower(b) { + case 's': + st = 256 + default: + return length + } + + case 256: + switch byteToLower(b) { + case 't': + st = 257 + default: + return length + } + + case 257: + switch byteToLower(b) { + case 'o': + st = 258 + default: + return length + } + + case 258: + switch byteToLower(b) { + case 'n': + st = 259 + default: + return length + } + + case 259: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 260 + default: + return length + } + + case 261: + switch byteToLower(b) { + case 'k': + st = 262 + case 't': + st = 265 + default: + return length + } + + case 262: + switch byteToLower(b) { + case 'e': + st = 263 + default: + return length + } + + case 263: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 264 + default: + return length + } + + case 265: + switch byteToLower(b) { + case 'h': + st = 266 + default: + return length + } + + case 266: + switch byteToLower(b) { + case 'e': + st = 267 + default: + return length + } + + case 267: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 268 + default: + return length + } + + case 269: + switch byteToLower(b) { + case 's': + st = 270 + default: + return length + } + + case 270: + switch byteToLower(b) { + case 's': + st = 271 + default: + return length + } + + case 271: + switch byteToLower(b) { + case 'e': + st = 272 + default: + return length + } + + case 272: + switch byteToLower(b) { + case 'l': + st = 273 + default: + return length + } + + case 273: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 274 + default: + return length + } + + case 277: + switch byteToLower(b) { + case 'd': + st = 278 + case 'i': + st = 284 + case 's': + st = 290 + case 'z': + st = 296 + default: + return length + } + + case 278: + switch byteToLower(b) { + case 'a': + st = 279 + default: + return length + } + + case 279: + switch byteToLower(b) { + case 'p': + st = 280 + default: + return length + } + + case 280: + switch byteToLower(b) { + case 'e': + st = 281 + default: + return length + } + + case 281: + switch byteToLower(b) { + case 's': + st = 282 + default: + return length + } + + case 282: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 283 + default: + return length + } + + case 284: + switch byteToLower(b) { + case 'l': + st = 285 + default: + return length + } + + case 285: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 286 + default: + return length + } + + case 286: + switch byteToLower(b) { + case 'e': + st = 287 + default: + return length + } + + case 287: + switch byteToLower(b) { + case 'r': + st = 288 + default: + return length + } + + case 288: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 289 + default: + return length + } + + case 290: + switch byteToLower(b) { + case 'i': + st = 291 + default: + return length + } + + case 291: + switch byteToLower(b) { + case 'n': + st = 292 + default: + return length + } + + case 292: + switch byteToLower(b) { + case 'e': + st = 293 + default: + return length + } + + case 293: + switch byteToLower(b) { + case 's': + st = 294 + default: + return length + } + + case 294: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 295 + default: + return length + } + + case 296: + switch byteToLower(b) { + case 'z': + length = i + 1 + st = 297 + default: + return length + } + + case 301: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 302 + default: + return length + } + + case 303: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 304 + case 'b': + st = 366 + case 'c': + length = i + 1 + st = 368 + case 'd': + length = i + 1 + st = 369 + case 'e': + st = 370 + case 'f': + length = i + 1 + st = 378 + case 'g': + length = i + 1 + st = 381 + case 'h': + length = i + 1 + st = 382 + case 'i': + length = i + 1 + st = 409 + case 'k': + length = i + 1 + st = 417 + case 'l': + length = i + 1 + st = 418 + case 'm': + length = i + 1 + st = 443 + case 'n': + length = i + 1 + st = 444 + case 'o': + length = i + 1 + st = 445 + case 'r': + length = i + 1 + st = 532 + case 'u': + length = i + 1 + st = 552 + case 'v': + length = i + 1 + st = 561 + case 'w': + length = i + 1 + st = 562 + case 'x': + length = i + 1 + st = 563 + case 'y': + length = i + 1 + st = 564 + case 'z': + length = i + 1 + st = 570 + default: + return length + } + + case 304: + switch byteToLower(b) { + case 'b': + length = i + 1 + st = 305 + case 'f': + st = 306 + case 'l': + length = i + 1 + st = 308 + case 'm': + st = 309 + case 'n': + st = 314 + case 'p': + st = 328 + case 'r': + st = 338 + case 's': + st = 354 + case 't': + length = i + 1 + st = 360 + default: + return length + } + + case 306: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 307 + default: + return length + } + + case 309: + switch byteToLower(b) { + case 'e': + st = 310 + case 'p': + length = i + 1 + st = 313 + default: + return length + } + + case 310: + switch byteToLower(b) { + case 'r': + st = 311 + default: + return length + } + + case 311: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 312 + default: + return length + } + + case 314: + switch byteToLower(b) { + case 'c': + st = 315 + case 'o': + st = 326 + default: + return length + } + + case 315: + switch byteToLower(b) { + case 'e': + st = 316 + default: + return length + } + + case 316: + switch byteToLower(b) { + case 'r': + st = 317 + default: + return length + } + + case 317: + switch byteToLower(b) { + case 'r': + st = 318 + default: + return length + } + + case 318: + switch byteToLower(b) { + case 'e': + st = 319 + default: + return length + } + + case 319: + switch byteToLower(b) { + case 's': + st = 320 + default: + return length + } + + case 320: + switch byteToLower(b) { + case 'e': + st = 321 + default: + return length + } + + case 321: + switch byteToLower(b) { + case 'a': + st = 322 + default: + return length + } + + case 322: + switch byteToLower(b) { + case 'r': + st = 323 + default: + return length + } + + case 323: + switch byteToLower(b) { + case 'c': + st = 324 + default: + return length + } + + case 324: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 325 + default: + return length + } + + case 326: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 327 + default: + return length + } + + case 328: + switch byteToLower(b) { + case 'e': + st = 329 + case 'i': + st = 334 + default: + return length + } + + case 329: + switch byteToLower(b) { + case 't': + st = 330 + default: + return length + } + + case 330: + switch byteToLower(b) { + case 'o': + st = 331 + default: + return length + } + + case 331: + switch byteToLower(b) { + case 'w': + st = 332 + default: + return length + } + + case 332: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 333 + default: + return length + } + + case 334: + switch byteToLower(b) { + case 't': + st = 335 + default: + return length + } + + case 335: + switch byteToLower(b) { + case 'a': + st = 336 + default: + return length + } + + case 336: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 337 + default: + return length + } + + case 338: + switch byteToLower(b) { + case 'a': + st = 339 + case 'd': + st = 343 + case 'e': + length = i + 1 + st = 345 + case 's': + length = i + 1 + st = 349 + case 't': + st = 350 + default: + return length + } + + case 339: + switch byteToLower(b) { + case 'v': + st = 340 + default: + return length + } + + case 340: + switch byteToLower(b) { + case 'a': + st = 341 + default: + return length + } + + case 341: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 342 + default: + return length + } + + case 343: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 344 + default: + return length + } + + case 345: + switch byteToLower(b) { + case 'e': + st = 346 + default: + return length + } + + case 346: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 347 + default: + return length + } + + case 347: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 348 + default: + return length + } + + case 350: + switch byteToLower(b) { + case 'i': + st = 351 + default: + return length + } + + case 351: + switch byteToLower(b) { + case 'e': + st = 352 + default: + return length + } + + case 352: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 353 + default: + return length + } + + case 354: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 355 + case 'h': + length = i + 1 + st = 356 + case 'i': + st = 357 + default: + return length + } + + case 357: + switch byteToLower(b) { + case 'n': + st = 358 + default: + return length + } + + case 358: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 359 + default: + return length + } + + case 360: + switch byteToLower(b) { + case 'e': + st = 361 + default: + return length + } + + case 361: + switch byteToLower(b) { + case 'r': + st = 362 + default: + return length + } + + case 362: + switch byteToLower(b) { + case 'i': + st = 363 + default: + return length + } + + case 363: + switch byteToLower(b) { + case 'n': + st = 364 + default: + return length + } + + case 364: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 365 + default: + return length + } + + case 366: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 367 + default: + return length + } + + case 370: + switch byteToLower(b) { + case 'n': + st = 371 + case 'o': + length = i + 1 + st = 375 + case 'r': + st = 376 + default: + return length + } + + case 371: + switch byteToLower(b) { + case 't': + st = 372 + default: + return length + } + + case 372: + switch byteToLower(b) { + case 'e': + st = 373 + default: + return length + } + + case 373: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 374 + default: + return length + } + + case 376: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 377 + default: + return length + } + + case 378: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 379 + case 'd': + length = i + 1 + st = 380 + default: + return length + } + + case 382: + switch byteToLower(b) { + case 'a': + st = 383 + case 'e': + st = 389 + case 'l': + st = 392 + case 'r': + st = 395 + case 'u': + st = 405 + default: + return length + } + + case 383: + switch byteToLower(b) { + case 'n': + st = 384 + case 't': + length = i + 1 + st = 388 + default: + return length + } + + case 384: + switch byteToLower(b) { + case 'n': + st = 385 + default: + return length + } + + case 385: + switch byteToLower(b) { + case 'e': + st = 386 + default: + return length + } + + case 386: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 387 + default: + return length + } + + case 389: + switch byteToLower(b) { + case 'a': + st = 390 + default: + return length + } + + case 390: + switch byteToLower(b) { + case 'p': + length = i + 1 + st = 391 + default: + return length + } + + case 392: + switch byteToLower(b) { + case 'o': + st = 393 + default: + return length + } + + case 393: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 394 + default: + return length + } + + case 395: + switch byteToLower(b) { + case 'i': + st = 396 + case 'o': + st = 402 + default: + return length + } + + case 396: + switch byteToLower(b) { + case 's': + st = 397 + default: + return length + } + + case 397: + switch byteToLower(b) { + case 't': + st = 398 + default: + return length + } + + case 398: + switch byteToLower(b) { + case 'm': + st = 399 + default: + return length + } + + case 399: + switch byteToLower(b) { + case 'a': + st = 400 + default: + return length + } + + case 400: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 401 + default: + return length + } + + case 402: + switch byteToLower(b) { + case 'm': + st = 403 + default: + return length + } + + case 403: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 404 + default: + return length + } + + case 405: + switch byteToLower(b) { + case 'r': + st = 406 + default: + return length + } + + case 406: + switch byteToLower(b) { + case 'c': + st = 407 + default: + return length + } + + case 407: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 408 + default: + return length + } + + case 409: + switch byteToLower(b) { + case 's': + st = 410 + case 't': + st = 413 + default: + return length + } + + case 410: + switch byteToLower(b) { + case 'c': + st = 411 + default: + return length + } + + case 411: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 412 + default: + return length + } + + case 413: + switch byteToLower(b) { + case 'i': + st = 414 + case 'y': + length = i + 1 + st = 416 + default: + return length + } + + case 414: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 415 + default: + return length + } + + case 418: + switch byteToLower(b) { + case 'a': + st = 419 + case 'e': + st = 423 + case 'i': + st = 429 + case 'o': + st = 435 + case 'u': + st = 441 + default: + return length + } + + case 419: + switch byteToLower(b) { + case 'i': + st = 420 + default: + return length + } + + case 420: + switch byteToLower(b) { + case 'm': + st = 421 + default: + return length + } + + case 421: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 422 + default: + return length + } + + case 423: + switch byteToLower(b) { + case 'a': + st = 424 + default: + return length + } + + case 424: + switch byteToLower(b) { + case 'n': + st = 425 + default: + return length + } + + case 425: + switch byteToLower(b) { + case 'i': + st = 426 + default: + return length + } + + case 426: + switch byteToLower(b) { + case 'n': + st = 427 + default: + return length + } + + case 427: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 428 + default: + return length + } + + case 429: + switch byteToLower(b) { + case 'c': + st = 430 + case 'n': + st = 432 + default: + return length + } + + case 430: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 431 + default: + return length + } + + case 432: + switch byteToLower(b) { + case 'i': + st = 433 + default: + return length + } + + case 433: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 434 + default: + return length + } + + case 435: + switch byteToLower(b) { + case 't': + st = 436 + default: + return length + } + + case 436: + switch byteToLower(b) { + case 'h': + st = 437 + default: + return length + } + + case 437: + switch byteToLower(b) { + case 'i': + st = 438 + default: + return length + } + + case 438: + switch byteToLower(b) { + case 'n': + st = 439 + default: + return length + } + + case 439: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 440 + default: + return length + } + + case 441: + switch byteToLower(b) { + case 'b': + length = i + 1 + st = 442 + default: + return length + } + + case 445: + switch byteToLower(b) { + case 'a': + st = 446 + case 'd': + st = 449 + case 'f': + st = 452 + case 'l': + st = 456 + case 'm': + length = i + 1 + st = 465 + case 'n': + st = 480 + case 'o': + st = 507 + case 'r': + st = 514 + case 'u': + st = 519 + default: + return length + } + + case 446: + switch byteToLower(b) { + case 'c': + st = 447 + default: + return length + } + + case 447: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 448 + default: + return length + } + + case 449: + switch byteToLower(b) { + case 'e': + st = 450 + default: + return length + } + + case 450: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 451 + default: + return length + } + + case 452: + switch byteToLower(b) { + case 'f': + st = 453 + default: + return length + } + + case 453: + switch byteToLower(b) { + case 'e': + st = 454 + default: + return length + } + + case 454: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 455 + default: + return length + } + + case 456: + switch byteToLower(b) { + case 'l': + st = 457 + case 'o': + st = 461 + default: + return length + } + + case 457: + switch byteToLower(b) { + case 'e': + st = 458 + default: + return length + } + + case 458: + switch byteToLower(b) { + case 'g': + st = 459 + default: + return length + } + + case 459: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 460 + default: + return length + } + + case 461: + switch byteToLower(b) { + case 'g': + st = 462 + default: + return length + } + + case 462: + switch byteToLower(b) { + case 'n': + st = 463 + default: + return length + } + + case 463: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 464 + default: + return length + } + + case 465: + switch byteToLower(b) { + case 'm': + st = 466 + case 'p': + st = 472 + default: + return length + } + + case 466: + switch byteToLower(b) { + case 'u': + st = 467 + default: + return length + } + + case 467: + switch byteToLower(b) { + case 'n': + st = 468 + default: + return length + } + + case 468: + switch byteToLower(b) { + case 'i': + st = 469 + default: + return length + } + + case 469: + switch byteToLower(b) { + case 't': + st = 470 + default: + return length + } + + case 470: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 471 + default: + return length + } + + case 472: + switch byteToLower(b) { + case 'a': + st = 473 + case 'u': + st = 476 + default: + return length + } + + case 473: + switch byteToLower(b) { + case 'n': + st = 474 + default: + return length + } + + case 474: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 475 + default: + return length + } + + case 476: + switch byteToLower(b) { + case 't': + st = 477 + default: + return length + } + + case 477: + switch byteToLower(b) { + case 'e': + st = 478 + default: + return length + } + + case 478: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 479 + default: + return length + } + + case 480: + switch byteToLower(b) { + case 'd': + st = 481 + case 's': + st = 484 + case 't': + st = 499 + default: + return length + } + + case 481: + switch byteToLower(b) { + case 'o': + st = 482 + default: + return length + } + + case 482: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 483 + default: + return length + } + + case 484: + switch byteToLower(b) { + case 't': + st = 485 + case 'u': + st = 493 + default: + return length + } + + case 485: + switch byteToLower(b) { + case 'r': + st = 486 + default: + return length + } + + case 486: + switch byteToLower(b) { + case 'u': + st = 487 + default: + return length + } + + case 487: + switch byteToLower(b) { + case 'c': + st = 488 + default: + return length + } + + case 488: + switch byteToLower(b) { + case 't': + st = 489 + default: + return length + } + + case 489: + switch byteToLower(b) { + case 'i': + st = 490 + default: + return length + } + + case 490: + switch byteToLower(b) { + case 'o': + st = 491 + default: + return length + } + + case 491: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 492 + default: + return length + } + + case 493: + switch byteToLower(b) { + case 'l': + st = 494 + default: + return length + } + + case 494: + switch byteToLower(b) { + case 't': + st = 495 + default: + return length + } + + case 495: + switch byteToLower(b) { + case 'i': + st = 496 + default: + return length + } + + case 496: + switch byteToLower(b) { + case 'n': + st = 497 + default: + return length + } + + case 497: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 498 + default: + return length + } + + case 499: + switch byteToLower(b) { + case 'r': + st = 500 + default: + return length + } + + case 500: + switch byteToLower(b) { + case 'a': + st = 501 + default: + return length + } + + case 501: + switch byteToLower(b) { + case 'c': + st = 502 + default: + return length + } + + case 502: + switch byteToLower(b) { + case 't': + st = 503 + default: + return length + } + + case 503: + switch byteToLower(b) { + case 'o': + st = 504 + default: + return length + } + + case 504: + switch byteToLower(b) { + case 'r': + st = 505 + default: + return length + } + + case 505: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 506 + default: + return length + } + + case 507: + switch byteToLower(b) { + case 'k': + st = 508 + case 'l': + length = i + 1 + st = 512 + case 'p': + length = i + 1 + st = 513 + default: + return length + } + + case 508: + switch byteToLower(b) { + case 'i': + st = 509 + default: + return length + } + + case 509: + switch byteToLower(b) { + case 'n': + st = 510 + default: + return length + } + + case 510: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 511 + default: + return length + } + + case 514: + switch byteToLower(b) { + case 's': + st = 515 + default: + return length + } + + case 515: + switch byteToLower(b) { + case 'i': + st = 516 + default: + return length + } + + case 516: + switch byteToLower(b) { + case 'c': + st = 517 + default: + return length + } + + case 517: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 518 + default: + return length + } + + case 519: + switch byteToLower(b) { + case 'n': + st = 520 + case 'p': + st = 524 + case 'r': + st = 528 + default: + return length + } + + case 520: + switch byteToLower(b) { + case 't': + st = 521 + default: + return length + } + + case 521: + switch byteToLower(b) { + case 'r': + st = 522 + default: + return length + } + + case 522: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 523 + default: + return length + } + + case 524: + switch byteToLower(b) { + case 'o': + st = 525 + default: + return length + } + + case 525: + switch byteToLower(b) { + case 'n': + st = 526 + default: + return length + } + + case 526: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 527 + default: + return length + } + + case 528: + switch byteToLower(b) { + case 's': + st = 529 + default: + return length + } + + case 529: + switch byteToLower(b) { + case 'e': + st = 530 + default: + return length + } + + case 530: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 531 + default: + return length + } + + case 532: + switch byteToLower(b) { + case 'e': + st = 533 + case 'i': + st = 541 + case 's': + length = i + 1 + st = 546 + case 'u': + st = 547 + default: + return length + } + + case 533: + switch byteToLower(b) { + case 'd': + st = 534 + default: + return length + } + + case 534: + switch byteToLower(b) { + case 'i': + st = 535 + default: + return length + } + + case 535: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 536 + default: + return length + } + + case 536: + switch byteToLower(b) { + case 'c': + st = 537 + default: + return length + } + + case 537: + switch byteToLower(b) { + case 'a': + st = 538 + default: + return length + } + + case 538: + switch byteToLower(b) { + case 'r': + st = 539 + default: + return length + } + + case 539: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 540 + default: + return length + } + + case 541: + switch byteToLower(b) { + case 'c': + st = 542 + default: + return length + } + + case 542: + switch byteToLower(b) { + case 'k': + st = 543 + default: + return length + } + + case 543: + switch byteToLower(b) { + case 'e': + st = 544 + default: + return length + } + + case 544: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 545 + default: + return length + } + + case 547: + switch byteToLower(b) { + case 'i': + st = 548 + default: + return length + } + + case 548: + switch byteToLower(b) { + case 's': + st = 549 + default: + return length + } + + case 549: + switch byteToLower(b) { + case 'e': + st = 550 + default: + return length + } + + case 550: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 551 + default: + return length + } + + case 552: + switch byteToLower(b) { + case 'i': + st = 553 + default: + return length + } + + case 553: + switch byteToLower(b) { + case 's': + st = 554 + default: + return length + } + + case 554: + switch byteToLower(b) { + case 'i': + st = 555 + default: + return length + } + + case 555: + switch byteToLower(b) { + case 'n': + st = 556 + default: + return length + } + + case 556: + switch byteToLower(b) { + case 'e': + st = 557 + default: + return length + } + + case 557: + switch byteToLower(b) { + case 'l': + st = 558 + default: + return length + } + + case 558: + switch byteToLower(b) { + case 'l': + st = 559 + default: + return length + } + + case 559: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 560 + default: + return length + } + + case 564: + switch byteToLower(b) { + case 'm': + st = 565 + case 'o': + st = 568 + default: + return length + } + + case 565: + switch byteToLower(b) { + case 'r': + st = 566 + default: + return length + } + + case 566: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 567 + default: + return length + } + + case 568: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 569 + default: + return length + } + + case 571: + switch byteToLower(b) { + case 'a': + st = 572 + case 'c': + st = 589 + case 'e': + length = i + 1 + st = 592 + case 'i': + st = 624 + case 'j': + length = i + 1 + st = 651 + case 'k': + length = i + 1 + st = 652 + case 'm': + length = i + 1 + st = 653 + case 'n': + st = 654 + case 'o': + length = i + 1 + st = 656 + case 'u': + st = 677 + case 'v': + st = 682 + case 'z': + length = i + 1 + st = 685 + default: + return length + } + + case 572: + switch byteToLower(b) { + case 'b': + st = 573 + case 'd': + length = i + 1 + st = 576 + case 'n': + st = 577 + case 't': + st = 580 + case 'y': + length = i + 1 + st = 588 + default: + return length + } + + case 573: + switch byteToLower(b) { + case 'u': + st = 574 + default: + return length + } + + case 574: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 575 + default: + return length + } + + case 577: + switch byteToLower(b) { + case 'c': + st = 578 + default: + return length + } + + case 578: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 579 + default: + return length + } + + case 580: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 581 + case 'i': + st = 582 + case 's': + st = 585 + default: + return length + } + + case 582: + switch byteToLower(b) { + case 'n': + st = 583 + default: + return length + } + + case 583: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 584 + default: + return length + } + + case 585: + switch byteToLower(b) { + case 'u': + st = 586 + default: + return length + } + + case 586: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 587 + default: + return length + } + + case 589: + switch byteToLower(b) { + case 'l': + st = 590 + default: + return length + } + + case 590: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 591 + default: + return length + } + + case 592: + switch byteToLower(b) { + case 'a': + st = 593 + case 'g': + st = 596 + case 'l': + st = 600 + case 'm': + st = 606 + case 'n': + st = 612 + case 's': + st = 619 + case 'v': + length = i + 1 + st = 623 + default: + return length + } + + case 593: + switch byteToLower(b) { + case 'l': + st = 594 + default: + return length + } + + case 594: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 595 + default: + return length + } + + case 596: + switch byteToLower(b) { + case 'r': + st = 597 + default: + return length + } + + case 597: + switch byteToLower(b) { + case 'e': + st = 598 + default: + return length + } + + case 598: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 599 + default: + return length + } + + case 600: + switch byteToLower(b) { + case 'i': + st = 601 + default: + return length + } + + case 601: + switch byteToLower(b) { + case 'v': + st = 602 + default: + return length + } + + case 602: + switch byteToLower(b) { + case 'e': + st = 603 + default: + return length + } + + case 603: + switch byteToLower(b) { + case 'r': + st = 604 + default: + return length + } + + case 604: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 605 + default: + return length + } + + case 606: + switch byteToLower(b) { + case 'o': + st = 607 + default: + return length + } + + case 607: + switch byteToLower(b) { + case 'c': + st = 608 + default: + return length + } + + case 608: + switch byteToLower(b) { + case 'r': + st = 609 + default: + return length + } + + case 609: + switch byteToLower(b) { + case 'a': + st = 610 + default: + return length + } + + case 610: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 611 + default: + return length + } + + case 612: + switch byteToLower(b) { + case 't': + st = 613 + default: + return length + } + + case 613: + switch byteToLower(b) { + case 'a': + st = 614 + case 'i': + st = 616 + default: + return length + } + + case 614: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 615 + default: + return length + } + + case 616: + switch byteToLower(b) { + case 's': + st = 617 + default: + return length + } + + case 617: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 618 + default: + return length + } + + case 619: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 620 + default: + return length + } + + case 620: + switch byteToLower(b) { + case 'g': + st = 621 + default: + return length + } + + case 621: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 622 + default: + return length + } + + case 624: + switch byteToLower(b) { + case 'a': + st = 625 + case 'e': + st = 631 + case 'g': + st = 633 + case 'r': + st = 638 + case 's': + st = 645 + default: + return length + } + + case 625: + switch byteToLower(b) { + case 'm': + st = 626 + default: + return length + } + + case 626: + switch byteToLower(b) { + case 'o': + st = 627 + default: + return length + } + + case 627: + switch byteToLower(b) { + case 'n': + st = 628 + default: + return length + } + + case 628: + switch byteToLower(b) { + case 'd': + st = 629 + default: + return length + } + + case 629: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 630 + default: + return length + } + + case 631: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 632 + default: + return length + } + + case 633: + switch byteToLower(b) { + case 'i': + st = 634 + default: + return length + } + + case 634: + switch byteToLower(b) { + case 't': + st = 635 + default: + return length + } + + case 635: + switch byteToLower(b) { + case 'a': + st = 636 + default: + return length + } + + case 636: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 637 + default: + return length + } + + case 638: + switch byteToLower(b) { + case 'e': + st = 639 + default: + return length + } + + case 639: + switch byteToLower(b) { + case 'c': + st = 640 + default: + return length + } + + case 640: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 641 + default: + return length + } + + case 641: + switch byteToLower(b) { + case 'o': + st = 642 + default: + return length + } + + case 642: + switch byteToLower(b) { + case 'r': + st = 643 + default: + return length + } + + case 643: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 644 + default: + return length + } + + case 645: + switch byteToLower(b) { + case 'c': + st = 646 + default: + return length + } + + case 646: + switch byteToLower(b) { + case 'o': + st = 647 + default: + return length + } + + case 647: + switch byteToLower(b) { + case 'u': + st = 648 + default: + return length + } + + case 648: + switch byteToLower(b) { + case 'n': + st = 649 + default: + return length + } + + case 649: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 650 + default: + return length + } + + case 654: + switch byteToLower(b) { + case 'p': + length = i + 1 + st = 655 + default: + return length + } + + case 656: + switch byteToLower(b) { + case 'c': + st = 657 + case 'g': + length = i + 1 + st = 659 + case 'h': + st = 660 + case 'm': + st = 662 + case 'o': + st = 667 + case 'w': + st = 671 + default: + return length + } + + case 657: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 658 + default: + return length + } + + case 660: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 661 + default: + return length + } + + case 662: + switch byteToLower(b) { + case 'a': + st = 663 + default: + return length + } + + case 663: + switch byteToLower(b) { + case 'i': + st = 664 + default: + return length + } + + case 664: + switch byteToLower(b) { + case 'n': + st = 665 + default: + return length + } + + case 665: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 666 + default: + return length + } + + case 667: + switch byteToLower(b) { + case 's': + st = 668 + default: + return length + } + + case 668: + switch byteToLower(b) { + case 'a': + st = 669 + default: + return length + } + + case 669: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 670 + default: + return length + } + + case 671: + switch byteToLower(b) { + case 'n': + st = 672 + default: + return length + } + + case 672: + switch byteToLower(b) { + case 'l': + st = 673 + default: + return length + } + + case 673: + switch byteToLower(b) { + case 'o': + st = 674 + default: + return length + } + + case 674: + switch byteToLower(b) { + case 'a': + st = 675 + default: + return length + } + + case 675: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 676 + default: + return length + } + + case 677: + switch byteToLower(b) { + case 'r': + st = 678 + default: + return length + } + + case 678: + switch byteToLower(b) { + case 'b': + st = 679 + default: + return length + } + + case 679: + switch byteToLower(b) { + case 'a': + st = 680 + default: + return length + } + + case 680: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 681 + default: + return length + } + + case 682: + switch byteToLower(b) { + case 'a': + st = 683 + default: + return length + } + + case 683: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 684 + default: + return length + } + + case 686: + switch byteToLower(b) { + case 'a': + st = 687 + case 'c': + length = i + 1 + st = 692 + case 'd': + st = 693 + case 'e': + length = i + 1 + st = 701 + case 'g': + length = i + 1 + st = 702 + case 'm': + st = 703 + case 'n': + st = 711 + case 'p': + st = 734 + case 'q': + st = 738 + case 'r': + length = i + 1 + st = 746 + case 's': + length = i + 1 + st = 749 + case 't': + length = i + 1 + st = 755 + case 'u': + length = i + 1 + st = 756 + case 'v': + st = 766 + case 'x': + st = 776 + default: + return length + } + + case 687: + switch byteToLower(b) { + case 'r': + st = 688 + case 't': + length = i + 1 + st = 691 + default: + return length + } + + case 688: + switch byteToLower(b) { + case 't': + st = 689 + default: + return length + } + + case 689: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 690 + default: + return length + } + + case 693: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 694 + default: + return length + } + + case 694: + switch byteToLower(b) { + case 'c': + st = 695 + default: + return length + } + + case 695: + switch byteToLower(b) { + case 'a': + st = 696 + default: + return length + } + + case 696: + switch byteToLower(b) { + case 't': + st = 697 + default: + return length + } + + case 697: + switch byteToLower(b) { + case 'i': + st = 698 + default: + return length + } + + case 698: + switch byteToLower(b) { + case 'o': + st = 699 + default: + return length + } + + case 699: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 700 + default: + return length + } + + case 703: + switch byteToLower(b) { + case 'a': + st = 704 + case 'e': + st = 707 + default: + return length + } + + case 704: + switch byteToLower(b) { + case 'i': + st = 705 + default: + return length + } + + case 705: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 706 + default: + return length + } + + case 707: + switch byteToLower(b) { + case 'r': + st = 708 + default: + return length + } + + case 708: + switch byteToLower(b) { + case 'c': + st = 709 + default: + return length + } + + case 709: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 710 + default: + return length + } + + case 711: + switch byteToLower(b) { + case 'e': + st = 712 + case 'g': + st = 716 + case 't': + st = 725 + default: + return length + } + + case 712: + switch byteToLower(b) { + case 'r': + st = 713 + default: + return length + } + + case 713: + switch byteToLower(b) { + case 'g': + st = 714 + default: + return length + } + + case 714: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 715 + default: + return length + } + + case 716: + switch byteToLower(b) { + case 'i': + st = 717 + default: + return length + } + + case 717: + switch byteToLower(b) { + case 'n': + st = 718 + default: + return length + } + + case 718: + switch byteToLower(b) { + case 'e': + st = 719 + default: + return length + } + + case 719: + switch byteToLower(b) { + case 'e': + st = 720 + default: + return length + } + + case 720: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 721 + default: + return length + } + + case 721: + switch byteToLower(b) { + case 'i': + st = 722 + default: + return length + } + + case 722: + switch byteToLower(b) { + case 'n': + st = 723 + default: + return length + } + + case 723: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 724 + default: + return length + } + + case 725: + switch byteToLower(b) { + case 'e': + st = 726 + default: + return length + } + + case 726: + switch byteToLower(b) { + case 'r': + st = 727 + default: + return length + } + + case 727: + switch byteToLower(b) { + case 'p': + st = 728 + default: + return length + } + + case 728: + switch byteToLower(b) { + case 'r': + st = 729 + default: + return length + } + + case 729: + switch byteToLower(b) { + case 'i': + st = 730 + default: + return length + } + + case 730: + switch byteToLower(b) { + case 's': + st = 731 + default: + return length + } + + case 731: + switch byteToLower(b) { + case 'e': + st = 732 + default: + return length + } + + case 732: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 733 + default: + return length + } + + case 734: + switch byteToLower(b) { + case 's': + st = 735 + default: + return length + } + + case 735: + switch byteToLower(b) { + case 'o': + st = 736 + default: + return length + } + + case 736: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 737 + default: + return length + } + + case 738: + switch byteToLower(b) { + case 'u': + st = 739 + default: + return length + } + + case 739: + switch byteToLower(b) { + case 'i': + st = 740 + default: + return length + } + + case 740: + switch byteToLower(b) { + case 'p': + st = 741 + default: + return length + } + + case 741: + switch byteToLower(b) { + case 'm': + st = 742 + default: + return length + } + + case 742: + switch byteToLower(b) { + case 'e': + st = 743 + default: + return length + } + + case 743: + switch byteToLower(b) { + case 'n': + st = 744 + default: + return length + } + + case 744: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 745 + default: + return length + } + + case 746: + switch byteToLower(b) { + case 'n': + st = 747 + default: + return length + } + + case 747: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 748 + default: + return length + } + + case 749: + switch byteToLower(b) { + case 'q': + length = i + 1 + st = 750 + case 't': + st = 751 + default: + return length + } + + case 751: + switch byteToLower(b) { + case 'a': + st = 752 + default: + return length + } + + case 752: + switch byteToLower(b) { + case 't': + st = 753 + default: + return length + } + + case 753: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 754 + default: + return length + } + + case 756: + switch byteToLower(b) { + case 'r': + st = 757 + case 's': + length = i + 1 + st = 765 + default: + return length + } + + case 757: + switch byteToLower(b) { + case 'o': + st = 758 + default: + return length + } + + case 758: + switch byteToLower(b) { + case 'v': + st = 759 + default: + return length + } + + case 759: + switch byteToLower(b) { + case 'i': + st = 760 + default: + return length + } + + case 760: + switch byteToLower(b) { + case 's': + st = 761 + default: + return length + } + + case 761: + switch byteToLower(b) { + case 'i': + st = 762 + default: + return length + } + + case 762: + switch byteToLower(b) { + case 'o': + st = 763 + default: + return length + } + + case 763: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 764 + default: + return length + } + + case 766: + switch byteToLower(b) { + case 'e': + st = 767 + default: + return length + } + + case 767: + switch byteToLower(b) { + case 'n': + st = 768 + case 'r': + st = 771 + default: + return length + } + + case 768: + switch byteToLower(b) { + case 't': + st = 769 + default: + return length + } + + case 769: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 770 + default: + return length + } + + case 771: + switch byteToLower(b) { + case 'b': + st = 772 + default: + return length + } + + case 772: + switch byteToLower(b) { + case 'a': + st = 773 + default: + return length + } + + case 773: + switch byteToLower(b) { + case 'n': + st = 774 + default: + return length + } + + case 774: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 775 + default: + return length + } + + case 776: + switch byteToLower(b) { + case 'c': + st = 777 + case 'i': + st = 783 + case 'p': + st = 785 + default: + return length + } + + case 777: + switch byteToLower(b) { + case 'h': + st = 778 + default: + return length + } + + case 778: + switch byteToLower(b) { + case 'a': + st = 779 + default: + return length + } + + case 779: + switch byteToLower(b) { + case 'n': + st = 780 + default: + return length + } + + case 780: + switch byteToLower(b) { + case 'g': + st = 781 + default: + return length + } + + case 781: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 782 + default: + return length + } + + case 783: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 784 + default: + return length + } + + case 785: + switch byteToLower(b) { + case 'e': + st = 786 + case 'o': + st = 789 + case 'r': + st = 793 + default: + return length + } + + case 786: + switch byteToLower(b) { + case 'r': + st = 787 + default: + return length + } + + case 787: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 788 + default: + return length + } + + case 789: + switch byteToLower(b) { + case 's': + st = 790 + default: + return length + } + + case 790: + switch byteToLower(b) { + case 'e': + st = 791 + default: + return length + } + + case 791: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 792 + default: + return length + } + + case 793: + switch byteToLower(b) { + case 'e': + st = 794 + default: + return length + } + + case 794: + switch byteToLower(b) { + case 's': + st = 795 + default: + return length + } + + case 795: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 796 + default: + return length + } + + case 797: + switch byteToLower(b) { + case 'a': + st = 798 + case 'e': + st = 812 + case 'i': + length = i + 1 + st = 819 + case 'j': + length = i + 1 + st = 846 + case 'k': + length = i + 1 + st = 847 + case 'l': + st = 848 + case 'm': + length = i + 1 + st = 870 + case 'o': + length = i + 1 + st = 871 + case 'r': + length = i + 1 + st = 893 + case 'u': + st = 900 + case 'y': + st = 914 + default: + return length + } + + case 798: + switch byteToLower(b) { + case 'i': + st = 799 + case 'n': + length = i + 1 + st = 803 + case 'r': + st = 805 + case 's': + st = 807 + default: + return length + } + + case 799: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 800 + case 't': + st = 801 + default: + return length + } + + case 801: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 802 + default: + return length + } + + case 803: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 804 + default: + return length + } + + case 805: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 806 + default: + return length + } + + case 807: + switch byteToLower(b) { + case 'h': + st = 808 + default: + return length + } + + case 808: + switch byteToLower(b) { + case 'i': + st = 809 + default: + return length + } + + case 809: + switch byteToLower(b) { + case 'o': + st = 810 + default: + return length + } + + case 810: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 811 + default: + return length + } + + case 812: + switch byteToLower(b) { + case 'e': + st = 813 + default: + return length + } + + case 813: + switch byteToLower(b) { + case 'd': + st = 814 + default: + return length + } + + case 814: + switch byteToLower(b) { + case 'b': + st = 815 + default: + return length + } + + case 815: + switch byteToLower(b) { + case 'a': + st = 816 + default: + return length + } + + case 816: + switch byteToLower(b) { + case 'c': + st = 817 + default: + return length + } + + case 817: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 818 + default: + return length + } + + case 819: + switch byteToLower(b) { + case 'l': + st = 820 + case 'n': + st = 822 + case 'r': + st = 830 + case 's': + st = 836 + case 't': + length = i + 1 + st = 841 + default: + return length + } + + case 820: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 821 + default: + return length + } + + case 822: + switch byteToLower(b) { + case 'a': + st = 823 + default: + return length + } + + case 823: + switch byteToLower(b) { + case 'n': + st = 824 + default: + return length + } + + case 824: + switch byteToLower(b) { + case 'c': + st = 825 + default: + return length + } + + case 825: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 826 + case 'i': + st = 827 + default: + return length + } + + case 827: + switch byteToLower(b) { + case 'a': + st = 828 + default: + return length + } + + case 828: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 829 + default: + return length + } + + case 830: + switch byteToLower(b) { + case 'm': + st = 831 + default: + return length + } + + case 831: + switch byteToLower(b) { + case 'd': + st = 832 + default: + return length + } + + case 832: + switch byteToLower(b) { + case 'a': + st = 833 + default: + return length + } + + case 833: + switch byteToLower(b) { + case 'l': + st = 834 + default: + return length + } + + case 834: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 835 + default: + return length + } + + case 836: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 837 + default: + return length + } + + case 837: + switch byteToLower(b) { + case 'i': + st = 838 + default: + return length + } + + case 838: + switch byteToLower(b) { + case 'n': + st = 839 + default: + return length + } + + case 839: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 840 + default: + return length + } + + case 841: + switch byteToLower(b) { + case 'n': + st = 842 + default: + return length + } + + case 842: + switch byteToLower(b) { + case 'e': + st = 843 + default: + return length + } + + case 843: + switch byteToLower(b) { + case 's': + st = 844 + default: + return length + } + + case 844: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 845 + default: + return length + } + + case 848: + switch byteToLower(b) { + case 'i': + st = 849 + case 'o': + st = 854 + case 's': + st = 863 + case 'y': + length = i + 1 + st = 869 + default: + return length + } + + case 849: + switch byteToLower(b) { + case 'g': + st = 850 + default: + return length + } + + case 850: + switch byteToLower(b) { + case 'h': + st = 851 + default: + return length + } + + case 851: + switch byteToLower(b) { + case 't': + st = 852 + default: + return length + } + + case 852: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 853 + default: + return length + } + + case 854: + switch byteToLower(b) { + case 'r': + st = 855 + case 'w': + st = 859 + default: + return length + } + + case 855: + switch byteToLower(b) { + case 'i': + st = 856 + default: + return length + } + + case 856: + switch byteToLower(b) { + case 's': + st = 857 + default: + return length + } + + case 857: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 858 + default: + return length + } + + case 859: + switch byteToLower(b) { + case 'e': + st = 860 + default: + return length + } + + case 860: + switch byteToLower(b) { + case 'r': + st = 861 + default: + return length + } + + case 861: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 862 + default: + return length + } + + case 863: + switch byteToLower(b) { + case 'm': + st = 864 + default: + return length + } + + case 864: + switch byteToLower(b) { + case 'i': + st = 865 + default: + return length + } + + case 865: + switch byteToLower(b) { + case 'd': + st = 866 + default: + return length + } + + case 866: + switch byteToLower(b) { + case 't': + st = 867 + default: + return length + } + + case 867: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 868 + default: + return length + } + + case 871: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 872 + case 'r': + st = 878 + case 'u': + st = 885 + default: + return length + } + + case 872: + switch byteToLower(b) { + case 't': + st = 873 + default: + return length + } + + case 873: + switch byteToLower(b) { + case 'b': + st = 874 + default: + return length + } + + case 874: + switch byteToLower(b) { + case 'a': + st = 875 + default: + return length + } + + case 875: + switch byteToLower(b) { + case 'l': + st = 876 + default: + return length + } + + case 876: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 877 + default: + return length + } + + case 878: + switch byteToLower(b) { + case 'e': + st = 879 + case 's': + st = 881 + default: + return length + } + + case 879: + switch byteToLower(b) { + case 'x': + length = i + 1 + st = 880 + default: + return length + } + + case 881: + switch byteToLower(b) { + case 'a': + st = 882 + default: + return length + } + + case 882: + switch byteToLower(b) { + case 'l': + st = 883 + default: + return length + } + + case 883: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 884 + default: + return length + } + + case 885: + switch byteToLower(b) { + case 'n': + st = 886 + default: + return length + } + + case 886: + switch byteToLower(b) { + case 'd': + st = 887 + default: + return length + } + + case 887: + switch byteToLower(b) { + case 'a': + st = 888 + default: + return length + } + + case 888: + switch byteToLower(b) { + case 't': + st = 889 + default: + return length + } + + case 889: + switch byteToLower(b) { + case 'i': + st = 890 + default: + return length + } + + case 890: + switch byteToLower(b) { + case 'o': + st = 891 + default: + return length + } + + case 891: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 892 + default: + return length + } + + case 893: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 894 + case 'o': + st = 895 + default: + return length + } + + case 895: + switch byteToLower(b) { + case 'g': + st = 896 + default: + return length + } + + case 896: + switch byteToLower(b) { + case 'a': + st = 897 + default: + return length + } + + case 897: + switch byteToLower(b) { + case 'n': + st = 898 + default: + return length + } + + case 898: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 899 + default: + return length + } + + case 900: + switch byteToLower(b) { + case 'n': + st = 901 + case 'r': + st = 903 + case 't': + st = 910 + default: + return length + } + + case 901: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 902 + default: + return length + } + + case 903: + switch byteToLower(b) { + case 'n': + st = 904 + default: + return length + } + + case 904: + switch byteToLower(b) { + case 'i': + st = 905 + default: + return length + } + + case 905: + switch byteToLower(b) { + case 't': + st = 906 + default: + return length + } + + case 906: + switch byteToLower(b) { + case 'u': + st = 907 + default: + return length + } + + case 907: + switch byteToLower(b) { + case 'r': + st = 908 + default: + return length + } + + case 908: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 909 + default: + return length + } + + case 910: + switch byteToLower(b) { + case 'b': + st = 911 + default: + return length + } + + case 911: + switch byteToLower(b) { + case 'o': + st = 912 + default: + return length + } + + case 912: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 913 + default: + return length + } + + case 914: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 915 + default: + return length + } + + case 916: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 917 + case 'b': + length = i + 1 + st = 927 + case 'd': + length = i + 1 + st = 930 + case 'e': + length = i + 1 + st = 932 + case 'f': + length = i + 1 + st = 935 + case 'g': + length = i + 1 + st = 936 + case 'h': + length = i + 1 + st = 939 + case 'i': + length = i + 1 + st = 940 + case 'l': + length = i + 1 + st = 947 + case 'm': + length = i + 1 + st = 957 + case 'n': + length = i + 1 + st = 963 + case 'o': + st = 965 + case 'p': + length = i + 1 + st = 980 + case 'q': + length = i + 1 + st = 981 + case 'r': + length = i + 1 + st = 982 + case 's': + length = i + 1 + st = 998 + case 't': + length = i + 1 + st = 999 + case 'u': + length = i + 1 + st = 1000 + case 'w': + length = i + 1 + st = 1012 + case 'y': + length = i + 1 + st = 1013 + default: + return length + } + + case 917: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 918 + case 'r': + st = 923 + default: + return length + } + + case 918: + switch byteToLower(b) { + case 'l': + st = 919 + default: + return length + } + + case 919: + switch byteToLower(b) { + case 'e': + st = 920 + default: + return length + } + + case 920: + switch byteToLower(b) { + case 'r': + st = 921 + default: + return length + } + + case 921: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 922 + default: + return length + } + + case 923: + switch byteToLower(b) { + case 'd': + st = 924 + default: + return length + } + + case 924: + switch byteToLower(b) { + case 'e': + st = 925 + default: + return length + } + + case 925: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 926 + default: + return length + } + + case 927: + switch byteToLower(b) { + case 'i': + st = 928 + default: + return length + } + + case 928: + switch byteToLower(b) { + case 'z': + length = i + 1 + st = 929 + default: + return length + } + + case 930: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 931 + default: + return length + } + + case 932: + switch byteToLower(b) { + case 'n': + st = 933 + default: + return length + } + + case 933: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 934 + default: + return length + } + + case 936: + switch byteToLower(b) { + case 'e': + st = 937 + default: + return length + } + + case 937: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 938 + default: + return length + } + + case 940: + switch byteToLower(b) { + case 'f': + st = 941 + case 'v': + st = 944 + default: + return length + } + + case 941: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 942 + default: + return length + } + + case 942: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 943 + default: + return length + } + + case 944: + switch byteToLower(b) { + case 'e': + st = 945 + default: + return length + } + + case 945: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 946 + default: + return length + } + + case 947: + switch byteToLower(b) { + case 'a': + st = 948 + case 'e': + length = i + 1 + st = 951 + case 'o': + st = 952 + default: + return length + } + + case 948: + switch byteToLower(b) { + case 's': + st = 949 + default: + return length + } + + case 949: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 950 + default: + return length + } + + case 952: + switch byteToLower(b) { + case 'b': + st = 953 + default: + return length + } + + case 953: + switch byteToLower(b) { + case 'a': + st = 954 + case 'o': + length = i + 1 + st = 956 + default: + return length + } + + case 954: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 955 + default: + return length + } + + case 957: + switch byteToLower(b) { + case 'a': + st = 958 + case 'o': + length = i + 1 + st = 961 + case 'x': + length = i + 1 + st = 962 + default: + return length + } + + case 958: + switch byteToLower(b) { + case 'i': + st = 959 + default: + return length + } + + case 959: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 960 + default: + return length + } + + case 963: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 964 + default: + return length + } + + case 965: + switch byteToLower(b) { + case 'l': + st = 966 + case 'o': + length = i + 1 + st = 974 + case 'p': + length = i + 1 + st = 978 + case 'v': + length = i + 1 + st = 979 + default: + return length + } + + case 966: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 967 + case 'f': + length = i + 1 + st = 973 + default: + return length + } + + case 967: + switch byteToLower(b) { + case 'p': + st = 968 + default: + return length + } + + case 968: + switch byteToLower(b) { + case 'o': + st = 969 + default: + return length + } + + case 969: + switch byteToLower(b) { + case 'i': + st = 970 + default: + return length + } + + case 970: + switch byteToLower(b) { + case 'n': + st = 971 + default: + return length + } + + case 971: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 972 + default: + return length + } + + case 974: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 975 + default: + return length + } + + case 975: + switch byteToLower(b) { + case 'l': + st = 976 + default: + return length + } + + case 976: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 977 + default: + return length + } + + case 982: + switch byteToLower(b) { + case 'a': + st = 983 + case 'e': + st = 992 + case 'i': + st = 995 + default: + return length + } + + case 983: + switch byteToLower(b) { + case 'p': + st = 984 + case 't': + st = 989 + default: + return length + } + + case 984: + switch byteToLower(b) { + case 'h': + st = 985 + default: + return length + } + + case 985: + switch byteToLower(b) { + case 'i': + st = 986 + default: + return length + } + + case 986: + switch byteToLower(b) { + case 'c': + st = 987 + default: + return length + } + + case 987: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 988 + default: + return length + } + + case 989: + switch byteToLower(b) { + case 'i': + st = 990 + default: + return length + } + + case 990: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 991 + default: + return length + } + + case 992: + switch byteToLower(b) { + case 'e': + st = 993 + default: + return length + } + + case 993: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 994 + default: + return length + } + + case 995: + switch byteToLower(b) { + case 'p': + st = 996 + default: + return length + } + + case 996: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 997 + default: + return length + } + + case 1000: + switch byteToLower(b) { + case 'g': + st = 1001 + case 'i': + st = 1003 + case 'r': + st = 1010 + default: + return length + } + + case 1001: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1002 + default: + return length + } + + case 1003: + switch byteToLower(b) { + case 'd': + st = 1004 + case 't': + st = 1006 + default: + return length + } + + case 1004: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1005 + default: + return length + } + + case 1006: + switch byteToLower(b) { + case 'a': + st = 1007 + default: + return length + } + + case 1007: + switch byteToLower(b) { + case 'r': + st = 1008 + default: + return length + } + + case 1008: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1009 + default: + return length + } + + case 1010: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 1011 + default: + return length + } + + case 1014: + switch byteToLower(b) { + case 'a': + st = 1015 + case 'e': + st = 1028 + case 'i': + st = 1044 + case 'k': + length = i + 1 + st = 1055 + case 'm': + length = i + 1 + st = 1056 + case 'n': + length = i + 1 + st = 1057 + case 'o': + st = 1058 + case 'r': + length = i + 1 + st = 1096 + case 't': + length = i + 1 + st = 1097 + case 'u': + length = i + 1 + st = 1098 + default: + return length + } + + case 1015: + switch byteToLower(b) { + case 'm': + st = 1016 + case 'n': + st = 1021 + case 'u': + st = 1026 + default: + return length + } + + case 1016: + switch byteToLower(b) { + case 'b': + st = 1017 + default: + return length + } + + case 1017: + switch byteToLower(b) { + case 'u': + st = 1018 + default: + return length + } + + case 1018: + switch byteToLower(b) { + case 'r': + st = 1019 + default: + return length + } + + case 1019: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1020 + default: + return length + } + + case 1021: + switch byteToLower(b) { + case 'g': + st = 1022 + default: + return length + } + + case 1022: + switch byteToLower(b) { + case 'o': + st = 1023 + default: + return length + } + + case 1023: + switch byteToLower(b) { + case 'u': + st = 1024 + default: + return length + } + + case 1024: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1025 + default: + return length + } + + case 1026: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1027 + default: + return length + } + + case 1028: + switch byteToLower(b) { + case 'a': + st = 1029 + case 'l': + st = 1037 + case 'r': + st = 1039 + default: + return length + } + + case 1029: + switch byteToLower(b) { + case 'l': + st = 1030 + default: + return length + } + + case 1030: + switch byteToLower(b) { + case 't': + st = 1031 + default: + return length + } + + case 1031: + switch byteToLower(b) { + case 'h': + st = 1032 + default: + return length + } + + case 1032: + switch byteToLower(b) { + case 'c': + st = 1033 + default: + return length + } + + case 1033: + switch byteToLower(b) { + case 'a': + st = 1034 + default: + return length + } + + case 1034: + switch byteToLower(b) { + case 'r': + st = 1035 + default: + return length + } + + case 1035: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1036 + default: + return length + } + + case 1037: + switch byteToLower(b) { + case 'p': + length = i + 1 + st = 1038 + default: + return length + } + + case 1039: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1040 + case 'm': + st = 1041 + default: + return length + } + + case 1041: + switch byteToLower(b) { + case 'e': + st = 1042 + default: + return length + } + + case 1042: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1043 + default: + return length + } + + case 1044: + switch byteToLower(b) { + case 'p': + st = 1045 + case 't': + st = 1049 + case 'v': + length = i + 1 + st = 1054 + default: + return length + } + + case 1045: + switch byteToLower(b) { + case 'h': + st = 1046 + default: + return length + } + + case 1046: + switch byteToLower(b) { + case 'o': + st = 1047 + default: + return length + } + + case 1047: + switch byteToLower(b) { + case 'p': + length = i + 1 + st = 1048 + default: + return length + } + + case 1049: + switch byteToLower(b) { + case 'a': + st = 1050 + default: + return length + } + + case 1050: + switch byteToLower(b) { + case 'c': + st = 1051 + default: + return length + } + + case 1051: + switch byteToLower(b) { + case 'h': + st = 1052 + default: + return length + } + + case 1052: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1053 + default: + return length + } + + case 1058: + switch byteToLower(b) { + case 'c': + st = 1059 + case 'l': + st = 1063 + case 'm': + st = 1073 + case 'n': + st = 1081 + case 'r': + st = 1084 + case 's': + st = 1087 + case 'u': + st = 1092 + case 'w': + length = i + 1 + st = 1095 + default: + return length + } + + case 1059: + switch byteToLower(b) { + case 'k': + st = 1060 + default: + return length + } + + case 1060: + switch byteToLower(b) { + case 'e': + st = 1061 + default: + return length + } + + case 1061: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1062 + default: + return length + } + + case 1063: + switch byteToLower(b) { + case 'd': + st = 1064 + case 'i': + st = 1069 + default: + return length + } + + case 1064: + switch byteToLower(b) { + case 'i': + st = 1065 + default: + return length + } + + case 1065: + switch byteToLower(b) { + case 'n': + st = 1066 + default: + return length + } + + case 1066: + switch byteToLower(b) { + case 'g': + st = 1067 + default: + return length + } + + case 1067: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1068 + default: + return length + } + + case 1069: + switch byteToLower(b) { + case 'd': + st = 1070 + default: + return length + } + + case 1070: + switch byteToLower(b) { + case 'a': + st = 1071 + default: + return length + } + + case 1071: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1072 + default: + return length + } + + case 1073: + switch byteToLower(b) { + case 'e': + st = 1074 + default: + return length + } + + case 1074: + switch byteToLower(b) { + case 'd': + st = 1075 + case 's': + length = i + 1 + st = 1080 + default: + return length + } + + case 1075: + switch byteToLower(b) { + case 'e': + st = 1076 + default: + return length + } + + case 1076: + switch byteToLower(b) { + case 'p': + st = 1077 + default: + return length + } + + case 1077: + switch byteToLower(b) { + case 'o': + st = 1078 + default: + return length + } + + case 1078: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1079 + default: + return length + } + + case 1081: + switch byteToLower(b) { + case 'd': + st = 1082 + default: + return length + } + + case 1082: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1083 + default: + return length + } + + case 1084: + switch byteToLower(b) { + case 's': + st = 1085 + default: + return length + } + + case 1085: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1086 + default: + return length + } + + case 1087: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1088 + default: + return length + } + + case 1088: + switch byteToLower(b) { + case 'i': + st = 1089 + default: + return length + } + + case 1089: + switch byteToLower(b) { + case 'n': + st = 1090 + default: + return length + } + + case 1090: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1091 + default: + return length + } + + case 1092: + switch byteToLower(b) { + case 's': + st = 1093 + default: + return length + } + + case 1093: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1094 + default: + return length + } + + case 1099: + switch byteToLower(b) { + case '2': + st = 1100 + case 'b': + st = 1102 + case 'c': + st = 1104 + case 'd': + length = i + 1 + st = 1108 + case 'e': + length = i + 1 + st = 1109 + case 'f': + st = 1110 + case 'l': + length = i + 1 + st = 1112 + case 'm': + length = i + 1 + st = 1113 + case 'n': + length = i + 1 + st = 1122 + case 'o': + length = i + 1 + st = 1170 + case 'q': + length = i + 1 + st = 1171 + case 'r': + length = i + 1 + st = 1172 + case 's': + length = i + 1 + st = 1176 + case 't': + length = i + 1 + st = 1177 + case 'w': + st = 1178 + default: + return length + } + + case 1100: + switch byteToLower(b) { + case 'p': + length = i + 1 + st = 1101 + default: + return length + } + + case 1102: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 1103 + default: + return length + } + + case 1104: + switch byteToLower(b) { + case 'b': + st = 1105 + case 'u': + length = i + 1 + st = 1107 + default: + return length + } + + case 1105: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1106 + default: + return length + } + + case 1110: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 1111 + default: + return length + } + + case 1113: + switch byteToLower(b) { + case 'm': + st = 1114 + default: + return length + } + + case 1114: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1115 + default: + return length + } + + case 1115: + switch byteToLower(b) { + case 'b': + st = 1116 + default: + return length + } + + case 1116: + switch byteToLower(b) { + case 'i': + st = 1117 + default: + return length + } + + case 1117: + switch byteToLower(b) { + case 'l': + st = 1118 + default: + return length + } + + case 1118: + switch byteToLower(b) { + case 'i': + st = 1119 + default: + return length + } + + case 1119: + switch byteToLower(b) { + case 'e': + st = 1120 + default: + return length + } + + case 1120: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1121 + default: + return length + } + + case 1122: + switch byteToLower(b) { + case 'd': + st = 1123 + case 'f': + st = 1131 + case 'g': + length = i + 1 + st = 1138 + case 'k': + length = i + 1 + st = 1139 + case 's': + st = 1140 + case 't': + length = i + 1 + st = 1150 + case 'v': + st = 1161 + default: + return length + } + + case 1123: + switch byteToLower(b) { + case 'u': + st = 1124 + default: + return length + } + + case 1124: + switch byteToLower(b) { + case 's': + st = 1125 + default: + return length + } + + case 1125: + switch byteToLower(b) { + case 't': + st = 1126 + default: + return length + } + + case 1126: + switch byteToLower(b) { + case 'r': + st = 1127 + default: + return length + } + + case 1127: + switch byteToLower(b) { + case 'i': + st = 1128 + default: + return length + } + + case 1128: + switch byteToLower(b) { + case 'e': + st = 1129 + default: + return length + } + + case 1129: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1130 + default: + return length + } + + case 1131: + switch byteToLower(b) { + case 'i': + st = 1132 + case 'o': + length = i + 1 + st = 1137 + default: + return length + } + + case 1132: + switch byteToLower(b) { + case 'n': + st = 1133 + default: + return length + } + + case 1133: + switch byteToLower(b) { + case 'i': + st = 1134 + default: + return length + } + + case 1134: + switch byteToLower(b) { + case 't': + st = 1135 + default: + return length + } + + case 1135: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1136 + default: + return length + } + + case 1140: + switch byteToLower(b) { + case 't': + st = 1141 + case 'u': + st = 1147 + default: + return length + } + + case 1141: + switch byteToLower(b) { + case 'i': + st = 1142 + default: + return length + } + + case 1142: + switch byteToLower(b) { + case 't': + st = 1143 + default: + return length + } + + case 1143: + switch byteToLower(b) { + case 'u': + st = 1144 + default: + return length + } + + case 1144: + switch byteToLower(b) { + case 't': + st = 1145 + default: + return length + } + + case 1145: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1146 + default: + return length + } + + case 1147: + switch byteToLower(b) { + case 'r': + st = 1148 + default: + return length + } + + case 1148: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1149 + default: + return length + } + + case 1150: + switch byteToLower(b) { + case 'e': + st = 1151 + default: + return length + } + + case 1151: + switch byteToLower(b) { + case 'r': + st = 1152 + default: + return length + } + + case 1152: + switch byteToLower(b) { + case 'n': + st = 1153 + default: + return length + } + + case 1153: + switch byteToLower(b) { + case 'a': + st = 1154 + default: + return length + } + + case 1154: + switch byteToLower(b) { + case 't': + st = 1155 + default: + return length + } + + case 1155: + switch byteToLower(b) { + case 'i': + st = 1156 + default: + return length + } + + case 1156: + switch byteToLower(b) { + case 'o': + st = 1157 + default: + return length + } + + case 1157: + switch byteToLower(b) { + case 'n': + st = 1158 + default: + return length + } + + case 1158: + switch byteToLower(b) { + case 'a': + st = 1159 + default: + return length + } + + case 1159: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1160 + default: + return length + } + + case 1161: + switch byteToLower(b) { + case 'e': + st = 1162 + default: + return length + } + + case 1162: + switch byteToLower(b) { + case 's': + st = 1163 + default: + return length + } + + case 1163: + switch byteToLower(b) { + case 't': + st = 1164 + default: + return length + } + + case 1164: + switch byteToLower(b) { + case 'm': + st = 1165 + default: + return length + } + + case 1165: + switch byteToLower(b) { + case 'e': + st = 1166 + default: + return length + } + + case 1166: + switch byteToLower(b) { + case 'n': + st = 1167 + default: + return length + } + + case 1167: + switch byteToLower(b) { + case 't': + st = 1168 + default: + return length + } + + case 1168: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1169 + default: + return length + } + + case 1172: + switch byteToLower(b) { + case 'i': + st = 1173 + default: + return length + } + + case 1173: + switch byteToLower(b) { + case 's': + st = 1174 + default: + return length + } + + case 1174: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 1175 + default: + return length + } + + case 1178: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1179 + default: + return length + } + + case 1180: + switch byteToLower(b) { + case 'a': + st = 1181 + case 'c': + st = 1184 + case 'e': + length = i + 1 + st = 1186 + case 'l': + st = 1195 + case 'm': + length = i + 1 + st = 1197 + case 'o': + length = i + 1 + st = 1198 + case 'p': + length = i + 1 + st = 1204 + case 'u': + st = 1205 + default: + return length + } + + case 1181: + switch byteToLower(b) { + case 'v': + st = 1182 + default: + return length + } + + case 1182: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1183 + default: + return length + } + + case 1184: + switch byteToLower(b) { + case 'b': + length = i + 1 + st = 1185 + default: + return length + } + + case 1186: + switch byteToLower(b) { + case 't': + st = 1187 + case 'w': + st = 1190 + default: + return length + } + + case 1187: + switch byteToLower(b) { + case 'z': + st = 1188 + default: + return length + } + + case 1188: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1189 + default: + return length + } + + case 1190: + switch byteToLower(b) { + case 'e': + st = 1191 + default: + return length + } + + case 1191: + switch byteToLower(b) { + case 'l': + st = 1192 + default: + return length + } + + case 1192: + switch byteToLower(b) { + case 'r': + st = 1193 + default: + return length + } + + case 1193: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1194 + default: + return length + } + + case 1195: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1196 + default: + return length + } + + case 1198: + switch byteToLower(b) { + case 'b': + st = 1199 + default: + return length + } + + case 1199: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1200 + case 'u': + st = 1201 + default: + return length + } + + case 1201: + switch byteToLower(b) { + case 'r': + st = 1202 + default: + return length + } + + case 1202: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1203 + default: + return length + } + + case 1205: + switch byteToLower(b) { + case 'e': + st = 1206 + default: + return length + } + + case 1206: + switch byteToLower(b) { + case 'g': + st = 1207 + default: + return length + } + + case 1207: + switch byteToLower(b) { + case 'o': + st = 1208 + default: + return length + } + + case 1208: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1209 + default: + return length + } + + case 1210: + switch byteToLower(b) { + case 'a': + st = 1211 + case 'd': + st = 1216 + case 'e': + length = i + 1 + st = 1219 + case 'g': + length = i + 1 + st = 1220 + case 'h': + length = i + 1 + st = 1221 + case 'i': + length = i + 1 + st = 1222 + case 'm': + length = i + 1 + st = 1231 + case 'n': + length = i + 1 + st = 1232 + case 'o': + st = 1233 + case 'p': + length = i + 1 + st = 1242 + case 'r': + length = i + 1 + st = 1243 + case 'w': + length = i + 1 + st = 1247 + case 'y': + length = i + 1 + st = 1248 + case 'z': + length = i + 1 + st = 1252 + default: + return length + } + + case 1211: + switch byteToLower(b) { + case 'u': + st = 1212 + default: + return length + } + + case 1212: + switch byteToLower(b) { + case 'f': + st = 1213 + default: + return length + } + + case 1213: + switch byteToLower(b) { + case 'e': + st = 1214 + default: + return length + } + + case 1214: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1215 + default: + return length + } + + case 1216: + switch byteToLower(b) { + case 'd': + st = 1217 + default: + return length + } + + case 1217: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1218 + default: + return length + } + + case 1222: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 1223 + case 't': + st = 1224 + case 'w': + st = 1229 + default: + return length + } + + case 1224: + switch byteToLower(b) { + case 'c': + st = 1225 + default: + return length + } + + case 1225: + switch byteToLower(b) { + case 'h': + st = 1226 + default: + return length + } + + case 1226: + switch byteToLower(b) { + case 'e': + st = 1227 + default: + return length + } + + case 1227: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1228 + default: + return length + } + + case 1229: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1230 + default: + return length + } + + case 1233: + switch byteToLower(b) { + case 'e': + st = 1234 + case 'm': + st = 1237 + default: + return length + } + + case 1234: + switch byteToLower(b) { + case 'l': + st = 1235 + default: + return length + } + + case 1235: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1236 + default: + return length + } + + case 1237: + switch byteToLower(b) { + case 'a': + st = 1238 + default: + return length + } + + case 1238: + switch byteToLower(b) { + case 't': + st = 1239 + default: + return length + } + + case 1239: + switch byteToLower(b) { + case 's': + st = 1240 + default: + return length + } + + case 1240: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 1241 + default: + return length + } + + case 1243: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 1244 + case 'e': + st = 1245 + default: + return length + } + + case 1245: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 1246 + default: + return length + } + + case 1248: + switch byteToLower(b) { + case 'o': + st = 1249 + default: + return length + } + + case 1249: + switch byteToLower(b) { + case 't': + st = 1250 + default: + return length + } + + case 1250: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1251 + default: + return length + } + + case 1253: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1254 + case 'b': + length = i + 1 + st = 1271 + case 'c': + length = i + 1 + st = 1272 + case 'd': + st = 1273 + case 'e': + st = 1275 + case 'g': + st = 1287 + case 'i': + length = i + 1 + st = 1290 + case 'k': + length = i + 1 + st = 1314 + case 'o': + st = 1315 + case 'r': + length = i + 1 + st = 1333 + case 's': + length = i + 1 + st = 1334 + case 't': + length = i + 1 + st = 1335 + case 'u': + length = i + 1 + st = 1338 + case 'v': + length = i + 1 + st = 1347 + case 'y': + length = i + 1 + st = 1348 + default: + return length + } + + case 1254: + switch byteToLower(b) { + case 'c': + st = 1255 + case 'n': + st = 1260 + case 't': + length = i + 1 + st = 1262 + case 'w': + st = 1267 + default: + return length + } + + case 1255: + switch byteToLower(b) { + case 'a': + st = 1256 + default: + return length + } + + case 1256: + switch byteToLower(b) { + case 'i': + st = 1257 + default: + return length + } + + case 1257: + switch byteToLower(b) { + case 'x': + st = 1258 + default: + return length + } + + case 1258: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1259 + default: + return length + } + + case 1260: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 1261 + default: + return length + } + + case 1262: + switch byteToLower(b) { + case 'r': + st = 1263 + default: + return length + } + + case 1263: + switch byteToLower(b) { + case 'o': + st = 1264 + default: + return length + } + + case 1264: + switch byteToLower(b) { + case 'b': + st = 1265 + default: + return length + } + + case 1265: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1266 + default: + return length + } + + case 1267: + switch byteToLower(b) { + case 'y': + st = 1268 + default: + return length + } + + case 1268: + switch byteToLower(b) { + case 'e': + st = 1269 + default: + return length + } + + case 1269: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1270 + default: + return length + } + + case 1273: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1274 + default: + return length + } + + case 1275: + switch byteToLower(b) { + case 'a': + st = 1276 + case 'c': + st = 1279 + case 'g': + st = 1284 + default: + return length + } + + case 1276: + switch byteToLower(b) { + case 's': + st = 1277 + default: + return length + } + + case 1277: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1278 + default: + return length + } + + case 1279: + switch byteToLower(b) { + case 'l': + st = 1280 + default: + return length + } + + case 1280: + switch byteToLower(b) { + case 'e': + st = 1281 + default: + return length + } + + case 1281: + switch byteToLower(b) { + case 'r': + st = 1282 + default: + return length + } + + case 1282: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1283 + default: + return length + } + + case 1284: + switch byteToLower(b) { + case 'a': + st = 1285 + default: + return length + } + + case 1285: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1286 + default: + return length + } + + case 1287: + switch byteToLower(b) { + case 'b': + st = 1288 + default: + return length + } + + case 1288: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1289 + default: + return length + } + + case 1290: + switch byteToLower(b) { + case 'a': + st = 1291 + case 'd': + st = 1296 + case 'f': + st = 1298 + case 'g': + st = 1300 + case 'm': + st = 1306 + case 'n': + st = 1312 + default: + return length + } + + case 1291: + switch byteToLower(b) { + case 'i': + st = 1292 + default: + return length + } + + case 1292: + switch byteToLower(b) { + case 's': + st = 1293 + default: + return length + } + + case 1293: + switch byteToLower(b) { + case 'o': + st = 1294 + default: + return length + } + + case 1294: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1295 + default: + return length + } + + case 1296: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1297 + default: + return length + } + + case 1298: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1299 + default: + return length + } + + case 1300: + switch byteToLower(b) { + case 'h': + st = 1301 + default: + return length + } + + case 1301: + switch byteToLower(b) { + case 't': + st = 1302 + default: + return length + } + + case 1302: + switch byteToLower(b) { + case 'i': + st = 1303 + default: + return length + } + + case 1303: + switch byteToLower(b) { + case 'n': + st = 1304 + default: + return length + } + + case 1304: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1305 + default: + return length + } + + case 1306: + switch byteToLower(b) { + case 'i': + st = 1307 + case 'o': + length = i + 1 + st = 1311 + default: + return length + } + + case 1307: + switch byteToLower(b) { + case 't': + st = 1308 + default: + return length + } + + case 1308: + switch byteToLower(b) { + case 'e': + st = 1309 + default: + return length + } + + case 1309: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 1310 + default: + return length + } + + case 1312: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 1313 + default: + return length + } + + case 1315: + switch byteToLower(b) { + case 'a': + st = 1316 + case 'c': + st = 1319 + case 'l': + length = i + 1 + st = 1322 + case 'n': + st = 1323 + case 't': + st = 1327 + case 'v': + st = 1331 + default: + return length + } + + case 1316: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1317 + default: + return length + } + + case 1317: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1318 + default: + return length + } + + case 1319: + switch byteToLower(b) { + case 'a': + st = 1320 + default: + return length + } + + case 1320: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1321 + default: + return length + } + + case 1323: + switch byteToLower(b) { + case 'd': + st = 1324 + default: + return length + } + + case 1324: + switch byteToLower(b) { + case 'o': + st = 1325 + default: + return length + } + + case 1325: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1326 + default: + return length + } + + case 1327: + switch byteToLower(b) { + case 't': + st = 1328 + default: + return length + } + + case 1328: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1329 + case 'o': + length = i + 1 + st = 1330 + default: + return length + } + + case 1331: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1332 + default: + return length + } + + case 1335: + switch byteToLower(b) { + case 'd': + st = 1336 + default: + return length + } + + case 1336: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1337 + default: + return length + } + + case 1338: + switch byteToLower(b) { + case 'p': + st = 1339 + case 'x': + st = 1342 + default: + return length + } + + case 1339: + switch byteToLower(b) { + case 'i': + st = 1340 + default: + return length + } + + case 1340: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1341 + default: + return length + } + + case 1342: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1343 + case 'u': + st = 1344 + default: + return length + } + + case 1344: + switch byteToLower(b) { + case 'r': + st = 1345 + default: + return length + } + + case 1345: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1346 + default: + return length + } + + case 1349: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1350 + case 'b': + st = 1383 + case 'c': + length = i + 1 + st = 1385 + case 'd': + length = i + 1 + st = 1386 + case 'e': + length = i + 1 + st = 1387 + case 'g': + length = i + 1 + st = 1409 + case 'h': + length = i + 1 + st = 1410 + case 'i': + st = 1411 + case 'k': + length = i + 1 + st = 1418 + case 'l': + length = i + 1 + st = 1419 + case 'm': + length = i + 1 + st = 1420 + case 'n': + length = i + 1 + st = 1422 + case 'o': + length = i + 1 + st = 1423 + case 'p': + length = i + 1 + st = 1460 + case 'q': + length = i + 1 + st = 1461 + case 'r': + length = i + 1 + st = 1462 + case 's': + length = i + 1 + st = 1463 + case 't': + length = i + 1 + st = 1464 + case 'u': + length = i + 1 + st = 1468 + case 'v': + length = i + 1 + st = 1473 + case 'w': + length = i + 1 + st = 1474 + case 'x': + length = i + 1 + st = 1475 + case 'y': + length = i + 1 + st = 1476 + case 'z': + length = i + 1 + st = 1477 + default: + return length + } + + case 1350: + switch byteToLower(b) { + case 'd': + st = 1351 + case 'i': + st = 1355 + case 'n': + st = 1360 + case 'r': + st = 1370 + default: + return length + } + + case 1351: + switch byteToLower(b) { + case 'r': + st = 1352 + default: + return length + } + + case 1352: + switch byteToLower(b) { + case 'i': + st = 1353 + default: + return length + } + + case 1353: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 1354 + default: + return length + } + + case 1355: + switch byteToLower(b) { + case 'f': + length = i + 1 + st = 1356 + case 's': + st = 1357 + default: + return length + } + + case 1357: + switch byteToLower(b) { + case 'o': + st = 1358 + default: + return length + } + + case 1358: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1359 + default: + return length + } + + case 1360: + switch byteToLower(b) { + case 'a': + st = 1361 + case 'g': + st = 1368 + default: + return length + } + + case 1361: + switch byteToLower(b) { + case 'g': + st = 1362 + default: + return length + } + + case 1362: + switch byteToLower(b) { + case 'e': + st = 1363 + default: + return length + } + + case 1363: + switch byteToLower(b) { + case 'm': + st = 1364 + default: + return length + } + + case 1364: + switch byteToLower(b) { + case 'e': + st = 1365 + default: + return length + } + + case 1365: + switch byteToLower(b) { + case 'n': + st = 1366 + default: + return length + } + + case 1366: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1367 + default: + return length + } + + case 1368: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1369 + default: + return length + } + + case 1370: + switch byteToLower(b) { + case 'k': + st = 1371 + case 'r': + st = 1378 + default: + return length + } + + case 1371: + switch byteToLower(b) { + case 'e': + st = 1372 + default: + return length + } + + case 1372: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1373 + default: + return length + } + + case 1373: + switch byteToLower(b) { + case 'i': + st = 1374 + case 's': + length = i + 1 + st = 1377 + default: + return length + } + + case 1374: + switch byteToLower(b) { + case 'n': + st = 1375 + default: + return length + } + + case 1375: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1376 + default: + return length + } + + case 1378: + switch byteToLower(b) { + case 'i': + st = 1379 + default: + return length + } + + case 1379: + switch byteToLower(b) { + case 'o': + st = 1380 + default: + return length + } + + case 1380: + switch byteToLower(b) { + case 't': + st = 1381 + default: + return length + } + + case 1381: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1382 + default: + return length + } + + case 1383: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1384 + default: + return length + } + + case 1387: + switch byteToLower(b) { + case 'd': + st = 1388 + case 'e': + st = 1391 + case 'l': + st = 1393 + case 'm': + st = 1400 + case 'n': + length = i + 1 + st = 1407 + default: + return length + } + + case 1388: + switch byteToLower(b) { + case 'i': + st = 1389 + default: + return length + } + + case 1389: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1390 + default: + return length + } + + case 1391: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1392 + default: + return length + } + + case 1393: + switch byteToLower(b) { + case 'b': + st = 1394 + default: + return length + } + + case 1394: + switch byteToLower(b) { + case 'o': + st = 1395 + default: + return length + } + + case 1395: + switch byteToLower(b) { + case 'u': + st = 1396 + default: + return length + } + + case 1396: + switch byteToLower(b) { + case 'r': + st = 1397 + default: + return length + } + + case 1397: + switch byteToLower(b) { + case 'n': + st = 1398 + default: + return length + } + + case 1398: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1399 + default: + return length + } + + case 1400: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1401 + case 'o': + st = 1402 + default: + return length + } + + case 1402: + switch byteToLower(b) { + case 'r': + st = 1403 + default: + return length + } + + case 1403: + switch byteToLower(b) { + case 'i': + st = 1404 + default: + return length + } + + case 1404: + switch byteToLower(b) { + case 'a': + st = 1405 + default: + return length + } + + case 1405: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1406 + default: + return length + } + + case 1407: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 1408 + default: + return length + } + + case 1411: + switch byteToLower(b) { + case 'a': + st = 1412 + case 'l': + length = i + 1 + st = 1415 + case 'n': + st = 1416 + default: + return length + } + + case 1412: + switch byteToLower(b) { + case 'm': + st = 1413 + default: + return length + } + + case 1413: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1414 + default: + return length + } + + case 1416: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1417 + default: + return length + } + + case 1420: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1421 + default: + return length + } + + case 1423: + switch byteToLower(b) { + case 'b': + st = 1424 + case 'd': + st = 1426 + case 'e': + length = i + 1 + st = 1428 + case 'n': + st = 1429 + case 'r': + st = 1435 + case 's': + st = 1444 + case 't': + st = 1448 + case 'v': + length = i + 1 + st = 1457 + default: + return length + } + + case 1424: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1425 + default: + return length + } + + case 1426: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1427 + default: + return length + } + + case 1429: + switch byteToLower(b) { + case 'a': + st = 1430 + case 'e': + st = 1433 + default: + return length + } + + case 1430: + switch byteToLower(b) { + case 's': + st = 1431 + default: + return length + } + + case 1431: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 1432 + default: + return length + } + + case 1433: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1434 + default: + return length + } + + case 1435: + switch byteToLower(b) { + case 'm': + st = 1436 + case 't': + st = 1439 + default: + return length + } + + case 1436: + switch byteToLower(b) { + case 'o': + st = 1437 + default: + return length + } + + case 1437: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1438 + default: + return length + } + + case 1439: + switch byteToLower(b) { + case 'g': + st = 1440 + default: + return length + } + + case 1440: + switch byteToLower(b) { + case 'a': + st = 1441 + default: + return length + } + + case 1441: + switch byteToLower(b) { + case 'g': + st = 1442 + default: + return length + } + + case 1442: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1443 + default: + return length + } + + case 1444: + switch byteToLower(b) { + case 'c': + st = 1445 + default: + return length + } + + case 1445: + switch byteToLower(b) { + case 'o': + st = 1446 + default: + return length + } + + case 1446: + switch byteToLower(b) { + case 'w': + length = i + 1 + st = 1447 + default: + return length + } + + case 1448: + switch byteToLower(b) { + case 'o': + st = 1449 + default: + return length + } + + case 1449: + switch byteToLower(b) { + case 'r': + st = 1450 + default: + return length + } + + case 1450: + switch byteToLower(b) { + case 'c': + st = 1451 + default: + return length + } + + case 1451: + switch byteToLower(b) { + case 'y': + st = 1452 + default: + return length + } + + case 1452: + switch byteToLower(b) { + case 'c': + st = 1453 + default: + return length + } + + case 1453: + switch byteToLower(b) { + case 'l': + st = 1454 + default: + return length + } + + case 1454: + switch byteToLower(b) { + case 'e': + st = 1455 + default: + return length + } + + case 1455: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1456 + default: + return length + } + + case 1457: + switch byteToLower(b) { + case 'i': + st = 1458 + default: + return length + } + + case 1458: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1459 + default: + return length + } + + case 1464: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1465 + case 'p': + st = 1466 + default: + return length + } + + case 1466: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1467 + default: + return length + } + + case 1468: + switch byteToLower(b) { + case 's': + st = 1469 + default: + return length + } + + case 1469: + switch byteToLower(b) { + case 'e': + st = 1470 + default: + return length + } + + case 1470: + switch byteToLower(b) { + case 'u': + st = 1471 + default: + return length + } + + case 1471: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 1472 + default: + return length + } + + case 1478: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1479 + case 'c': + length = i + 1 + st = 1491 + case 'e': + length = i + 1 + st = 1492 + case 'f': + length = i + 1 + st = 1509 + case 'g': + length = i + 1 + st = 1510 + case 'h': + st = 1512 + case 'i': + length = i + 1 + st = 1514 + case 'l': + length = i + 1 + st = 1524 + case 'o': + length = i + 1 + st = 1525 + case 'p': + length = i + 1 + st = 1526 + case 'r': + length = i + 1 + st = 1527 + case 't': + st = 1530 + case 'u': + length = i + 1 + st = 1532 + case 'y': + st = 1533 + case 'z': + length = i + 1 + st = 1535 + default: + return length + } + + case 1479: + switch byteToLower(b) { + case 'd': + st = 1480 + case 'g': + st = 1483 + case 'm': + st = 1487 + case 'v': + st = 1489 + default: + return length + } + + case 1480: + switch byteToLower(b) { + case 'e': + st = 1481 + default: + return length + } + + case 1481: + switch byteToLower(b) { + case 'x': + length = i + 1 + st = 1482 + default: + return length + } + + case 1483: + switch byteToLower(b) { + case 'o': + st = 1484 + default: + return length + } + + case 1484: + switch byteToLower(b) { + case 'y': + st = 1485 + default: + return length + } + + case 1485: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1486 + default: + return length + } + + case 1487: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1488 + default: + return length + } + + case 1489: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1490 + default: + return length + } + + case 1492: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1493 + case 't': + length = i + 1 + st = 1494 + case 'u': + st = 1499 + case 'w': + length = i + 1 + st = 1504 + case 'x': + st = 1506 + default: + return length + } + + case 1494: + switch byteToLower(b) { + case 'w': + st = 1495 + default: + return length + } + + case 1495: + switch byteToLower(b) { + case 'o': + st = 1496 + default: + return length + } + + case 1496: + switch byteToLower(b) { + case 'r': + st = 1497 + default: + return length + } + + case 1497: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 1498 + default: + return length + } + + case 1499: + switch byteToLower(b) { + case 's': + st = 1500 + default: + return length + } + + case 1500: + switch byteToLower(b) { + case 't': + st = 1501 + default: + return length + } + + case 1501: + switch byteToLower(b) { + case 'a': + st = 1502 + default: + return length + } + + case 1502: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1503 + default: + return length + } + + case 1504: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1505 + default: + return length + } + + case 1506: + switch byteToLower(b) { + case 'u': + st = 1507 + default: + return length + } + + case 1507: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1508 + default: + return length + } + + case 1510: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1511 + default: + return length + } + + case 1512: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 1513 + default: + return length + } + + case 1514: + switch byteToLower(b) { + case 'c': + st = 1515 + case 'n': + st = 1517 + case 's': + st = 1520 + default: + return length + } + + case 1515: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1516 + default: + return length + } + + case 1517: + switch byteToLower(b) { + case 'j': + st = 1518 + default: + return length + } + + case 1518: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1519 + default: + return length + } + + case 1520: + switch byteToLower(b) { + case 's': + st = 1521 + default: + return length + } + + case 1521: + switch byteToLower(b) { + case 'a': + st = 1522 + default: + return length + } + + case 1522: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1523 + default: + return length + } + + case 1527: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1528 + case 'w': + length = i + 1 + st = 1529 + default: + return length + } + + case 1530: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1531 + default: + return length + } + + case 1533: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1534 + default: + return length + } + + case 1536: + switch byteToLower(b) { + case 'k': + st = 1537 + case 'm': + length = i + 1 + st = 1543 + case 'n': + st = 1544 + case 'o': + st = 1554 + case 'r': + st = 1556 + case 's': + st = 1566 + case 't': + st = 1570 + case 'v': + st = 1575 + default: + return length + } + + case 1537: + switch byteToLower(b) { + case 'i': + st = 1538 + default: + return length + } + + case 1538: + switch byteToLower(b) { + case 'n': + st = 1539 + default: + return length + } + + case 1539: + switch byteToLower(b) { + case 'a': + st = 1540 + default: + return length + } + + case 1540: + switch byteToLower(b) { + case 'w': + st = 1541 + default: + return length + } + + case 1541: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1542 + default: + return length + } + + case 1544: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1545 + case 'g': + length = i + 1 + st = 1546 + case 'i': + st = 1547 + case 'l': + length = i + 1 + st = 1550 + default: + return length + } + + case 1547: + switch byteToLower(b) { + case 'o': + st = 1548 + default: + return length + } + + case 1548: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1549 + default: + return length + } + + case 1550: + switch byteToLower(b) { + case 'i': + st = 1551 + default: + return length + } + + case 1551: + switch byteToLower(b) { + case 'n': + st = 1552 + default: + return length + } + + case 1552: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1553 + default: + return length + } + + case 1554: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1555 + default: + return length + } + + case 1556: + switch byteToLower(b) { + case 'a': + st = 1557 + case 'g': + length = i + 1 + st = 1561 + default: + return length + } + + case 1557: + switch byteToLower(b) { + case 'c': + st = 1558 + default: + return length + } + + case 1558: + switch byteToLower(b) { + case 'l': + st = 1559 + default: + return length + } + + case 1559: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1560 + default: + return length + } + + case 1561: + switch byteToLower(b) { + case 'a': + st = 1562 + default: + return length + } + + case 1562: + switch byteToLower(b) { + case 'n': + st = 1563 + default: + return length + } + + case 1563: + switch byteToLower(b) { + case 'i': + st = 1564 + default: + return length + } + + case 1564: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1565 + default: + return length + } + + case 1566: + switch byteToLower(b) { + case 'a': + st = 1567 + default: + return length + } + + case 1567: + switch byteToLower(b) { + case 'k': + st = 1568 + default: + return length + } + + case 1568: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1569 + default: + return length + } + + case 1570: + switch byteToLower(b) { + case 's': + st = 1571 + default: + return length + } + + case 1571: + switch byteToLower(b) { + case 'u': + st = 1572 + default: + return length + } + + case 1572: + switch byteToLower(b) { + case 'k': + st = 1573 + default: + return length + } + + case 1573: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1574 + default: + return length + } + + case 1575: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 1576 + default: + return length + } + + case 1577: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1578 + case 'e': + length = i + 1 + st = 1596 + case 'f': + length = i + 1 + st = 1597 + case 'g': + length = i + 1 + st = 1598 + case 'h': + length = i + 1 + st = 1599 + case 'i': + st = 1625 + case 'k': + length = i + 1 + st = 1644 + case 'l': + length = i + 1 + st = 1645 + case 'm': + length = i + 1 + st = 1656 + case 'n': + length = i + 1 + st = 1657 + case 'o': + st = 1658 + case 'r': + length = i + 1 + st = 1668 + case 's': + length = i + 1 + st = 1693 + case 't': + length = i + 1 + st = 1694 + case 'u': + st = 1695 + case 'w': + length = i + 1 + st = 1697 + case 'y': + length = i + 1 + st = 1698 + default: + return length + } + + case 1578: + switch byteToLower(b) { + case 'g': + st = 1579 + case 'n': + st = 1581 + case 'r': + st = 1586 + default: + return length + } + + case 1579: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1580 + default: + return length + } + + case 1581: + switch byteToLower(b) { + case 'e': + st = 1582 + default: + return length + } + + case 1582: + switch byteToLower(b) { + case 'r': + st = 1583 + default: + return length + } + + case 1583: + switch byteToLower(b) { + case 'a': + st = 1584 + default: + return length + } + + case 1584: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1585 + default: + return length + } + + case 1586: + switch byteToLower(b) { + case 'i': + st = 1587 + case 't': + st = 1589 + default: + return length + } + + case 1587: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1588 + default: + return length + } + + case 1589: + switch byteToLower(b) { + case 'n': + st = 1590 + case 's': + length = i + 1 + st = 1594 + case 'y': + length = i + 1 + st = 1595 + default: + return length + } + + case 1590: + switch byteToLower(b) { + case 'e': + st = 1591 + default: + return length + } + + case 1591: + switch byteToLower(b) { + case 'r': + st = 1592 + default: + return length + } + + case 1592: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1593 + default: + return length + } + + case 1599: + switch byteToLower(b) { + case 'a': + st = 1600 + case 'i': + st = 1606 + case 'o': + st = 1611 + case 'y': + st = 1621 + default: + return length + } + + case 1600: + switch byteToLower(b) { + case 'r': + st = 1601 + default: + return length + } + + case 1601: + switch byteToLower(b) { + case 'm': + st = 1602 + default: + return length + } + + case 1602: + switch byteToLower(b) { + case 'a': + st = 1603 + default: + return length + } + + case 1603: + switch byteToLower(b) { + case 'c': + st = 1604 + default: + return length + } + + case 1604: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1605 + default: + return length + } + + case 1606: + switch byteToLower(b) { + case 'l': + st = 1607 + default: + return length + } + + case 1607: + switch byteToLower(b) { + case 'i': + st = 1608 + default: + return length + } + + case 1608: + switch byteToLower(b) { + case 'p': + st = 1609 + default: + return length + } + + case 1609: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1610 + default: + return length + } + + case 1611: + switch byteToLower(b) { + case 't': + st = 1612 + default: + return length + } + + case 1612: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1613 + default: + return length + } + + case 1613: + switch byteToLower(b) { + case 'g': + st = 1614 + case 's': + length = i + 1 + st = 1620 + default: + return length + } + + case 1614: + switch byteToLower(b) { + case 'r': + st = 1615 + default: + return length + } + + case 1615: + switch byteToLower(b) { + case 'a': + st = 1616 + default: + return length + } + + case 1616: + switch byteToLower(b) { + case 'p': + st = 1617 + default: + return length + } + + case 1617: + switch byteToLower(b) { + case 'h': + st = 1618 + default: + return length + } + + case 1618: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1619 + default: + return length + } + + case 1621: + switch byteToLower(b) { + case 's': + st = 1622 + default: + return length + } + + case 1622: + switch byteToLower(b) { + case 'i': + st = 1623 + default: + return length + } + + case 1623: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1624 + default: + return length + } + + case 1625: + switch byteToLower(b) { + case 'a': + st = 1626 + case 'c': + st = 1630 + case 'n': + st = 1639 + case 'z': + st = 1641 + default: + return length + } + + case 1626: + switch byteToLower(b) { + case 'g': + st = 1627 + default: + return length + } + + case 1627: + switch byteToLower(b) { + case 'e': + st = 1628 + default: + return length + } + + case 1628: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1629 + default: + return length + } + + case 1630: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1631 + case 't': + st = 1632 + default: + return length + } + + case 1632: + switch byteToLower(b) { + case 'e': + st = 1633 + case 'u': + st = 1635 + default: + return length + } + + case 1633: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1634 + default: + return length + } + + case 1635: + switch byteToLower(b) { + case 'r': + st = 1636 + default: + return length + } + + case 1636: + switch byteToLower(b) { + case 'e': + st = 1637 + default: + return length + } + + case 1637: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1638 + default: + return length + } + + case 1639: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 1640 + default: + return length + } + + case 1641: + switch byteToLower(b) { + case 'z': + st = 1642 + default: + return length + } + + case 1642: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1643 + default: + return length + } + + case 1645: + switch byteToLower(b) { + case 'a': + st = 1646 + case 'u': + st = 1649 + default: + return length + } + + case 1646: + switch byteToLower(b) { + case 'c': + st = 1647 + default: + return length + } + + case 1647: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1648 + default: + return length + } + + case 1649: + switch byteToLower(b) { + case 'm': + st = 1650 + case 's': + length = i + 1 + st = 1655 + default: + return length + } + + case 1650: + switch byteToLower(b) { + case 'b': + st = 1651 + default: + return length + } + + case 1651: + switch byteToLower(b) { + case 'i': + st = 1652 + default: + return length + } + + case 1652: + switch byteToLower(b) { + case 'n': + st = 1653 + default: + return length + } + + case 1653: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1654 + default: + return length + } + + case 1658: + switch byteToLower(b) { + case 'h': + st = 1659 + case 'k': + st = 1661 + case 'r': + st = 1664 + case 's': + st = 1666 + default: + return length + } + + case 1659: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1660 + default: + return length + } + + case 1661: + switch byteToLower(b) { + case 'e': + st = 1662 + default: + return length + } + + case 1662: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1663 + default: + return length + } + + case 1664: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1665 + default: + return length + } + + case 1666: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1667 + default: + return length + } + + case 1668: + switch byteToLower(b) { + case 'a': + st = 1669 + case 'e': + st = 1672 + case 'o': + length = i + 1 + st = 1675 + default: + return length + } + + case 1669: + switch byteToLower(b) { + case 'x': + st = 1670 + default: + return length + } + + case 1670: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1671 + default: + return length + } + + case 1672: + switch byteToLower(b) { + case 's': + st = 1673 + default: + return length + } + + case 1673: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1674 + default: + return length + } + + case 1675: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 1676 + case 'f': + length = i + 1 + st = 1684 + case 'p': + st = 1685 + default: + return length + } + + case 1676: + switch byteToLower(b) { + case 'u': + st = 1677 + default: + return length + } + + case 1677: + switch byteToLower(b) { + case 'c': + st = 1678 + default: + return length + } + + case 1678: + switch byteToLower(b) { + case 't': + st = 1679 + default: + return length + } + + case 1679: + switch byteToLower(b) { + case 'i': + st = 1680 + default: + return length + } + + case 1680: + switch byteToLower(b) { + case 'o': + st = 1681 + default: + return length + } + + case 1681: + switch byteToLower(b) { + case 'n': + st = 1682 + default: + return length + } + + case 1682: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1683 + default: + return length + } + + case 1685: + switch byteToLower(b) { + case 'e': + st = 1686 + default: + return length + } + + case 1686: + switch byteToLower(b) { + case 'r': + st = 1687 + default: + return length + } + + case 1687: + switch byteToLower(b) { + case 't': + st = 1688 + default: + return length + } + + case 1688: + switch byteToLower(b) { + case 'i': + st = 1689 + case 'y': + length = i + 1 + st = 1692 + default: + return length + } + + case 1689: + switch byteToLower(b) { + case 'e': + st = 1690 + default: + return length + } + + case 1690: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1691 + default: + return length + } + + case 1695: + switch byteToLower(b) { + case 'b': + length = i + 1 + st = 1696 + default: + return length + } + + case 1699: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1700 + case 'p': + st = 1701 + case 'u': + st = 1704 + default: + return length + } + + case 1701: + switch byteToLower(b) { + case 'o': + st = 1702 + default: + return length + } + + case 1702: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1703 + default: + return length + } + + case 1704: + switch byteToLower(b) { + case 'e': + st = 1705 + default: + return length + } + + case 1705: + switch byteToLower(b) { + case 'b': + st = 1706 + default: + return length + } + + case 1706: + switch byteToLower(b) { + case 'e': + st = 1707 + default: + return length + } + + case 1707: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 1708 + default: + return length + } + + case 1709: + switch byteToLower(b) { + case 'a': + st = 1710 + case 'e': + length = i + 1 + st = 1715 + case 'i': + st = 1772 + case 'o': + length = i + 1 + st = 1777 + case 's': + length = i + 1 + st = 1784 + case 'u': + length = i + 1 + st = 1787 + case 'w': + length = i + 1 + st = 1791 + case 'y': + st = 1792 + default: + return length + } + + case 1710: + switch byteToLower(b) { + case 'c': + st = 1711 + default: + return length + } + + case 1711: + switch byteToLower(b) { + case 'i': + st = 1712 + default: + return length + } + + case 1712: + switch byteToLower(b) { + case 'n': + st = 1713 + default: + return length + } + + case 1713: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1714 + default: + return length + } + + case 1715: + switch byteToLower(b) { + case 'a': + st = 1716 + case 'c': + st = 1721 + case 'd': + length = i + 1 + st = 1726 + case 'h': + st = 1732 + case 'i': + st = 1735 + case 'n': + length = i + 1 + st = 1740 + case 'p': + st = 1745 + case 's': + st = 1759 + case 'v': + st = 1767 + default: + return length + } + + case 1716: + switch byteToLower(b) { + case 'l': + st = 1717 + default: + return length + } + + case 1717: + switch byteToLower(b) { + case 't': + st = 1718 + default: + return length + } + + case 1718: + switch byteToLower(b) { + case 'o': + st = 1719 + default: + return length + } + + case 1719: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1720 + default: + return length + } + + case 1721: + switch byteToLower(b) { + case 'i': + st = 1722 + default: + return length + } + + case 1722: + switch byteToLower(b) { + case 'p': + st = 1723 + default: + return length + } + + case 1723: + switch byteToLower(b) { + case 'e': + st = 1724 + default: + return length + } + + case 1724: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1725 + default: + return length + } + + case 1726: + switch byteToLower(b) { + case 's': + st = 1727 + default: + return length + } + + case 1727: + switch byteToLower(b) { + case 't': + st = 1728 + default: + return length + } + + case 1728: + switch byteToLower(b) { + case 'o': + st = 1729 + default: + return length + } + + case 1729: + switch byteToLower(b) { + case 'n': + st = 1730 + default: + return length + } + + case 1730: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1731 + default: + return length + } + + case 1732: + switch byteToLower(b) { + case 'a': + st = 1733 + default: + return length + } + + case 1733: + switch byteToLower(b) { + case 'b': + length = i + 1 + st = 1734 + default: + return length + } + + case 1735: + switch byteToLower(b) { + case 's': + st = 1736 + case 't': + length = i + 1 + st = 1739 + default: + return length + } + + case 1736: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1737 + default: + return length + } + + case 1737: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1738 + default: + return length + } + + case 1740: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1741 + default: + return length + } + + case 1741: + switch byteToLower(b) { + case 'a': + st = 1742 + default: + return length + } + + case 1742: + switch byteToLower(b) { + case 'l': + st = 1743 + default: + return length + } + + case 1743: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1744 + default: + return length + } + + case 1745: + switch byteToLower(b) { + case 'a': + st = 1746 + case 'o': + st = 1749 + case 'u': + st = 1752 + default: + return length + } + + case 1746: + switch byteToLower(b) { + case 'i': + st = 1747 + default: + return length + } + + case 1747: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1748 + default: + return length + } + + case 1749: + switch byteToLower(b) { + case 'r': + st = 1750 + default: + return length + } + + case 1750: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1751 + default: + return length + } + + case 1752: + switch byteToLower(b) { + case 'b': + st = 1753 + default: + return length + } + + case 1753: + switch byteToLower(b) { + case 'l': + st = 1754 + default: + return length + } + + case 1754: + switch byteToLower(b) { + case 'i': + st = 1755 + default: + return length + } + + case 1755: + switch byteToLower(b) { + case 'c': + st = 1756 + default: + return length + } + + case 1756: + switch byteToLower(b) { + case 'a': + st = 1757 + default: + return length + } + + case 1757: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 1758 + default: + return length + } + + case 1759: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1760 + default: + return length + } + + case 1760: + switch byteToLower(b) { + case 'a': + st = 1761 + default: + return length + } + + case 1761: + switch byteToLower(b) { + case 'u': + st = 1762 + default: + return length + } + + case 1762: + switch byteToLower(b) { + case 'r': + st = 1763 + default: + return length + } + + case 1763: + switch byteToLower(b) { + case 'a': + st = 1764 + default: + return length + } + + case 1764: + switch byteToLower(b) { + case 'n': + st = 1765 + default: + return length + } + + case 1765: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1766 + default: + return length + } + + case 1767: + switch byteToLower(b) { + case 'i': + st = 1768 + default: + return length + } + + case 1768: + switch byteToLower(b) { + case 'e': + st = 1769 + default: + return length + } + + case 1769: + switch byteToLower(b) { + case 'w': + length = i + 1 + st = 1770 + default: + return length + } + + case 1770: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1771 + default: + return length + } + + case 1772: + switch byteToLower(b) { + case 'c': + st = 1773 + case 'o': + length = i + 1 + st = 1775 + case 'p': + length = i + 1 + st = 1776 + default: + return length + } + + case 1773: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 1774 + default: + return length + } + + case 1777: + switch byteToLower(b) { + case 'c': + st = 1778 + case 'd': + st = 1781 + default: + return length + } + + case 1778: + switch byteToLower(b) { + case 'k': + st = 1779 + default: + return length + } + + case 1779: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1780 + default: + return length + } + + case 1781: + switch byteToLower(b) { + case 'e': + st = 1782 + default: + return length + } + + case 1782: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1783 + default: + return length + } + + case 1784: + switch byteToLower(b) { + case 'v': + st = 1785 + default: + return length + } + + case 1785: + switch byteToLower(b) { + case 'p': + length = i + 1 + st = 1786 + default: + return length + } + + case 1787: + switch byteToLower(b) { + case 'h': + st = 1788 + case 'n': + length = i + 1 + st = 1790 + default: + return length + } + + case 1788: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1789 + default: + return length + } + + case 1792: + switch byteToLower(b) { + case 'u': + st = 1793 + default: + return length + } + + case 1793: + switch byteToLower(b) { + case 'k': + st = 1794 + default: + return length + } + + case 1794: + switch byteToLower(b) { + case 'y': + st = 1795 + default: + return length + } + + case 1795: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 1796 + default: + return length + } + + case 1797: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1798 + case 'b': + length = i + 1 + st = 1830 + case 'c': + length = i + 1 + st = 1831 + case 'd': + length = i + 1 + st = 1864 + case 'e': + length = i + 1 + st = 1865 + case 'g': + length = i + 1 + st = 1880 + case 'h': + length = i + 1 + st = 1881 + case 'i': + length = i + 1 + st = 1896 + case 'j': + length = i + 1 + st = 1904 + case 'k': + length = i + 1 + st = 1905 + case 'l': + length = i + 1 + st = 1908 + case 'm': + length = i + 1 + st = 1909 + case 'n': + length = i + 1 + st = 1910 + case 'o': + length = i + 1 + st = 1913 + case 'p': + st = 1941 + case 'r': + length = i + 1 + st = 1961 + case 't': + length = i + 1 + st = 1962 + case 'u': + length = i + 1 + st = 1969 + case 'v': + length = i + 1 + st = 1993 + case 'w': + st = 1994 + case 'x': + length = i + 1 + st = 1998 + case 'y': + length = i + 1 + st = 1999 + case 'z': + length = i + 1 + st = 2009 + default: + return length + } + + case 1798: + switch byteToLower(b) { + case 'a': + st = 1799 + case 'l': + st = 1805 + case 'm': + st = 1807 + case 'n': + st = 1812 + case 'p': + length = i + 1 + st = 1825 + case 'r': + st = 1826 + case 'x': + st = 1828 + default: + return length + } + + case 1799: + switch byteToLower(b) { + case 'r': + st = 1800 + default: + return length + } + + case 1800: + switch byteToLower(b) { + case 'l': + st = 1801 + default: + return length + } + + case 1801: + switch byteToLower(b) { + case 'a': + st = 1802 + default: + return length + } + + case 1802: + switch byteToLower(b) { + case 'n': + st = 1803 + default: + return length + } + + case 1803: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 1804 + default: + return length + } + + case 1805: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1806 + default: + return length + } + + case 1807: + switch byteToLower(b) { + case 's': + st = 1808 + default: + return length + } + + case 1808: + switch byteToLower(b) { + case 'u': + st = 1809 + default: + return length + } + + case 1809: + switch byteToLower(b) { + case 'n': + st = 1810 + default: + return length + } + + case 1810: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1811 + default: + return length + } + + case 1812: + switch byteToLower(b) { + case 'd': + st = 1813 + default: + return length + } + + case 1813: + switch byteToLower(b) { + case 'v': + st = 1814 + default: + return length + } + + case 1814: + switch byteToLower(b) { + case 'i': + st = 1815 + default: + return length + } + + case 1815: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 1816 + default: + return length + } + + case 1816: + switch byteToLower(b) { + case 'c': + st = 1817 + default: + return length + } + + case 1817: + switch byteToLower(b) { + case 'o': + st = 1818 + default: + return length + } + + case 1818: + switch byteToLower(b) { + case 'r': + st = 1819 + default: + return length + } + + case 1819: + switch byteToLower(b) { + case 'o': + st = 1820 + default: + return length + } + + case 1820: + switch byteToLower(b) { + case 'm': + st = 1821 + default: + return length + } + + case 1821: + switch byteToLower(b) { + case 'a': + st = 1822 + default: + return length + } + + case 1822: + switch byteToLower(b) { + case 'n': + st = 1823 + default: + return length + } + + case 1823: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1824 + default: + return length + } + + case 1826: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1827 + default: + return length + } + + case 1828: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 1829 + default: + return length + } + + case 1831: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1832 + case 'b': + length = i + 1 + st = 1833 + case 'h': + st = 1834 + case 'i': + st = 1857 + case 'o': + st = 1862 + default: + return length + } + + case 1834: + switch byteToLower(b) { + case 'm': + st = 1835 + case 'o': + st = 1839 + case 'u': + st = 1850 + case 'w': + st = 1853 + default: + return length + } + + case 1835: + switch byteToLower(b) { + case 'i': + st = 1836 + default: + return length + } + + case 1836: + switch byteToLower(b) { + case 'd': + st = 1837 + default: + return length + } + + case 1837: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1838 + default: + return length + } + + case 1839: + switch byteToLower(b) { + case 'l': + st = 1840 + case 'o': + st = 1848 + default: + return length + } + + case 1840: + switch byteToLower(b) { + case 'a': + st = 1841 + default: + return length + } + + case 1841: + switch byteToLower(b) { + case 'r': + st = 1842 + default: + return length + } + + case 1842: + switch byteToLower(b) { + case 's': + st = 1843 + default: + return length + } + + case 1843: + switch byteToLower(b) { + case 'h': + st = 1844 + default: + return length + } + + case 1844: + switch byteToLower(b) { + case 'i': + st = 1845 + default: + return length + } + + case 1845: + switch byteToLower(b) { + case 'p': + st = 1846 + default: + return length + } + + case 1846: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1847 + default: + return length + } + + case 1848: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1849 + default: + return length + } + + case 1850: + switch byteToLower(b) { + case 'l': + st = 1851 + default: + return length + } + + case 1851: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1852 + default: + return length + } + + case 1853: + switch byteToLower(b) { + case 'a': + st = 1854 + default: + return length + } + + case 1854: + switch byteToLower(b) { + case 'r': + st = 1855 + default: + return length + } + + case 1855: + switch byteToLower(b) { + case 'z': + length = i + 1 + st = 1856 + default: + return length + } + + case 1857: + switch byteToLower(b) { + case 'e': + st = 1858 + default: + return length + } + + case 1858: + switch byteToLower(b) { + case 'n': + st = 1859 + default: + return length + } + + case 1859: + switch byteToLower(b) { + case 'c': + st = 1860 + default: + return length + } + + case 1860: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1861 + default: + return length + } + + case 1862: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1863 + default: + return length + } + + case 1865: + switch byteToLower(b) { + case 'a': + st = 1866 + case 'n': + st = 1868 + case 'r': + st = 1871 + case 'w': + length = i + 1 + st = 1877 + case 'x': + length = i + 1 + st = 1878 + default: + return length + } + + case 1866: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1867 + default: + return length + } + + case 1868: + switch byteToLower(b) { + case 'e': + st = 1869 + default: + return length + } + + case 1869: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1870 + default: + return length + } + + case 1871: + switch byteToLower(b) { + case 'v': + st = 1872 + default: + return length + } + + case 1872: + switch byteToLower(b) { + case 'i': + st = 1873 + default: + return length + } + + case 1873: + switch byteToLower(b) { + case 'c': + st = 1874 + default: + return length + } + + case 1874: + switch byteToLower(b) { + case 'e': + st = 1875 + default: + return length + } + + case 1875: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1876 + default: + return length + } + + case 1878: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1879 + default: + return length + } + + case 1881: + switch byteToLower(b) { + case 'i': + st = 1882 + case 'o': + st = 1887 + case 'r': + st = 1891 + default: + return length + } + + case 1882: + switch byteToLower(b) { + case 'k': + st = 1883 + default: + return length + } + + case 1883: + switch byteToLower(b) { + case 's': + st = 1884 + default: + return length + } + + case 1884: + switch byteToLower(b) { + case 'h': + st = 1885 + default: + return length + } + + case 1885: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 1886 + default: + return length + } + + case 1887: + switch byteToLower(b) { + case 'e': + st = 1888 + case 'w': + length = i + 1 + st = 1890 + default: + return length + } + + case 1888: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1889 + default: + return length + } + + case 1891: + switch byteToLower(b) { + case 'i': + st = 1892 + default: + return length + } + + case 1892: + switch byteToLower(b) { + case 'r': + st = 1893 + default: + return length + } + + case 1893: + switch byteToLower(b) { + case 'a': + st = 1894 + default: + return length + } + + case 1894: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 1895 + default: + return length + } + + case 1896: + switch byteToLower(b) { + case 'n': + st = 1897 + case 't': + st = 1902 + default: + return length + } + + case 1897: + switch byteToLower(b) { + case 'g': + st = 1898 + default: + return length + } + + case 1898: + switch byteToLower(b) { + case 'l': + st = 1899 + default: + return length + } + + case 1899: + switch byteToLower(b) { + case 'e': + st = 1900 + default: + return length + } + + case 1900: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1901 + default: + return length + } + + case 1902: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1903 + default: + return length + } + + case 1905: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1906 + case 'y': + length = i + 1 + st = 1907 + default: + return length + } + + case 1910: + switch byteToLower(b) { + case 'c': + st = 1911 + default: + return length + } + + case 1911: + switch byteToLower(b) { + case 'f': + length = i + 1 + st = 1912 + default: + return length + } + + case 1913: + switch byteToLower(b) { + case 'c': + st = 1914 + case 'f': + st = 1921 + case 'h': + st = 1927 + case 'l': + st = 1929 + case 'n': + st = 1938 + case 'y': + length = i + 1 + st = 1940 + default: + return length + } + + case 1914: + switch byteToLower(b) { + case 'c': + st = 1915 + case 'i': + st = 1918 + default: + return length + } + + case 1915: + switch byteToLower(b) { + case 'e': + st = 1916 + default: + return length + } + + case 1916: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1917 + default: + return length + } + + case 1918: + switch byteToLower(b) { + case 'a': + st = 1919 + default: + return length + } + + case 1919: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1920 + default: + return length + } + + case 1921: + switch byteToLower(b) { + case 't': + st = 1922 + default: + return length + } + + case 1922: + switch byteToLower(b) { + case 'w': + st = 1923 + default: + return length + } + + case 1923: + switch byteToLower(b) { + case 'a': + st = 1924 + default: + return length + } + + case 1924: + switch byteToLower(b) { + case 'r': + st = 1925 + default: + return length + } + + case 1925: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1926 + default: + return length + } + + case 1927: + switch byteToLower(b) { + case 'u': + length = i + 1 + st = 1928 + default: + return length + } + + case 1929: + switch byteToLower(b) { + case 'a': + st = 1930 + case 'u': + st = 1932 + default: + return length + } + + case 1930: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 1931 + default: + return length + } + + case 1932: + switch byteToLower(b) { + case 't': + st = 1933 + default: + return length + } + + case 1933: + switch byteToLower(b) { + case 'i': + st = 1934 + default: + return length + } + + case 1934: + switch byteToLower(b) { + case 'o': + st = 1935 + default: + return length + } + + case 1935: + switch byteToLower(b) { + case 'n': + st = 1936 + default: + return length + } + + case 1936: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1937 + default: + return length + } + + case 1938: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1939 + default: + return length + } + + case 1941: + switch byteToLower(b) { + case 'a': + st = 1942 + case 'i': + st = 1945 + case 'r': + st = 1950 + default: + return length + } + + case 1942: + switch byteToLower(b) { + case 'c': + st = 1943 + default: + return length + } + + case 1943: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1944 + default: + return length + } + + case 1945: + switch byteToLower(b) { + case 'e': + st = 1946 + default: + return length + } + + case 1946: + switch byteToLower(b) { + case 'g': + st = 1947 + default: + return length + } + + case 1947: + switch byteToLower(b) { + case 'e': + st = 1948 + default: + return length + } + + case 1948: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 1949 + default: + return length + } + + case 1950: + switch byteToLower(b) { + case 'e': + st = 1951 + default: + return length + } + + case 1951: + switch byteToLower(b) { + case 'a': + st = 1952 + default: + return length + } + + case 1952: + switch byteToLower(b) { + case 'd': + st = 1953 + default: + return length + } + + case 1953: + switch byteToLower(b) { + case 'b': + st = 1954 + default: + return length + } + + case 1954: + switch byteToLower(b) { + case 'e': + st = 1955 + default: + return length + } + + case 1955: + switch byteToLower(b) { + case 't': + st = 1956 + default: + return length + } + + case 1956: + switch byteToLower(b) { + case 't': + st = 1957 + default: + return length + } + + case 1957: + switch byteToLower(b) { + case 'i': + st = 1958 + default: + return length + } + + case 1958: + switch byteToLower(b) { + case 'n': + st = 1959 + default: + return length + } + + case 1959: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 1960 + default: + return length + } + + case 1962: + switch byteToLower(b) { + case 'u': + st = 1963 + case 'y': + st = 1966 + default: + return length + } + + case 1963: + switch byteToLower(b) { + case 'd': + st = 1964 + default: + return length + } + + case 1964: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1965 + default: + return length + } + + case 1966: + switch byteToLower(b) { + case 'l': + st = 1967 + default: + return length + } + + case 1967: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 1968 + default: + return length + } + + case 1969: + switch byteToLower(b) { + case 'c': + st = 1970 + case 'p': + st = 1973 + case 'r': + st = 1983 + case 'z': + st = 1989 + default: + return length + } + + case 1970: + switch byteToLower(b) { + case 'k': + st = 1971 + default: + return length + } + + case 1971: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1972 + default: + return length + } + + case 1973: + switch byteToLower(b) { + case 'p': + st = 1974 + default: + return length + } + + case 1974: + switch byteToLower(b) { + case 'l': + st = 1975 + case 'o': + st = 1980 + default: + return length + } + + case 1975: + switch byteToLower(b) { + case 'i': + st = 1976 + case 'y': + length = i + 1 + st = 1979 + default: + return length + } + + case 1976: + switch byteToLower(b) { + case 'e': + st = 1977 + default: + return length + } + + case 1977: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1978 + default: + return length + } + + case 1980: + switch byteToLower(b) { + case 'r': + st = 1981 + default: + return length + } + + case 1981: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 1982 + default: + return length + } + + case 1983: + switch byteToLower(b) { + case 'f': + length = i + 1 + st = 1984 + case 'g': + st = 1985 + default: + return length + } + + case 1985: + switch byteToLower(b) { + case 'e': + st = 1986 + default: + return length + } + + case 1986: + switch byteToLower(b) { + case 'r': + st = 1987 + default: + return length + } + + case 1987: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 1988 + default: + return length + } + + case 1989: + switch byteToLower(b) { + case 'u': + st = 1990 + default: + return length + } + + case 1990: + switch byteToLower(b) { + case 'k': + st = 1991 + default: + return length + } + + case 1991: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 1992 + default: + return length + } + + case 1994: + switch byteToLower(b) { + case 'i': + st = 1995 + default: + return length + } + + case 1995: + switch byteToLower(b) { + case 's': + st = 1996 + default: + return length + } + + case 1996: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 1997 + default: + return length + } + + case 1999: + switch byteToLower(b) { + case 'd': + st = 2000 + case 's': + st = 2004 + default: + return length + } + + case 2000: + switch byteToLower(b) { + case 'n': + st = 2001 + default: + return length + } + + case 2001: + switch byteToLower(b) { + case 'e': + st = 2002 + default: + return length + } + + case 2002: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 2003 + default: + return length + } + + case 2004: + switch byteToLower(b) { + case 't': + st = 2005 + default: + return length + } + + case 2005: + switch byteToLower(b) { + case 'e': + st = 2006 + default: + return length + } + + case 2006: + switch byteToLower(b) { + case 'm': + st = 2007 + default: + return length + } + + case 2007: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2008 + default: + return length + } + + case 2010: + switch byteToLower(b) { + case 'a': + st = 2011 + case 'c': + length = i + 1 + st = 2024 + case 'd': + length = i + 1 + st = 2025 + case 'e': + st = 2026 + case 'f': + length = i + 1 + st = 2047 + case 'g': + length = i + 1 + st = 2048 + case 'h': + length = i + 1 + st = 2049 + case 'i': + st = 2056 + case 'j': + length = i + 1 + st = 2073 + case 'k': + length = i + 1 + st = 2074 + case 'l': + length = i + 1 + st = 2075 + case 'm': + length = i + 1 + st = 2076 + case 'n': + length = i + 1 + st = 2077 + case 'o': + length = i + 1 + st = 2078 + case 'r': + length = i + 1 + st = 2104 + case 't': + length = i + 1 + st = 2122 + case 'u': + st = 2123 + case 'v': + length = i + 1 + st = 2125 + case 'w': + length = i + 1 + st = 2126 + case 'z': + length = i + 1 + st = 2127 + default: + return length + } + + case 2011: + switch byteToLower(b) { + case 'i': + st = 2012 + case 't': + st = 2016 + case 'x': + length = i + 1 + st = 2022 + default: + return length + } + + case 2012: + switch byteToLower(b) { + case 'p': + st = 2013 + default: + return length + } + + case 2013: + switch byteToLower(b) { + case 'e': + st = 2014 + default: + return length + } + + case 2014: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 2015 + default: + return length + } + + case 2016: + switch byteToLower(b) { + case 'a': + st = 2017 + case 't': + st = 2019 + default: + return length + } + + case 2017: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 2018 + default: + return length + } + + case 2019: + switch byteToLower(b) { + case 'o': + st = 2020 + default: + return length + } + + case 2020: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 2021 + default: + return length + } + + case 2022: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 2023 + default: + return length + } + + case 2026: + switch byteToLower(b) { + case 'a': + st = 2027 + case 'c': + st = 2029 + case 'l': + length = i + 1 + st = 2037 + case 'm': + st = 2038 + case 'n': + st = 2043 + default: + return length + } + + case 2027: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 2028 + default: + return length + } + + case 2029: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 2030 + default: + return length + } + + case 2030: + switch byteToLower(b) { + case 'n': + st = 2031 + default: + return length + } + + case 2031: + switch byteToLower(b) { + case 'o': + st = 2032 + default: + return length + } + + case 2032: + switch byteToLower(b) { + case 'l': + st = 2033 + default: + return length + } + + case 2033: + switch byteToLower(b) { + case 'o': + st = 2034 + default: + return length + } + + case 2034: + switch byteToLower(b) { + case 'g': + st = 2035 + default: + return length + } + + case 2035: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 2036 + default: + return length + } + + case 2038: + switch byteToLower(b) { + case 'a': + st = 2039 + default: + return length + } + + case 2039: + switch byteToLower(b) { + case 's': + st = 2040 + default: + return length + } + + case 2040: + switch byteToLower(b) { + case 'e': + st = 2041 + default: + return length + } + + case 2041: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 2042 + default: + return length + } + + case 2043: + switch byteToLower(b) { + case 'n': + st = 2044 + default: + return length + } + + case 2044: + switch byteToLower(b) { + case 'i': + st = 2045 + default: + return length + } + + case 2045: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2046 + default: + return length + } + + case 2049: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 2050 + case 'e': + st = 2051 + default: + return length + } + + case 2051: + switch byteToLower(b) { + case 'a': + st = 2052 + default: + return length + } + + case 2052: + switch byteToLower(b) { + case 't': + st = 2053 + default: + return length + } + + case 2053: + switch byteToLower(b) { + case 'e': + st = 2054 + default: + return length + } + + case 2054: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 2055 + default: + return length + } + + case 2056: + switch byteToLower(b) { + case 'c': + st = 2057 + case 'e': + st = 2062 + case 'p': + st = 2066 + case 'r': + st = 2068 + default: + return length + } + + case 2057: + switch byteToLower(b) { + case 'k': + st = 2058 + default: + return length + } + + case 2058: + switch byteToLower(b) { + case 'e': + st = 2059 + default: + return length + } + + case 2059: + switch byteToLower(b) { + case 't': + st = 2060 + default: + return length + } + + case 2060: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2061 + default: + return length + } + + case 2062: + switch byteToLower(b) { + case 'n': + st = 2063 + default: + return length + } + + case 2063: + switch byteToLower(b) { + case 'd': + st = 2064 + default: + return length + } + + case 2064: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2065 + default: + return length + } + + case 2066: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2067 + default: + return length + } + + case 2068: + switch byteToLower(b) { + case 'e': + st = 2069 + case 'o': + st = 2071 + default: + return length + } + + case 2069: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2070 + default: + return length + } + + case 2071: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 2072 + default: + return length + } + + case 2078: + switch byteToLower(b) { + case 'd': + st = 2079 + case 'k': + st = 2082 + case 'o': + st = 2085 + case 'p': + length = i + 1 + st = 2088 + case 'r': + st = 2089 + case 's': + st = 2092 + case 'u': + st = 2097 + case 'w': + st = 2100 + case 'y': + st = 2102 + default: + return length + } + + case 2079: + switch byteToLower(b) { + case 'a': + st = 2080 + default: + return length + } + + case 2080: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 2081 + default: + return length + } + + case 2082: + switch byteToLower(b) { + case 'y': + st = 2083 + default: + return length + } + + case 2083: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 2084 + default: + return length + } + + case 2085: + switch byteToLower(b) { + case 'l': + st = 2086 + default: + return length + } + + case 2086: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2087 + default: + return length + } + + case 2089: + switch byteToLower(b) { + case 'a': + st = 2090 + default: + return length + } + + case 2090: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 2091 + default: + return length + } + + case 2092: + switch byteToLower(b) { + case 'h': + st = 2093 + default: + return length + } + + case 2093: + switch byteToLower(b) { + case 'i': + st = 2094 + default: + return length + } + + case 2094: + switch byteToLower(b) { + case 'b': + st = 2095 + default: + return length + } + + case 2095: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2096 + default: + return length + } + + case 2097: + switch byteToLower(b) { + case 'r': + st = 2098 + default: + return length + } + + case 2098: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2099 + default: + return length + } + + case 2100: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 2101 + default: + return length + } + + case 2102: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2103 + default: + return length + } + + case 2104: + switch byteToLower(b) { + case 'a': + st = 2105 + case 'u': + st = 2119 + default: + return length + } + + case 2105: + switch byteToLower(b) { + case 'd': + st = 2106 + case 'i': + st = 2111 + case 'v': + st = 2116 + default: + return length + } + + case 2106: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 2107 + case 'i': + st = 2108 + default: + return length + } + + case 2108: + switch byteToLower(b) { + case 'n': + st = 2109 + default: + return length + } + + case 2109: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 2110 + default: + return length + } + + case 2111: + switch byteToLower(b) { + case 'n': + st = 2112 + default: + return length + } + + case 2112: + switch byteToLower(b) { + case 'i': + st = 2113 + default: + return length + } + + case 2113: + switch byteToLower(b) { + case 'n': + st = 2114 + default: + return length + } + + case 2114: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 2115 + default: + return length + } + + case 2116: + switch byteToLower(b) { + case 'e': + st = 2117 + default: + return length + } + + case 2117: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 2118 + default: + return length + } + + case 2119: + switch byteToLower(b) { + case 's': + st = 2120 + default: + return length + } + + case 2120: + switch byteToLower(b) { + case 't': + length = i + 1 + st = 2121 + default: + return length + } + + case 2123: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 2124 + default: + return length + } + + case 2128: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2129 + case 'g': + length = i + 1 + st = 2130 + case 'k': + length = i + 1 + st = 2131 + case 'n': + st = 2132 + case 'o': + st = 2142 + case 's': + length = i + 1 + st = 2144 + case 'y': + length = i + 1 + st = 2145 + case 'z': + length = i + 1 + st = 2146 + default: + return length + } + + case 2132: + switch byteToLower(b) { + case 'i': + st = 2133 + case 'o': + length = i + 1 + st = 2141 + default: + return length + } + + case 2133: + switch byteToLower(b) { + case 'v': + st = 2134 + default: + return length + } + + case 2134: + switch byteToLower(b) { + case 'e': + st = 2135 + default: + return length + } + + case 2135: + switch byteToLower(b) { + case 'r': + st = 2136 + default: + return length + } + + case 2136: + switch byteToLower(b) { + case 's': + st = 2137 + default: + return length + } + + case 2137: + switch byteToLower(b) { + case 'i': + st = 2138 + default: + return length + } + + case 2138: + switch byteToLower(b) { + case 't': + st = 2139 + default: + return length + } + + case 2139: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 2140 + default: + return length + } + + case 2142: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 2143 + default: + return length + } + + case 2147: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2148 + case 'c': + length = i + 1 + st = 2156 + case 'e': + length = i + 1 + st = 2157 + case 'g': + length = i + 1 + st = 2178 + case 'i': + length = i + 1 + st = 2179 + case 'l': + st = 2195 + case 'n': + length = i + 1 + st = 2204 + case 'o': + st = 2205 + case 'u': + length = i + 1 + st = 2219 + default: + return length + } + + case 2148: + switch byteToLower(b) { + case 'c': + st = 2149 + default: + return length + } + + case 2149: + switch byteToLower(b) { + case 'a': + st = 2150 + default: + return length + } + + case 2150: + switch byteToLower(b) { + case 't': + st = 2151 + default: + return length + } + + case 2151: + switch byteToLower(b) { + case 'i': + st = 2152 + default: + return length + } + + case 2152: + switch byteToLower(b) { + case 'o': + st = 2153 + default: + return length + } + + case 2153: + switch byteToLower(b) { + case 'n': + st = 2154 + default: + return length + } + + case 2154: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2155 + default: + return length + } + + case 2157: + switch byteToLower(b) { + case 'g': + st = 2158 + case 'n': + st = 2161 + case 'r': + st = 2167 + case 't': + length = i + 1 + st = 2177 + default: + return length + } + + case 2158: + switch byteToLower(b) { + case 'a': + st = 2159 + default: + return length + } + + case 2159: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2160 + default: + return length + } + + case 2161: + switch byteToLower(b) { + case 't': + st = 2162 + default: + return length + } + + case 2162: + switch byteToLower(b) { + case 'u': + st = 2163 + default: + return length + } + + case 2163: + switch byteToLower(b) { + case 'r': + st = 2164 + default: + return length + } + + case 2164: + switch byteToLower(b) { + case 'e': + st = 2165 + default: + return length + } + + case 2165: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2166 + default: + return length + } + + case 2167: + switch byteToLower(b) { + case 's': + st = 2168 + default: + return length + } + + case 2168: + switch byteToLower(b) { + case 'i': + st = 2169 + default: + return length + } + + case 2169: + switch byteToLower(b) { + case 'c': + st = 2170 + default: + return length + } + + case 2170: + switch byteToLower(b) { + case 'h': + st = 2171 + default: + return length + } + + case 2171: + switch byteToLower(b) { + case 'e': + st = 2172 + default: + return length + } + + case 2172: + switch byteToLower(b) { + case 'r': + st = 2173 + default: + return length + } + + case 2173: + switch byteToLower(b) { + case 'u': + st = 2174 + default: + return length + } + + case 2174: + switch byteToLower(b) { + case 'n': + st = 2175 + default: + return length + } + + case 2175: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 2176 + default: + return length + } + + case 2179: + switch byteToLower(b) { + case 'a': + st = 2180 + case 'd': + st = 2184 + case 'l': + st = 2187 + case 's': + st = 2191 + default: + return length + } + + case 2180: + switch byteToLower(b) { + case 'j': + st = 2181 + default: + return length + } + + case 2181: + switch byteToLower(b) { + case 'e': + st = 2182 + default: + return length + } + + case 2182: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2183 + default: + return length + } + + case 2184: + switch byteToLower(b) { + case 'e': + st = 2185 + default: + return length + } + + case 2185: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 2186 + default: + return length + } + + case 2187: + switch byteToLower(b) { + case 'l': + st = 2188 + default: + return length + } + + case 2188: + switch byteToLower(b) { + case 'a': + st = 2189 + default: + return length + } + + case 2189: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2190 + default: + return length + } + + case 2191: + switch byteToLower(b) { + case 'i': + st = 2192 + default: + return length + } + + case 2192: + switch byteToLower(b) { + case 'o': + st = 2193 + default: + return length + } + + case 2193: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 2194 + default: + return length + } + + case 2195: + switch byteToLower(b) { + case 'a': + st = 2196 + default: + return length + } + + case 2196: + switch byteToLower(b) { + case 'a': + st = 2197 + default: + return length + } + + case 2197: + switch byteToLower(b) { + case 'n': + st = 2198 + default: + return length + } + + case 2198: + switch byteToLower(b) { + case 'd': + st = 2199 + default: + return length + } + + case 2199: + switch byteToLower(b) { + case 'e': + st = 2200 + default: + return length + } + + case 2200: + switch byteToLower(b) { + case 'r': + st = 2201 + default: + return length + } + + case 2201: + switch byteToLower(b) { + case 'e': + st = 2202 + default: + return length + } + + case 2202: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 2203 + default: + return length + } + + case 2205: + switch byteToLower(b) { + case 'd': + st = 2206 + case 't': + st = 2209 + case 'y': + st = 2215 + default: + return length + } + + case 2206: + switch byteToLower(b) { + case 'k': + st = 2207 + default: + return length + } + + case 2207: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2208 + default: + return length + } + + case 2209: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 2210 + case 'i': + st = 2211 + case 'o': + length = i + 1 + st = 2214 + default: + return length + } + + case 2211: + switch byteToLower(b) { + case 'n': + st = 2212 + default: + return length + } + + case 2212: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 2213 + default: + return length + } + + case 2215: + switch byteToLower(b) { + case 'a': + st = 2216 + default: + return length + } + + case 2216: + switch byteToLower(b) { + case 'g': + st = 2217 + default: + return length + } + + case 2217: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 2218 + default: + return length + } + + case 2220: + switch byteToLower(b) { + case 'a': + st = 2221 + case 'e': + st = 2233 + case 'f': + length = i + 1 + st = 2249 + case 'h': + st = 2250 + case 'i': + st = 2256 + case 'm': + st = 2271 + case 'o': + st = 2273 + case 's': + length = i + 1 + st = 2279 + case 't': + st = 2280 + default: + return length + } + + case 2221: + switch byteToLower(b) { + case 'l': + st = 2222 + case 'n': + st = 2228 + case 't': + st = 2230 + default: + return length + } + + case 2222: + switch byteToLower(b) { + case 'e': + st = 2223 + case 't': + st = 2225 + default: + return length + } + + case 2223: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2224 + default: + return length + } + + case 2225: + switch byteToLower(b) { + case 'e': + st = 2226 + default: + return length + } + + case 2226: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 2227 + default: + return length + } + + case 2228: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 2229 + default: + return length + } + + case 2230: + switch byteToLower(b) { + case 'c': + st = 2231 + default: + return length + } + + case 2231: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 2232 + default: + return length + } + + case 2233: + switch byteToLower(b) { + case 'b': + st = 2234 + case 'd': + length = i + 1 + st = 2242 + case 'i': + st = 2247 + default: + return length + } + + case 2234: + switch byteToLower(b) { + case 'c': + st = 2235 + case 's': + st = 2238 + default: + return length + } + + case 2235: + switch byteToLower(b) { + case 'a': + st = 2236 + default: + return length + } + + case 2236: + switch byteToLower(b) { + case 'm': + length = i + 1 + st = 2237 + default: + return length + } + + case 2238: + switch byteToLower(b) { + case 'i': + st = 2239 + default: + return length + } + + case 2239: + switch byteToLower(b) { + case 't': + st = 2240 + default: + return length + } + + case 2240: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 2241 + default: + return length + } + + case 2242: + switch byteToLower(b) { + case 'd': + st = 2243 + default: + return length + } + + case 2243: + switch byteToLower(b) { + case 'i': + st = 2244 + default: + return length + } + + case 2244: + switch byteToLower(b) { + case 'n': + st = 2245 + default: + return length + } + + case 2245: + switch byteToLower(b) { + case 'g': + length = i + 1 + st = 2246 + default: + return length + } + + case 2247: + switch byteToLower(b) { + case 'r': + length = i + 1 + st = 2248 + default: + return length + } + + case 2250: + switch byteToLower(b) { + case 'o': + st = 2251 + default: + return length + } + + case 2251: + switch byteToLower(b) { + case 's': + st = 2252 + default: + return length + } + + case 2252: + switch byteToLower(b) { + case 'w': + st = 2253 + default: + return length + } + + case 2253: + switch byteToLower(b) { + case 'h': + st = 2254 + default: + return length + } + + case 2254: + switch byteToLower(b) { + case 'o': + length = i + 1 + st = 2255 + default: + return length + } + + case 2256: + switch byteToLower(b) { + case 'e': + st = 2257 + case 'k': + st = 2259 + case 'l': + st = 2261 + case 'n': + length = i + 1 + st = 2270 + default: + return length + } + + case 2257: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 2258 + default: + return length + } + + case 2259: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 2260 + default: + return length + } + + case 2261: + switch byteToLower(b) { + case 'l': + st = 2262 + default: + return length + } + + case 2262: + switch byteToLower(b) { + case 'i': + st = 2263 + default: + return length + } + + case 2263: + switch byteToLower(b) { + case 'a': + st = 2264 + default: + return length + } + + case 2264: + switch byteToLower(b) { + case 'm': + st = 2265 + default: + return length + } + + case 2265: + switch byteToLower(b) { + case 'h': + st = 2266 + default: + return length + } + + case 2266: + switch byteToLower(b) { + case 'i': + st = 2267 + default: + return length + } + + case 2267: + switch byteToLower(b) { + case 'l': + st = 2268 + default: + return length + } + + case 2268: + switch byteToLower(b) { + case 'l': + length = i + 1 + st = 2269 + default: + return length + } + + case 2271: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 2272 + default: + return length + } + + case 2273: + switch byteToLower(b) { + case 'r': + st = 2274 + default: + return length + } + + case 2274: + switch byteToLower(b) { + case 'k': + length = i + 1 + st = 2275 + case 'l': + st = 2277 + default: + return length + } + + case 2275: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2276 + default: + return length + } + + case 2277: + switch byteToLower(b) { + case 'd': + length = i + 1 + st = 2278 + default: + return length + } + + case 2280: + switch byteToLower(b) { + case 'c': + length = i + 1 + st = 2281 + case 'f': + length = i + 1 + st = 2282 + default: + return length + } + + case 2283: + switch byteToLower(b) { + case 'b': + st = 2284 + case 'e': + st = 2287 + case 'i': + st = 2291 + case 'x': + st = 2293 + case 'y': + st = 2295 + case 'n': + st = 2860 + default: + return length + } + + case 2284: + switch byteToLower(b) { + case 'o': + st = 2285 + default: + return length + } + + case 2285: + switch byteToLower(b) { + case 'x': + length = i + 1 + st = 2286 + default: + return length + } + + case 2287: + switch byteToLower(b) { + case 'r': + st = 2288 + default: + return length + } + + case 2288: + switch byteToLower(b) { + case 'o': + st = 2289 + default: + return length + } + + case 2289: + switch byteToLower(b) { + case 'x': + length = i + 1 + st = 2290 + default: + return length + } + + case 2291: + switch byteToLower(b) { + case 'n': + length = i + 1 + st = 2292 + default: + return length + } + + case 2293: + switch byteToLower(b) { + case 'x': + length = i + 1 + st = 2294 + default: + return length + } + + case 2295: + switch byteToLower(b) { + case 'z': + length = i + 1 + st = 2296 + default: + return length + } + + case 2297: + switch byteToLower(b) { + case 'a': + st = 2298 + case 'e': + length = i + 1 + st = 2307 + case 'o': + st = 2308 + case 't': + length = i + 1 + st = 2329 + default: + return length + } + + case 2298: + switch byteToLower(b) { + case 'c': + st = 2299 + case 'n': + st = 2303 + default: + return length + } + + case 2299: + switch byteToLower(b) { + case 'h': + st = 2300 + default: + return length + } + + case 2300: + switch byteToLower(b) { + case 't': + st = 2301 + default: + return length + } + + case 2301: + switch byteToLower(b) { + case 's': + length = i + 1 + st = 2302 + default: + return length + } + + case 2303: + switch byteToLower(b) { + case 'd': + st = 2304 + default: + return length + } + + case 2304: + switch byteToLower(b) { + case 'e': + st = 2305 + default: + return length + } + + case 2305: + switch byteToLower(b) { + case 'x': + length = i + 1 + st = 2306 + default: + return length + } + + case 2308: + switch byteToLower(b) { + case 'd': + st = 2309 + case 'g': + st = 2316 + case 'k': + st = 2318 + case 'u': + st = 2324 + default: + return length + } + + case 2309: + switch byteToLower(b) { + case 'o': + st = 2310 + default: + return length + } + + case 2310: + switch byteToLower(b) { + case 'b': + st = 2311 + default: + return length + } + + case 2311: + switch byteToLower(b) { + case 'a': + st = 2312 + default: + return length + } + + case 2312: + switch byteToLower(b) { + case 's': + st = 2313 + default: + return length + } + + case 2313: + switch byteToLower(b) { + case 'h': + st = 2314 + default: + return length + } + + case 2314: + switch byteToLower(b) { + case 'i': + length = i + 1 + st = 2315 + default: + return length + } + + case 2316: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2317 + default: + return length + } + + case 2318: + switch byteToLower(b) { + case 'o': + st = 2319 + default: + return length + } + + case 2319: + switch byteToLower(b) { + case 'h': + st = 2320 + default: + return length + } + + case 2320: + switch byteToLower(b) { + case 'a': + st = 2321 + default: + return length + } + + case 2321: + switch byteToLower(b) { + case 'm': + st = 2322 + default: + return length + } + + case 2322: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2323 + default: + return length + } + + case 2324: + switch byteToLower(b) { + case 't': + st = 2325 + default: + return length + } + + case 2325: + switch byteToLower(b) { + case 'u': + st = 2326 + default: + return length + } + + case 2326: + switch byteToLower(b) { + case 'b': + st = 2327 + default: + return length + } + + case 2327: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 2328 + default: + return length + } + + case 2330: + switch byteToLower(b) { + case 'a': + length = i + 1 + st = 2331 + case 'i': + st = 2332 + case 'k': + st = 2334 + case 'm': + length = i + 1 + st = 2337 + case 'o': + st = 2338 + case 'u': + st = 2341 + case 'w': + length = i + 1 + st = 2347 + default: + return length + } + + case 2332: + switch byteToLower(b) { + case 'p': + length = i + 1 + st = 2333 + default: + return length + } + + case 2334: + switch byteToLower(b) { + case 'e': + st = 2335 + default: + return length + } + + case 2335: + switch byteToLower(b) { + case 'y': + length = i + 1 + st = 2336 + default: + return length + } + + case 2338: + switch byteToLower(b) { + case 'n': + st = 2339 + default: + return length + } + + case 2339: + switch byteToLower(b) { + case 'e': + length = i + 1 + st = 2340 + default: + return length + } + + case 2341: + switch byteToLower(b) { + case 'e': + st = 2342 + default: + return length + } + + case 2342: + switch byteToLower(b) { + case 'r': + st = 2343 + default: + return length + } + + case 2343: + switch byteToLower(b) { + case 'i': + st = 2344 + default: + return length + } + + case 2344: + switch byteToLower(b) { + case 'c': + st = 2345 + default: + return length + } + + case 2345: + switch byteToLower(b) { + case 'h': + length = i + 1 + st = 2346 + default: + return length + } + + case 2348: + switch b { + case '.': + length = i + 1 + st = 2349 + default: + return length + } + + case 2350: + switch b { + case '.': + length = i + 1 + st = 2351 + case '0': + st = 2368 + case '1': + st = 2370 + case '2': + st = 2372 + case '3': + st = 2374 + case '4': + st = 2376 + case '5': + st = 2378 + case '6': + st = 2380 + case '7': + st = 2382 + case '8': + st = 2384 + case '9': + st = 2386 + default: + return length + } + + case 2352: + switch b { + case '.': + length = i + 1 + st = 2353 + case '0': + st = 2388 + case '1': + st = 2390 + case '2': + st = 2392 + case '3': + st = 2394 + case '4': + st = 2396 + case '5': + st = 2398 + case '6': + st = 2400 + case '7': + st = 2402 + case '8': + st = 2404 + case '9': + st = 2406 + default: + return length + } + + case 2354: + switch b { + case '.': + length = i + 1 + st = 2355 + case '0': + st = 2408 + case '1': + st = 2410 + case '2': + st = 2412 + case '3': + st = 2414 + case '4': + st = 2416 + case '5': + st = 2418 + case '6': + st = 2420 + case '7': + st = 2422 + case '8': + st = 2424 + case '9': + st = 2426 + default: + return length + } + + case 2356: + switch b { + case '.': + length = i + 1 + st = 2357 + case '0': + st = 2428 + case '1': + st = 2430 + case '2': + st = 2432 + case '3': + st = 2434 + case '4': + st = 2436 + case '5': + st = 2438 + case '6': + st = 2440 + case '7': + st = 2442 + case '8': + st = 2444 + case '9': + st = 2446 + default: + return length + } + + case 2358: + switch b { + case '.': + length = i + 1 + st = 2359 + case '0': + st = 2448 + case '1': + st = 2450 + case '2': + st = 2452 + case '3': + st = 2454 + case '4': + st = 2456 + case '5': + st = 2458 + case '6': + st = 2460 + case '7': + st = 2462 + case '8': + st = 2464 + case '9': + st = 2466 + default: + return length + } + + case 2360: + switch b { + case '.': + length = i + 1 + st = 2361 + case '0': + st = 2468 + case '1': + st = 2470 + case '2': + st = 2472 + case '3': + st = 2474 + case '4': + st = 2476 + case '5': + st = 2478 + case '6': + st = 2480 + case '7': + st = 2482 + case '8': + st = 2484 + case '9': + st = 2486 + default: + return length + } + + case 2362: + switch b { + case '.': + length = i + 1 + st = 2363 + case '0': + st = 2488 + case '1': + st = 2490 + case '2': + st = 2492 + case '3': + st = 2494 + case '4': + st = 2496 + case '5': + st = 2498 + case '6': + st = 2500 + case '7': + st = 2502 + case '8': + st = 2504 + case '9': + st = 2506 + default: + return length + } + + case 2364: + switch b { + case '.': + length = i + 1 + st = 2365 + case '0': + st = 2508 + case '1': + st = 2510 + case '2': + st = 2512 + case '3': + st = 2514 + case '4': + st = 2516 + case '5': + st = 2518 + case '6': + st = 2520 + case '7': + st = 2522 + case '8': + st = 2524 + case '9': + st = 2526 + default: + return length + } + + case 2366: + switch b { + case '.': + length = i + 1 + st = 2367 + case '0': + st = 2528 + case '1': + st = 2530 + case '2': + st = 2532 + case '3': + st = 2534 + case '4': + st = 2536 + case '5': + st = 2538 + case '6': + st = 2540 + case '7': + st = 2542 + case '8': + st = 2544 + case '9': + st = 2546 + default: + return length + } + + case 2368: + switch b { + case '.': + length = i + 1 + st = 2369 + case '0': + st = 2548 + case '1': + st = 2550 + case '2': + st = 2552 + case '3': + st = 2554 + case '4': + st = 2556 + case '5': + st = 2558 + case '6': + st = 2560 + case '7': + st = 2562 + case '8': + st = 2564 + case '9': + st = 2566 + default: + return length + } + + case 2370: + switch b { + case '.': + length = i + 1 + st = 2371 + case '0': + st = 2568 + case '1': + st = 2570 + case '2': + st = 2572 + case '3': + st = 2574 + case '4': + st = 2576 + case '5': + st = 2578 + case '6': + st = 2580 + case '7': + st = 2582 + case '8': + st = 2584 + case '9': + st = 2586 + default: + return length + } + + case 2372: + switch b { + case '.': + length = i + 1 + st = 2373 + case '0': + st = 2588 + case '1': + st = 2590 + case '2': + st = 2592 + case '3': + st = 2594 + case '4': + st = 2596 + case '5': + st = 2598 + case '6': + st = 2600 + case '7': + st = 2602 + case '8': + st = 2604 + case '9': + st = 2606 + default: + return length + } + + case 2374: + switch b { + case '.': + length = i + 1 + st = 2375 + case '0': + st = 2608 + case '1': + st = 2610 + case '2': + st = 2612 + case '3': + st = 2614 + case '4': + st = 2616 + case '5': + st = 2618 + case '6': + st = 2620 + case '7': + st = 2622 + case '8': + st = 2624 + case '9': + st = 2626 + default: + return length + } + + case 2376: + switch b { + case '.': + length = i + 1 + st = 2377 + case '0': + st = 2628 + case '1': + st = 2630 + case '2': + st = 2632 + case '3': + st = 2634 + case '4': + st = 2636 + case '5': + st = 2638 + case '6': + st = 2640 + case '7': + st = 2642 + case '8': + st = 2644 + case '9': + st = 2646 + default: + return length + } + + case 2378: + switch b { + case '.': + length = i + 1 + st = 2379 + case '0': + st = 2648 + case '1': + st = 2650 + case '2': + st = 2652 + case '3': + st = 2654 + case '4': + st = 2656 + case '5': + st = 2658 + case '6': + st = 2660 + case '7': + st = 2662 + case '8': + st = 2664 + case '9': + st = 2666 + default: + return length + } + + case 2380: + switch b { + case '.': + length = i + 1 + st = 2381 + case '0': + st = 2668 + case '1': + st = 2670 + case '2': + st = 2672 + case '3': + st = 2674 + case '4': + st = 2676 + case '5': + st = 2678 + case '6': + st = 2680 + case '7': + st = 2682 + case '8': + st = 2684 + case '9': + st = 2686 + default: + return length + } + + case 2382: + switch b { + case '.': + length = i + 1 + st = 2383 + case '0': + st = 2688 + case '1': + st = 2690 + case '2': + st = 2692 + case '3': + st = 2694 + case '4': + st = 2696 + case '5': + st = 2698 + case '6': + st = 2700 + case '7': + st = 2702 + case '8': + st = 2704 + case '9': + st = 2706 + default: + return length + } + + case 2384: + switch b { + case '.': + length = i + 1 + st = 2385 + case '0': + st = 2708 + case '1': + st = 2710 + case '2': + st = 2712 + case '3': + st = 2714 + case '4': + st = 2716 + case '5': + st = 2718 + case '6': + st = 2720 + case '7': + st = 2722 + case '8': + st = 2724 + case '9': + st = 2726 + default: + return length + } + + case 2386: + switch b { + case '.': + length = i + 1 + st = 2387 + case '0': + st = 2728 + case '1': + st = 2730 + case '2': + st = 2732 + case '3': + st = 2734 + case '4': + st = 2736 + case '5': + st = 2738 + case '6': + st = 2740 + case '7': + st = 2742 + case '8': + st = 2744 + case '9': + st = 2746 + default: + return length + } + + case 2388: + switch b { + case '.': + length = i + 1 + st = 2389 + case '0': + st = 2748 + case '1': + st = 2750 + case '2': + st = 2752 + case '3': + st = 2754 + case '4': + st = 2756 + case '5': + st = 2758 + case '6': + st = 2760 + case '7': + st = 2762 + case '8': + st = 2764 + case '9': + st = 2766 + default: + return length + } + + case 2390: + switch b { + case '.': + length = i + 1 + st = 2391 + case '0': + st = 2768 + case '1': + st = 2770 + case '2': + st = 2772 + case '3': + st = 2774 + case '4': + st = 2776 + case '5': + st = 2778 + case '6': + st = 2780 + case '7': + st = 2782 + case '8': + st = 2784 + case '9': + st = 2786 + default: + return length + } + + case 2392: + switch b { + case '.': + length = i + 1 + st = 2393 + case '0': + st = 2788 + case '1': + st = 2790 + case '2': + st = 2792 + case '3': + st = 2794 + case '4': + st = 2796 + case '5': + st = 2798 + case '6': + st = 2800 + case '7': + st = 2802 + case '8': + st = 2804 + case '9': + st = 2806 + default: + return length + } + + case 2394: + switch b { + case '.': + length = i + 1 + st = 2395 + case '0': + st = 2808 + case '1': + st = 2810 + case '2': + st = 2812 + case '3': + st = 2814 + case '4': + st = 2816 + case '5': + st = 2818 + case '6': + st = 2820 + case '7': + st = 2822 + case '8': + st = 2824 + case '9': + st = 2826 + default: + return length + } + + case 2396: + switch b { + case '.': + length = i + 1 + st = 2397 + case '0': + st = 2828 + case '1': + st = 2830 + case '2': + st = 2832 + case '3': + st = 2834 + case '4': + st = 2836 + case '5': + st = 2838 + case '6': + st = 2840 + case '7': + st = 2842 + case '8': + st = 2844 + case '9': + st = 2846 + default: + return length + } + + case 2398: + switch b { + case '.': + length = i + 1 + st = 2399 + case '0': + st = 2848 + case '1': + st = 2850 + case '2': + st = 2852 + case '3': + st = 2854 + case '4': + st = 2856 + case '5': + st = 2858 + default: + return length + } + + case 2400: + switch b { + case '.': + length = i + 1 + st = 2401 + default: + return length + } + + case 2402: + switch b { + case '.': + length = i + 1 + st = 2403 + default: + return length + } + + case 2404: + switch b { + case '.': + length = i + 1 + st = 2405 + default: + return length + } + + case 2406: + switch b { + case '.': + length = i + 1 + st = 2407 + default: + return length + } + + case 2408: + switch b { + case '.': + length = i + 1 + st = 2409 + default: + return length + } + + case 2410: + switch b { + case '.': + length = i + 1 + st = 2411 + default: + return length + } + + case 2412: + switch b { + case '.': + length = i + 1 + st = 2413 + default: + return length + } + + case 2414: + switch b { + case '.': + length = i + 1 + st = 2415 + default: + return length + } + + case 2416: + switch b { + case '.': + length = i + 1 + st = 2417 + default: + return length + } + + case 2418: + switch b { + case '.': + length = i + 1 + st = 2419 + default: + return length + } + + case 2420: + switch b { + case '.': + length = i + 1 + st = 2421 + default: + return length + } + + case 2422: + switch b { + case '.': + length = i + 1 + st = 2423 + default: + return length + } + + case 2424: + switch b { + case '.': + length = i + 1 + st = 2425 + default: + return length + } + + case 2426: + switch b { + case '.': + length = i + 1 + st = 2427 + default: + return length + } + + case 2428: + switch b { + case '.': + length = i + 1 + st = 2429 + default: + return length + } + + case 2430: + switch b { + case '.': + length = i + 1 + st = 2431 + default: + return length + } + + case 2432: + switch b { + case '.': + length = i + 1 + st = 2433 + default: + return length + } + + case 2434: + switch b { + case '.': + length = i + 1 + st = 2435 + default: + return length + } + + case 2436: + switch b { + case '.': + length = i + 1 + st = 2437 + default: + return length + } + + case 2438: + switch b { + case '.': + length = i + 1 + st = 2439 + default: + return length + } + + case 2440: + switch b { + case '.': + length = i + 1 + st = 2441 + default: + return length + } + + case 2442: + switch b { + case '.': + length = i + 1 + st = 2443 + default: + return length + } + + case 2444: + switch b { + case '.': + length = i + 1 + st = 2445 + default: + return length + } + + case 2446: + switch b { + case '.': + length = i + 1 + st = 2447 + default: + return length + } + + case 2448: + switch b { + case '.': + length = i + 1 + st = 2449 + default: + return length + } + + case 2450: + switch b { + case '.': + length = i + 1 + st = 2451 + default: + return length + } + + case 2452: + switch b { + case '.': + length = i + 1 + st = 2453 + default: + return length + } + + case 2454: + switch b { + case '.': + length = i + 1 + st = 2455 + default: + return length + } + + case 2456: + switch b { + case '.': + length = i + 1 + st = 2457 + default: + return length + } + + case 2458: + switch b { + case '.': + length = i + 1 + st = 2459 + default: + return length + } + + case 2460: + switch b { + case '.': + length = i + 1 + st = 2461 + default: + return length + } + + case 2462: + switch b { + case '.': + length = i + 1 + st = 2463 + default: + return length + } + + case 2464: + switch b { + case '.': + length = i + 1 + st = 2465 + default: + return length + } + + case 2466: + switch b { + case '.': + length = i + 1 + st = 2467 + default: + return length + } + + case 2468: + switch b { + case '.': + length = i + 1 + st = 2469 + default: + return length + } + + case 2470: + switch b { + case '.': + length = i + 1 + st = 2471 + default: + return length + } + + case 2472: + switch b { + case '.': + length = i + 1 + st = 2473 + default: + return length + } + + case 2474: + switch b { + case '.': + length = i + 1 + st = 2475 + default: + return length + } + + case 2476: + switch b { + case '.': + length = i + 1 + st = 2477 + default: + return length + } + + case 2478: + switch b { + case '.': + length = i + 1 + st = 2479 + default: + return length + } + + case 2480: + switch b { + case '.': + length = i + 1 + st = 2481 + default: + return length + } + + case 2482: + switch b { + case '.': + length = i + 1 + st = 2483 + default: + return length + } + + case 2484: + switch b { + case '.': + length = i + 1 + st = 2485 + default: + return length + } + + case 2486: + switch b { + case '.': + length = i + 1 + st = 2487 + default: + return length + } + + case 2488: + switch b { + case '.': + length = i + 1 + st = 2489 + default: + return length + } + + case 2490: + switch b { + case '.': + length = i + 1 + st = 2491 + default: + return length + } + + case 2492: + switch b { + case '.': + length = i + 1 + st = 2493 + default: + return length + } + + case 2494: + switch b { + case '.': + length = i + 1 + st = 2495 + default: + return length + } + + case 2496: + switch b { + case '.': + length = i + 1 + st = 2497 + default: + return length + } + + case 2498: + switch b { + case '.': + length = i + 1 + st = 2499 + default: + return length + } + + case 2500: + switch b { + case '.': + length = i + 1 + st = 2501 + default: + return length + } + + case 2502: + switch b { + case '.': + length = i + 1 + st = 2503 + default: + return length + } + + case 2504: + switch b { + case '.': + length = i + 1 + st = 2505 + default: + return length + } + + case 2506: + switch b { + case '.': + length = i + 1 + st = 2507 + default: + return length + } + + case 2508: + switch b { + case '.': + length = i + 1 + st = 2509 + default: + return length + } + + case 2510: + switch b { + case '.': + length = i + 1 + st = 2511 + default: + return length + } + + case 2512: + switch b { + case '.': + length = i + 1 + st = 2513 + default: + return length + } + + case 2514: + switch b { + case '.': + length = i + 1 + st = 2515 + default: + return length + } + + case 2516: + switch b { + case '.': + length = i + 1 + st = 2517 + default: + return length + } + + case 2518: + switch b { + case '.': + length = i + 1 + st = 2519 + default: + return length + } + + case 2520: + switch b { + case '.': + length = i + 1 + st = 2521 + default: + return length + } + + case 2522: + switch b { + case '.': + length = i + 1 + st = 2523 + default: + return length + } + + case 2524: + switch b { + case '.': + length = i + 1 + st = 2525 + default: + return length + } + + case 2526: + switch b { + case '.': + length = i + 1 + st = 2527 + default: + return length + } + + case 2528: + switch b { + case '.': + length = i + 1 + st = 2529 + default: + return length + } + + case 2530: + switch b { + case '.': + length = i + 1 + st = 2531 + default: + return length + } + + case 2532: + switch b { + case '.': + length = i + 1 + st = 2533 + default: + return length + } + + case 2534: + switch b { + case '.': + length = i + 1 + st = 2535 + default: + return length + } + + case 2536: + switch b { + case '.': + length = i + 1 + st = 2537 + default: + return length + } + + case 2538: + switch b { + case '.': + length = i + 1 + st = 2539 + default: + return length + } + + case 2540: + switch b { + case '.': + length = i + 1 + st = 2541 + default: + return length + } + + case 2542: + switch b { + case '.': + length = i + 1 + st = 2543 + default: + return length + } + + case 2544: + switch b { + case '.': + length = i + 1 + st = 2545 + default: + return length + } + + case 2546: + switch b { + case '.': + length = i + 1 + st = 2547 + default: + return length + } + + case 2548: + switch b { + case '.': + length = i + 1 + st = 2549 + default: + return length + } + + case 2550: + switch b { + case '.': + length = i + 1 + st = 2551 + default: + return length + } + + case 2552: + switch b { + case '.': + length = i + 1 + st = 2553 + default: + return length + } + + case 2554: + switch b { + case '.': + length = i + 1 + st = 2555 + default: + return length + } + + case 2556: + switch b { + case '.': + length = i + 1 + st = 2557 + default: + return length + } + + case 2558: + switch b { + case '.': + length = i + 1 + st = 2559 + default: + return length + } + + case 2560: + switch b { + case '.': + length = i + 1 + st = 2561 + default: + return length + } + + case 2562: + switch b { + case '.': + length = i + 1 + st = 2563 + default: + return length + } + + case 2564: + switch b { + case '.': + length = i + 1 + st = 2565 + default: + return length + } + + case 2566: + switch b { + case '.': + length = i + 1 + st = 2567 + default: + return length + } + + case 2568: + switch b { + case '.': + length = i + 1 + st = 2569 + default: + return length + } + + case 2570: + switch b { + case '.': + length = i + 1 + st = 2571 + default: + return length + } + + case 2572: + switch b { + case '.': + length = i + 1 + st = 2573 + default: + return length + } + + case 2574: + switch b { + case '.': + length = i + 1 + st = 2575 + default: + return length + } + + case 2576: + switch b { + case '.': + length = i + 1 + st = 2577 + default: + return length + } + + case 2578: + switch b { + case '.': + length = i + 1 + st = 2579 + default: + return length + } + + case 2580: + switch b { + case '.': + length = i + 1 + st = 2581 + default: + return length + } + + case 2582: + switch b { + case '.': + length = i + 1 + st = 2583 + default: + return length + } + + case 2584: + switch b { + case '.': + length = i + 1 + st = 2585 + default: + return length + } + + case 2586: + switch b { + case '.': + length = i + 1 + st = 2587 + default: + return length + } + + case 2588: + switch b { + case '.': + length = i + 1 + st = 2589 + default: + return length + } + + case 2590: + switch b { + case '.': + length = i + 1 + st = 2591 + default: + return length + } + + case 2592: + switch b { + case '.': + length = i + 1 + st = 2593 + default: + return length + } + + case 2594: + switch b { + case '.': + length = i + 1 + st = 2595 + default: + return length + } + + case 2596: + switch b { + case '.': + length = i + 1 + st = 2597 + default: + return length + } + + case 2598: + switch b { + case '.': + length = i + 1 + st = 2599 + default: + return length + } + + case 2600: + switch b { + case '.': + length = i + 1 + st = 2601 + default: + return length + } + + case 2602: + switch b { + case '.': + length = i + 1 + st = 2603 + default: + return length + } + + case 2604: + switch b { + case '.': + length = i + 1 + st = 2605 + default: + return length + } + + case 2606: + switch b { + case '.': + length = i + 1 + st = 2607 + default: + return length + } + + case 2608: + switch b { + case '.': + length = i + 1 + st = 2609 + default: + return length + } + + case 2610: + switch b { + case '.': + length = i + 1 + st = 2611 + default: + return length + } + + case 2612: + switch b { + case '.': + length = i + 1 + st = 2613 + default: + return length + } + + case 2614: + switch b { + case '.': + length = i + 1 + st = 2615 + default: + return length + } + + case 2616: + switch b { + case '.': + length = i + 1 + st = 2617 + default: + return length + } + + case 2618: + switch b { + case '.': + length = i + 1 + st = 2619 + default: + return length + } + + case 2620: + switch b { + case '.': + length = i + 1 + st = 2621 + default: + return length + } + + case 2622: + switch b { + case '.': + length = i + 1 + st = 2623 + default: + return length + } + + case 2624: + switch b { + case '.': + length = i + 1 + st = 2625 + default: + return length + } + + case 2626: + switch b { + case '.': + length = i + 1 + st = 2627 + default: + return length + } + + case 2628: + switch b { + case '.': + length = i + 1 + st = 2629 + default: + return length + } + + case 2630: + switch b { + case '.': + length = i + 1 + st = 2631 + default: + return length + } + + case 2632: + switch b { + case '.': + length = i + 1 + st = 2633 + default: + return length + } + + case 2634: + switch b { + case '.': + length = i + 1 + st = 2635 + default: + return length + } + + case 2636: + switch b { + case '.': + length = i + 1 + st = 2637 + default: + return length + } + + case 2638: + switch b { + case '.': + length = i + 1 + st = 2639 + default: + return length + } + + case 2640: + switch b { + case '.': + length = i + 1 + st = 2641 + default: + return length + } + + case 2642: + switch b { + case '.': + length = i + 1 + st = 2643 + default: + return length + } + + case 2644: + switch b { + case '.': + length = i + 1 + st = 2645 + default: + return length + } + + case 2646: + switch b { + case '.': + length = i + 1 + st = 2647 + default: + return length + } + + case 2648: + switch b { + case '.': + length = i + 1 + st = 2649 + default: + return length + } + + case 2650: + switch b { + case '.': + length = i + 1 + st = 2651 + default: + return length + } + + case 2652: + switch b { + case '.': + length = i + 1 + st = 2653 + default: + return length + } + + case 2654: + switch b { + case '.': + length = i + 1 + st = 2655 + default: + return length + } + + case 2656: + switch b { + case '.': + length = i + 1 + st = 2657 + default: + return length + } + + case 2658: + switch b { + case '.': + length = i + 1 + st = 2659 + default: + return length + } + + case 2660: + switch b { + case '.': + length = i + 1 + st = 2661 + default: + return length + } + + case 2662: + switch b { + case '.': + length = i + 1 + st = 2663 + default: + return length + } + + case 2664: + switch b { + case '.': + length = i + 1 + st = 2665 + default: + return length + } + + case 2666: + switch b { + case '.': + length = i + 1 + st = 2667 + default: + return length + } + + case 2668: + switch b { + case '.': + length = i + 1 + st = 2669 + default: + return length + } + + case 2670: + switch b { + case '.': + length = i + 1 + st = 2671 + default: + return length + } + + case 2672: + switch b { + case '.': + length = i + 1 + st = 2673 + default: + return length + } + + case 2674: + switch b { + case '.': + length = i + 1 + st = 2675 + default: + return length + } + + case 2676: + switch b { + case '.': + length = i + 1 + st = 2677 + default: + return length + } + + case 2678: + switch b { + case '.': + length = i + 1 + st = 2679 + default: + return length + } + + case 2680: + switch b { + case '.': + length = i + 1 + st = 2681 + default: + return length + } + + case 2682: + switch b { + case '.': + length = i + 1 + st = 2683 + default: + return length + } + + case 2684: + switch b { + case '.': + length = i + 1 + st = 2685 + default: + return length + } + + case 2686: + switch b { + case '.': + length = i + 1 + st = 2687 + default: + return length + } + + case 2688: + switch b { + case '.': + length = i + 1 + st = 2689 + default: + return length + } + + case 2690: + switch b { + case '.': + length = i + 1 + st = 2691 + default: + return length + } + + case 2692: + switch b { + case '.': + length = i + 1 + st = 2693 + default: + return length + } + + case 2694: + switch b { + case '.': + length = i + 1 + st = 2695 + default: + return length + } + + case 2696: + switch b { + case '.': + length = i + 1 + st = 2697 + default: + return length + } + + case 2698: + switch b { + case '.': + length = i + 1 + st = 2699 + default: + return length + } + + case 2700: + switch b { + case '.': + length = i + 1 + st = 2701 + default: + return length + } + + case 2702: + switch b { + case '.': + length = i + 1 + st = 2703 + default: + return length + } + + case 2704: + switch b { + case '.': + length = i + 1 + st = 2705 + default: + return length + } + + case 2706: + switch b { + case '.': + length = i + 1 + st = 2707 + default: + return length + } + + case 2708: + switch b { + case '.': + length = i + 1 + st = 2709 + default: + return length + } + + case 2710: + switch b { + case '.': + length = i + 1 + st = 2711 + default: + return length + } + + case 2712: + switch b { + case '.': + length = i + 1 + st = 2713 + default: + return length + } + + case 2714: + switch b { + case '.': + length = i + 1 + st = 2715 + default: + return length + } + + case 2716: + switch b { + case '.': + length = i + 1 + st = 2717 + default: + return length + } + + case 2718: + switch b { + case '.': + length = i + 1 + st = 2719 + default: + return length + } + + case 2720: + switch b { + case '.': + length = i + 1 + st = 2721 + default: + return length + } + + case 2722: + switch b { + case '.': + length = i + 1 + st = 2723 + default: + return length + } + + case 2724: + switch b { + case '.': + length = i + 1 + st = 2725 + default: + return length + } + + case 2726: + switch b { + case '.': + length = i + 1 + st = 2727 + default: + return length + } + + case 2728: + switch b { + case '.': + length = i + 1 + st = 2729 + default: + return length + } + + case 2730: + switch b { + case '.': + length = i + 1 + st = 2731 + default: + return length + } + + case 2732: + switch b { + case '.': + length = i + 1 + st = 2733 + default: + return length + } + + case 2734: + switch b { + case '.': + length = i + 1 + st = 2735 + default: + return length + } + + case 2736: + switch b { + case '.': + length = i + 1 + st = 2737 + default: + return length + } + + case 2738: + switch b { + case '.': + length = i + 1 + st = 2739 + default: + return length + } + + case 2740: + switch b { + case '.': + length = i + 1 + st = 2741 + default: + return length + } + + case 2742: + switch b { + case '.': + length = i + 1 + st = 2743 + default: + return length + } + + case 2744: + switch b { + case '.': + length = i + 1 + st = 2745 + default: + return length + } + + case 2746: + switch b { + case '.': + length = i + 1 + st = 2747 + default: + return length + } + + case 2748: + switch b { + case '.': + length = i + 1 + st = 2749 + default: + return length + } + + case 2750: + switch b { + case '.': + length = i + 1 + st = 2751 + default: + return length + } + + case 2752: + switch b { + case '.': + length = i + 1 + st = 2753 + default: + return length + } + + case 2754: + switch b { + case '.': + length = i + 1 + st = 2755 + default: + return length + } + + case 2756: + switch b { + case '.': + length = i + 1 + st = 2757 + default: + return length + } + + case 2758: + switch b { + case '.': + length = i + 1 + st = 2759 + default: + return length + } + + case 2760: + switch b { + case '.': + length = i + 1 + st = 2761 + default: + return length + } + + case 2762: + switch b { + case '.': + length = i + 1 + st = 2763 + default: + return length + } + + case 2764: + switch b { + case '.': + length = i + 1 + st = 2765 + default: + return length + } + + case 2766: + switch b { + case '.': + length = i + 1 + st = 2767 + default: + return length + } + + case 2768: + switch b { + case '.': + length = i + 1 + st = 2769 + default: + return length + } + + case 2770: + switch b { + case '.': + length = i + 1 + st = 2771 + default: + return length + } + + case 2772: + switch b { + case '.': + length = i + 1 + st = 2773 + default: + return length + } + + case 2774: + switch b { + case '.': + length = i + 1 + st = 2775 + default: + return length + } + + case 2776: + switch b { + case '.': + length = i + 1 + st = 2777 + default: + return length + } + + case 2778: + switch b { + case '.': + length = i + 1 + st = 2779 + default: + return length + } + + case 2780: + switch b { + case '.': + length = i + 1 + st = 2781 + default: + return length + } + + case 2782: + switch b { + case '.': + length = i + 1 + st = 2783 + default: + return length + } + + case 2784: + switch b { + case '.': + length = i + 1 + st = 2785 + default: + return length + } + + case 2786: + switch b { + case '.': + length = i + 1 + st = 2787 + default: + return length + } + + case 2788: + switch b { + case '.': + length = i + 1 + st = 2789 + default: + return length + } + + case 2790: + switch b { + case '.': + length = i + 1 + st = 2791 + default: + return length + } + + case 2792: + switch b { + case '.': + length = i + 1 + st = 2793 + default: + return length + } + + case 2794: + switch b { + case '.': + length = i + 1 + st = 2795 + default: + return length + } + + case 2796: + switch b { + case '.': + length = i + 1 + st = 2797 + default: + return length + } + + case 2798: + switch b { + case '.': + length = i + 1 + st = 2799 + default: + return length + } + + case 2800: + switch b { + case '.': + length = i + 1 + st = 2801 + default: + return length + } + + case 2802: + switch b { + case '.': + length = i + 1 + st = 2803 + default: + return length + } + + case 2804: + switch b { + case '.': + length = i + 1 + st = 2805 + default: + return length + } + + case 2806: + switch b { + case '.': + length = i + 1 + st = 2807 + default: + return length + } + + case 2808: + switch b { + case '.': + length = i + 1 + st = 2809 + default: + return length + } + + case 2810: + switch b { + case '.': + length = i + 1 + st = 2811 + default: + return length + } + + case 2812: + switch b { + case '.': + length = i + 1 + st = 2813 + default: + return length + } + + case 2814: + switch b { + case '.': + length = i + 1 + st = 2815 + default: + return length + } + + case 2816: + switch b { + case '.': + length = i + 1 + st = 2817 + default: + return length + } + + case 2818: + switch b { + case '.': + length = i + 1 + st = 2819 + default: + return length + } + + case 2820: + switch b { + case '.': + length = i + 1 + st = 2821 + default: + return length + } + + case 2822: + switch b { + case '.': + length = i + 1 + st = 2823 + default: + return length + } + + case 2824: + switch b { + case '.': + length = i + 1 + st = 2825 + default: + return length + } + + case 2826: + switch b { + case '.': + length = i + 1 + st = 2827 + default: + return length + } + + case 2828: + switch b { + case '.': + length = i + 1 + st = 2829 + default: + return length + } + + case 2830: + switch b { + case '.': + length = i + 1 + st = 2831 + default: + return length + } + + case 2832: + switch b { + case '.': + length = i + 1 + st = 2833 + default: + return length + } + + case 2834: + switch b { + case '.': + length = i + 1 + st = 2835 + default: + return length + } + + case 2836: + switch b { + case '.': + length = i + 1 + st = 2837 + default: + return length + } + + case 2838: + switch b { + case '.': + length = i + 1 + st = 2839 + default: + return length + } + + case 2840: + switch b { + case '.': + length = i + 1 + st = 2841 + default: + return length + } + + case 2842: + switch b { + case '.': + length = i + 1 + st = 2843 + default: + return length + } + + case 2844: + switch b { + case '.': + length = i + 1 + st = 2845 + default: + return length + } + + case 2846: + switch b { + case '.': + length = i + 1 + st = 2847 + default: + return length + } + + case 2848: + switch b { + case '.': + length = i + 1 + st = 2849 + default: + return length + } + + case 2850: + switch b { + case '.': + length = i + 1 + st = 2851 + default: + return length + } + + case 2852: + switch b { + case '.': + length = i + 1 + st = 2853 + default: + return length + } + + case 2854: + switch b { + case '.': + length = i + 1 + st = 2855 + default: + return length + } + + case 2856: + switch b { + case '.': + length = i + 1 + st = 2857 + default: + return length + } + + case 2858: + switch b { + case '.': + length = i + 1 + st = 2859 + default: + return length + } + + case 2860: + switch b { + case '-': + st = 2861 + default: + return length + } + + case 2861: + switch b { + case '-': + length = i + 1 + st = 2862 + default: + return length + } + + } + } + + return length +} diff --git a/vendor/gitlab.com/golang-commonmark/linkify/linkify.go b/vendor/gitlab.com/golang-commonmark/linkify/linkify.go new file mode 100644 index 00000000..116d5615 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/linkify.go @@ -0,0 +1,462 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package linkify provides a way to find links in plain text. +package linkify + +import ( + "strings" + "unicode/utf8" +) + +// Link represents a link found in a string with a schema and a position in the string. +type Link struct { + Scheme string + Start, End int +} + +func max(a, b int) int { + if a >= b { + return a + } + return b +} + +// Links returns links found in s. +func Links(s string) (links []Link) { + for i := 0; i < len(s)-2; i++ { + switch s[i] { + case '.': // IP address or domain name + if i == 0 { + continue // . at the start of a line + } + if length := match(s[i+1:]); length > 0 { + pos := i + 1 + length + switch s[pos-1] { + case '.': // IP address + if pos >= len(s) { + continue // . at the end of line + } + if !digit(s[i-1]) { + i = pos + continue // . should be preceded by a digit + } + if !digit(s[pos]) { + i = pos + continue // . should be followed by a digit + } + + // find the start of the IP address + j := i - 2 + m := max(0, j-3) + for j >= m && digit(s[j]) { + j-- + } + if i-2-j > 2 { + i = pos + 1 + continue // at most 3 digits + } + start := 0 + if j >= 0 { + r, rlen := utf8.DecodeLastRuneInString(s[:j+1]) + if !isPunctOrSpaceOrControl(r) { + i = pos + 1 + continue + } + switch r { + case '.', ':', '/', '\\', '-', '_': + i = pos + 1 + continue + } + start = j + 2 - rlen + } + + length, ok := skipIPv4(s[start:]) + if !ok { + i = pos + 1 + continue + } + end := start + length + if end == len(s) { + links = append(links, Link{ + Scheme: "", + Start: start, + End: end, + }) + return + } + + r, _ := utf8.DecodeRuneInString(s[end:]) + if !isPunctOrSpaceOrControl(r) { + continue + } + + end = skipPort(s, end) + end = skipPath(s, end) + end = skipQuery(s, end) + end = skipFragment(s, end) + end = unskipPunct(s, end) + + if end < len(s) { + r, _ = utf8.DecodeRuneInString(s[end:]) + if !isPunctOrSpaceOrControl(r) || r == '%' { + continue + } + } + + links = append(links, Link{ + Scheme: "", + Start: start, + End: end, + }) + i = end + + default: // domain name + r, _ := utf8.DecodeLastRuneInString(s[:i]) + if isPunctOrSpaceOrControl(r) { + continue + } + + if pos == len(s) { + start, ok := findHostnameStart(s, i) + if !ok { + continue + } + links = append(links, Link{ + Scheme: "", + Start: start, + End: pos, + }) + return + } + + if s[i+1:pos] != "xn--" { + r, _ = utf8.DecodeRuneInString(s[pos:]) + if isLetterOrDigit(r) { + continue // should not be followed by a letter or a digit + } + } + + end, dot, ok := findHostnameEnd(s, pos) + if !ok { + continue + } + dot = max(dot, i) + + if !(dot+5 <= len(s) && s[dot+1:dot+5] == "xn--") { + if length := match(s[dot+1:]); dot+length+1 != end { + continue + } + } + + start, ok := findHostnameStart(s, i) + if !ok { + continue + } + + end = skipPort(s, end) + end = skipPath(s, end) + end = skipQuery(s, end) + end = skipFragment(s, end) + end = unskipPunct(s, end) + + if end < len(s) { + r, _ = utf8.DecodeRuneInString(s[end:]) + if !isPunctOrSpaceOrControl(r) || r == '%' { + continue // should be followed by punctuation or space + } + } + + links = append(links, Link{ + Scheme: "", + Start: start, + End: end, + }) + i = end + } + } + + case '/': // schema-less link + if s[i+1] != '/' { + continue + } + + if i > 0 { + if s[i-1] == ':' { + i++ + continue // should not be preceded by a colon + } + r, _ := utf8.DecodeLastRuneInString(s[:i]) + if !isPunctOrSpaceOrControl(r) { + i++ + continue // should be preceded by punctuation or space + } + } + + r, _ := utf8.DecodeRuneInString(s[i+2:]) + if !isLetterOrDigit(r) { + i++ + continue // should be followed by a letter or a digit + } + + start := i + end, dot, ok := findHostnameEnd(s, i+2) + if !ok { + continue + } + if s[i+2:end] != "localhost" { + if dot == -1 { + continue // no dot + } + if length, ok := skipIPv4(s[i+2:]); !ok || i+2+length != end { + if length := match(s[dot+1:]); dot+length+1 != end { + continue + } + } + } + + end = skipPort(s, end) + end = skipPath(s, end) + end = skipQuery(s, end) + end = skipFragment(s, end) + end = unskipPunct(s, end) + + if end < len(s) { + r, _ = utf8.DecodeRuneInString(s[end:]) + if !isPunctOrSpaceOrControl(r) || r == '%' { + continue // should be followed by punctuation or space + } + } + + links = append(links, Link{ + Scheme: "//", + Start: start, + End: end, + }) + i = end + + case ':': // http, https, ftp, mailto or localhost + if i < 3 { // at least ftp: + continue + } + + if i >= 9 && s[i-1] == 't' && s[i-9:i] == "localhost" { + j := i - 9 + if !digit(s[j+10]) { + continue + } + if j > 0 { + r, _ := utf8.DecodeLastRuneInString(s[:j]) + if !isPunctOrSpaceOrControl(r) { + i++ + continue // should be preceded by punctuation or space + } + } + + start := j + pos := j + 9 + end := skipPort(s, pos) + if end == pos { + continue // invalid port + } + end = skipPath(s, end) + end = skipQuery(s, end) + end = skipFragment(s, end) + end = unskipPunct(s, end) + + if end < len(s) { + r, _ := utf8.DecodeRuneInString(s[end:]) + if !isPunctOrSpaceOrControl(r) || r == '%' { + i++ + continue // should be followed by punctuation or space + } + } + + links = append(links, Link{ + Scheme: "", + Start: start, + End: end, + }) + i = end + + break + } + + j := i - 1 + var start int + var schema string + + switch byteToLower(s[j]) { + case 'o': // mailto + if j < 5 { + continue // too short for mailto + } + if len(s)-j < 8 { + continue // insufficient length after + } + if strings.ToLower(s[j-5:j+2]) != "mailto:" { + continue + } + r, _ := utf8.DecodeLastRuneInString(s[:j-5]) + if isLetterOrDigit(r) { + continue // should not be preceded by a letter or a digit + } + r, _ = utf8.DecodeRuneInString(s[j+2:]) + if !isAllowedInEmail(r) { + continue // should be followed by a valid e-mail character + } + + start = j - 5 + end, ok := findEmailEnd(s, j+2) + if !ok { + continue + } + + links = append(links, Link{ + Scheme: "mailto:", + Start: start, + End: end, + }) + i = end + continue // continue processing + + case 'p': // http or ftp + if len(s)-j < 8 { + continue // insufficient length after + } + switch byteToLower(s[j-2]) { + case 'f': + if strings.ToLower(s[j-2:j+4]) != "ftp://" { + continue + } + start = j - 2 + schema = "ftp:" + case 't': + if j < 3 { + continue + } + if strings.ToLower(s[j-3:j+4]) != "http://" { + continue + } + start = j - 3 + schema = "http:" + default: + continue + } + + case 's': // https + if j < 4 { + continue // too short for https + } + if len(s)-j < 8 { + continue // insufficient length after + } + start = j - 4 + if strings.ToLower(s[start:j+4]) != "https://" { + continue + } + schema = "https:" + + default: + continue + } + + // http, https or ftp + + if start > 0 { + r, _ := utf8.DecodeLastRuneInString(s[:start]) + if !isPunctOrSpaceOrControl(r) { + continue // should be preceded by punctuation or space + } + } + + r, _ := utf8.DecodeRuneInString(s[j+4:]) + if isPunctOrSpaceOrControl(r) { + continue + } + + end, dot, ok := findHostnameEnd(s, j+4) + if !ok { + continue + } + if s[j+4:end] != "localhost" { + if dot == -1 { + continue // no dot + } + if length, ok := skipIPv4(s[j+4:]); !ok || j+4+length != end { + if !(dot+5 <= len(s) && s[dot+1:dot+5] == "xn--") { + if length := match(s[dot+1:]); dot+length+1 != end { + continue + } + } + } + } + + end = skipPort(s, end) + end = skipPath(s, end) + end = skipQuery(s, end) + end = skipFragment(s, end) + end = unskipPunct(s, end) + + if end < len(s) { + r, _ = utf8.DecodeRuneInString(s[end:]) + if !isPunctOrSpaceOrControl(r) || r == '%' { + continue // should be followed by punctuation or space + } + } + + links = append(links, Link{ + Scheme: schema, + Start: start, + End: end, + }) + i = end + + case '@': // schema-less e-mail + if i == 0 { + continue // @ at the start of a line + } + + if len(s)-i < 5 { + continue // insufficient length after + } + + r, _ := utf8.DecodeLastRuneInString(s[:i]) + if !isAllowedInEmail(r) { + continue // should be preceded by a valid e-mail character + } + + r, _ = utf8.DecodeRuneInString(s[i+1:]) + if !isLetterOrDigit(r) { + continue // should be followed by a letter or a digit + } + + start, ok := findEmailStart(s, i-1) + if !ok { + continue + } + + end, dot, ok := findHostnameEnd(s, i+1) + if !ok { + continue + } + if dot == -1 { + continue // no dot + } + if !(dot+5 <= len(s) && s[dot+1:dot+5] == "xn--") { + if length := match(s[dot+1:]); dot+length+1 != end { + continue + } + } + + links = append(links, Link{ + Scheme: "mailto:", + Start: start, + End: end, + }) + i = end + } + } + return +} diff --git a/vendor/gitlab.com/golang-commonmark/linkify/url.go b/vendor/gitlab.com/golang-commonmark/linkify/url.go new file mode 100644 index 00000000..495a7ac4 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/url.go @@ -0,0 +1,404 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package linkify + +import "unicode/utf8" + +func atoi3(s string, start int) (int, bool) { + n := 0 + var i int + for i = start; i < len(s) && digit(s[i]); i++ { + n = n*10 + int(s[i]-'0') + if n > 255 { + return 0, false + } + } + if i == start { + return 0, false + } + return i, true +} + +func skipIPv4(s string) (_ int, _ bool) { + j := 0 + for i := 0; i < 4; i++ { + if j >= len(s) { + return + } + if i > 0 { + if s[j] != '.' { + return + } + j++ + } + n, ok := atoi3(s, j) + if !ok { + return + } + j = n + } + return j, true +} + +func atoi5(s string, start int) (int, bool) { + n := 0 + var i int + for i = start; i < len(s) && digit(s[i]); i++ { + n = n*10 + int(s[i]-'0') + if n > 65535 { + return 0, false + } + } + if i == start || n == 0 { + return 0, false + } + return i, true +} + +func skipPort(s string, start int) int { + if start >= len(s) || s[start] != ':' { + return start + } + end, ok := atoi5(s, start+1) + if !ok { + return start + } + return end +} + +func skipPath(s string, start int) int { + if start >= len(s) || s[start] != '/' { + return start // skip empty path + } + var stack []rune + var notClosedIndex int + var nHyphen int + end := start + 1 +loop: + for end < len(s) { + r, rlen := utf8.DecodeRuneInString(s[end:]) + if r == utf8.RuneError { + nHyphen = 0 + break + } + + switch { + case isUnreserved(r): + if r == '-' { + nHyphen++ + if nHyphen > 1 { + break loop + } + } else { + nHyphen = 0 + } + case isSubDelimiter(r) || r == '[' || r == ']': + nHyphen = 0 + switch r { + case '[', '(': + if len(stack) == 0 { + notClosedIndex = end + } + stack = append(stack, r) + case ']', ')': + opening := '[' + if r == ')' { + opening = '(' + } + if len(stack) == 0 || stack[len(stack)-1] != opening { + break loop + } + stack = stack[:len(stack)-1] + } + case r == '/' || r == ':' || r == '@': + nHyphen = 0 + case r == '%': + nHyphen = 0 + if end+2 >= len(s) { + break loop + } + if !(hexDigit(s[end+1]) && + hexDigit(s[end+2])) { + break loop + } + end += 2 + default: + nHyphen = 0 + if r != ' ' || len(stack) == 0 { + break loop + } + } + end += rlen + } + if len(stack) > 0 { + return notClosedIndex + } + if nHyphen > 0 { + return end - nHyphen + 1 + } + return end +} + +func skipQuery(s string, start int) int { + if start >= len(s) || s[start] != '?' { + return start + } + var stack []rune + var notClosedIndex int + var nHyphen int + end := start + 1 +loop: + for end < len(s) { + r, rlen := utf8.DecodeRuneInString(s[end:]) + if r == utf8.RuneError { + nHyphen = 0 + break + } + + switch { + case isUnreserved(r): + if r == '-' { + nHyphen++ + if nHyphen > 1 { + break loop + } + } else { + nHyphen = 0 + } + case isSubDelimiter(r) || r == '[' || r == ']': + nHyphen = 0 + switch r { + case '[', '(': + if len(stack) == 0 { + notClosedIndex = end + } + stack = append(stack, r) + case ']', ')': + opening := '[' + if r == ')' { + opening = '(' + } + if len(stack) == 0 || stack[len(stack)-1] != opening { + break loop + } + stack = stack[:len(stack)-1] + } + case r == '?' || r == '/' || r == ':' || r == '@': + nHyphen = 0 + case r == '%': + nHyphen = 0 + if end+2 >= len(s) { + break loop + } + if !(hexDigit(s[end+1]) && + hexDigit(s[end+2])) { + break loop + } + end += 2 + default: + nHyphen = 0 + if r != ' ' || len(stack) == 0 { + break loop + } + } + end += rlen + } + if len(stack) > 0 { + return notClosedIndex + } + if nHyphen > 0 { + return end - nHyphen + 1 + } + return end +} + +func skipFragment(s string, start int) int { + if start >= len(s) || s[start] != '#' { + return start + } + var stack []rune + var notClosedIndex int + var nHyphen int + end := start + 1 +loop: + for end < len(s) { + r, rlen := utf8.DecodeRuneInString(s[end:]) + if r == utf8.RuneError { + nHyphen = 0 + break + } + + switch { + case isUnreserved(r): + if r == '-' { + nHyphen++ + if nHyphen > 1 { + break loop + } + } else { + nHyphen = 0 + } + case isSubDelimiter(r) || r == '[' || r == ']': + nHyphen = 0 + switch r { + case '[', '(': + if len(stack) == 0 { + notClosedIndex = end + } + stack = append(stack, r) + case ']', ')': + opening := '[' + if r == ')' { + opening = '(' + } + if len(stack) == 0 || stack[len(stack)-1] != opening { + break loop + } + stack = stack[:len(stack)-1] + } + case r == '?' || r == '/' || r == ':' || r == '@': + nHyphen = 0 + case r == '%': + nHyphen = 0 + if end+2 >= len(s) { + break loop + } + if !(hexDigit(s[end+1]) && + hexDigit(s[end+2])) { + break loop + } + end += 2 + default: + nHyphen = 0 + if r != ' ' || len(stack) == 0 { + break loop + } + } + end += rlen + } + if len(stack) > 0 { + return notClosedIndex + } + if nHyphen > 0 { + return end - nHyphen + 1 + } + return end +} + +func unskipPunct(s string, start int) int { + end := start - 1 + if end < 0 || end >= len(s) || !basicPunct[s[end]] { + return start + } + return end +} + +func findHostnameStart(s string, start int) (_ int, _ bool) { + end := start + lastDot := true + nHyphen := 0 +loop: + for end > 0 { + r, rlen := utf8.DecodeLastRuneInString(s[:end]) + if r == utf8.RuneError { + return + } + + switch { + case r == '.': + if nHyphen > 0 { + return + } + lastDot = true + case r == '-': + if end == start { + return + } + if lastDot { + return + } + nHyphen++ + if nHyphen == 3 { + return + } + case r == ':' || r == '/' || r == '\\' || r == '_': + return + case isPunctOrSpaceOrControl(r): + break loop + default: + lastDot = false + nHyphen = 0 + } + end -= rlen + } + if lastDot || nHyphen > 0 { + return + } + return end, true +} + +func findHostnameEnd(s string, start int) (_ int, _ int, _ bool) { + end := start + lastDot := false + lastDotPos := -1 + nHyphen := 0 +loop: + for end < len(s) { + r, rlen := utf8.DecodeRuneInString(s[end:]) + if r == utf8.RuneError { + return + } + + switch { + case r == '.': + if nHyphen > 0 { + return + } + if lastDot { + break loop + } + lastDot = true + lastDotPos = end + nHyphen = 0 + case r == '-': + lastDot = false + if end == start { + return + } + if lastDot { + return + } + nHyphen++ + if nHyphen == 3 { + break loop + } + case r == '\\' || r == '_': + return + case isPunctOrSpaceOrControl(r): + break loop + default: + lastDot = false + nHyphen = 0 + } + end += rlen + } + + if nHyphen > 0 { + end -= nHyphen + } else if lastDot { + if s[end-1] == '.' { + end-- + } + lastDotPos = end - 1 + for lastDotPos >= start && s[lastDotPos] != '.' { + lastDotPos-- + } + if lastDotPos < start { + lastDotPos = -1 + } + } + + return end, lastDotPos, true +} diff --git a/vendor/gitlab.com/golang-commonmark/linkify/util.go b/vendor/gitlab.com/golang-commonmark/linkify/util.go new file mode 100644 index 00000000..9f70a57f --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/linkify/util.go @@ -0,0 +1,20 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package linkify + +func digit(b byte) bool { + return b >= '0' && b <= '9' +} + +func hexDigit(b byte) bool { + return digit(b) || b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F' +} + +func byteToLower(b byte) byte { + if b >= 'A' && b <= 'Z' { + return b - 'A' + 'a' + } + return b +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml new file mode 100644 index 00000000..58bdd5c4 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml @@ -0,0 +1,25 @@ +image: golang:1.11 + +stages: + - build + - test + +before_script: + - go get github.com/russross/blackfriday + - go get gitlab.com/golang-commonmark/html + - go get gitlab.com/golang-commonmark/linkify + - go get gitlab.com/golang-commonmark/mdurl + - go get gitlab.com/golang-commonmark/puny + - go get gitlab.com/opennota/wd + - go get gopkg.in/russross/blackfriday.v2 + +build: + stage: build + script: + - go build ./... + +test: + stage: test + script: + - test -z "$(gofmt -l . | tee /dev/stderr)" + - go test -cover ./... diff --git a/vendor/gitlab.com/golang-commonmark/markdown/AUTHORS b/vendor/gitlab.com/golang-commonmark/markdown/AUTHORS new file mode 100644 index 00000000..041a96ce --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/AUTHORS @@ -0,0 +1 @@ +opennota@gmail.com diff --git a/vendor/gitlab.com/golang-commonmark/markdown/LICENSE b/vendor/gitlab.com/golang-commonmark/markdown/LICENSE new file mode 100644 index 00000000..9cdcd201 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/LICENSE @@ -0,0 +1,10 @@ +Copyright (c) 2015, The 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: + +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/gitlab.com/golang-commonmark/markdown/README.md b/vendor/gitlab.com/golang-commonmark/markdown/README.md new file mode 100644 index 00000000..ac2a1de8 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/README.md @@ -0,0 +1,64 @@ +markdown [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/markdown?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/markdown) [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![Pipeline status](https://gitlab.com/golang-commonmark/markdown/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/markdown/commits/master) [![Coverage report](https://gitlab.com/golang-commonmark/markdown/badges/master/coverage.svg)](https://gitlab.com/golang-commonmark/markdown/commits/master) +======== + +Package golang-commonmark/markdown provides a CommonMark-compliant markdown parser and renderer, written in Go. + +## Installation + + go get -u gitlab.com/golang-commonmark/markdown + +You can also go get [mdtool](https://gitlab.com/golang-commonmark/mdtool), an example command-line tool: + + go get -u gitlab.com/golang-commonmark/mdtool + +## Standards support + +Currently supported CommonMark spec: [v0.28](http://spec.commonmark.org/0.28/). + +## Extensions + +Besides the features required by CommonMark, golang-commonmark/markdown supports: + + * Tables (GFM) + * Strikethrough (GFM) + * Autoconverting plain-text URLs to links + * Typographic replacements (smart quotes and other) + +## Usage + +``` go +md := markdown.New(markdown.XHTMLOutput(true)) +fmt.Println(md.RenderToString([]byte("Header\n===\nText"))) +``` + +Check out [the source of mdtool](https://gitlab.com/golang-commonmark/mdtool/blob/master/main.go) for a more complete example. + +The following options are currently supported: + + Name | Type | Description | Default + --------------- | --------- | ----------------------------------------------------------- | --------- + HTML | bool | whether to enable raw HTML | false + Tables | bool | whether to enable GFM tables | true + Linkify | bool | whether to autoconvert plain-text URLs to links | true + Typographer | bool | whether to enable typographic replacements | true + Quotes | string / []string | double + single quote replacement pairs for the typographer | “”‘’ + MaxNesting | int | maximum nesting level | 20 + LangPrefix | string | CSS language prefix for fenced blocks | language- + Breaks | bool | whether to convert newlines inside paragraphs into `
` | false + XHTMLOutput | bool | whether to output XHTML instead of HTML | false + +## Benchmarks + +Rendering spec/spec-0.28.txt on a Intel(R) Core(TM) i5-2400 CPU @ 3.10GHz + + BenchmarkRenderSpecNoHTML 100 10254720 ns/op 2998037 B/op 18225 allocs/op + BenchmarkRenderSpec 100 10180241 ns/op 2997307 B/op 18214 allocs/op + BenchmarkRenderSpecBlackFriday 200 7241749 ns/op 2834340 B/op 17101 allocs/op + BenchmarkRenderSpecBlackFriday2 200 7448256 ns/op 2991202 B/op 16705 allocs/op + +## See also + +https://github.com/jgm/CommonMark — the reference CommonMark implementations in C and JavaScript, + also contains the latest spec and an online demo. + +http://talk.commonmark.org — the CommonMark forum, a good place to join together the efforts of the developers. diff --git a/vendor/gitlab.com/golang-commonmark/markdown/align.go b/vendor/gitlab.com/golang-commonmark/markdown/align.go new file mode 100644 index 00000000..bcb63600 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/align.go @@ -0,0 +1,26 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +type Align byte + +const ( + AlignNone = iota + AlignLeft + AlignCenter + AlignRight +) + +func (a Align) String() string { + switch a { + case AlignLeft: + return "left" + case AlignCenter: + return "center" + case AlignRight: + return "right" + } + return "" +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/autolink.go b/vendor/gitlab.com/golang-commonmark/markdown/autolink.go new file mode 100644 index 00000000..ab51c71b --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/autolink.go @@ -0,0 +1,70 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import ( + "regexp" + "strings" +) + +var ( + rAutolink = regexp.MustCompile(`^<([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)>`) + rEmail = regexp.MustCompile(`^<([a-zA-Z0-9.!#$%&'*+/=?^_{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>`) +) + +func ruleAutolink(s *StateInline, silent bool) bool { + pos := s.Pos + src := s.Src + + if src[pos] != '<' { + return false + } + + tail := src[pos:] + + if strings.IndexByte(tail, '>') < 0 { + return false + } + + link := rAutolink.FindString(tail) + if link != "" { + link = link[1 : len(link)-1] + href := normalizeLink(link) + if !validateLink(href) { + return false + } + + if !silent { + s.PushOpeningToken(&LinkOpen{Href: href}) + s.PushToken(&Text{Content: normalizeLinkText(link)}) + s.PushClosingToken(&LinkClose{}) + } + + s.Pos += len(link) + 2 + + return true + } + + email := rEmail.FindString(tail) + if email != "" { + email = email[1 : len(email)-1] + href := normalizeLink("mailto:" + email) + if !validateLink(href) { + return false + } + + if !silent { + s.PushOpeningToken(&LinkOpen{Href: href}) + s.PushToken(&Text{Content: normalizeLinkText(email)}) + s.PushClosingToken(&LinkClose{}) + } + + s.Pos += len(email) + 2 + + return true + } + + return false +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/backticks.go b/vendor/gitlab.com/golang-commonmark/markdown/backticks.go new file mode 100644 index 00000000..07f268dc --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/backticks.go @@ -0,0 +1,60 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strings" + +func ruleBackticks(s *StateInline, silent bool) bool { + pos := s.Pos + src := s.Src + + if src[pos] != '`' { + return false + } + + start := pos + pos++ + max := s.PosMax + + for pos < max && src[pos] == '`' { + pos++ + } + + marker := src[start:pos] + + matchStart := pos + matchEnd := pos + for { + matchStart = strings.IndexByte(src[matchEnd:], '`') + if matchStart == -1 { + break + } + matchStart += matchEnd + + matchEnd = matchStart + 1 + + for matchEnd < max && src[matchEnd] == '`' { + matchEnd++ + } + + if matchEnd-matchStart == len(marker) { + if !silent { + s.PushToken(&CodeInline{ + Content: normalizeInlineCode(src[pos:matchStart]), + }) + } + s.Pos = matchEnd + return true + } + } + + if !silent { + s.Pending.WriteString(marker) + } + + s.Pos += len(marker) + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go b/vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go new file mode 100644 index 00000000..d5830634 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go @@ -0,0 +1,43 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func ruleBalancePairs(s *StateInline) { + delimiters := s.Delimiters + max := len(delimiters) + + for i := 0; i < max; i++ { + lastDelim := delimiters[i] + + if !lastDelim.Close { + continue + } + + j := i - lastDelim.Jump - 1 + + for j >= 0 { + currDelim := delimiters[j] + + if currDelim.Open && + currDelim.Marker == lastDelim.Marker && + currDelim.End < 0 && + currDelim.Level == lastDelim.Level { + oddMatch := (currDelim.Close || lastDelim.Open) && + currDelim.Length != -1 && + lastDelim.Length != -1 && + (currDelim.Length+lastDelim.Length)%3 == 0 + if !oddMatch { + delimiters[i].Jump = i - j + delimiters[i].Open = false + delimiters[j].End = i + delimiters[j].Jump = 0 + break + } + } + + j -= currDelim.Jump + 1 + } + } +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/blockquote.go b/vendor/gitlab.com/golang-commonmark/markdown/blockquote.go new file mode 100644 index 00000000..f8ad3626 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/blockquote.go @@ -0,0 +1,233 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "unicode/utf8" + +var blockquoteTerminatedBy []BlockRule + +func ruleBlockQuote(s *StateBlock, startLine, endLine int, silent bool) bool { + if s.SCount[startLine]-s.BlkIndent >= 4 { + return false + } + + pos := s.BMarks[startLine] + s.TShift[startLine] + max := s.EMarks[startLine] + src := s.Src + + if pos >= max { + return false + } + if src[pos] != '>' { + return false + } + pos++ + + if silent { + return true + } + + initial := s.SCount[startLine] + pos - (s.BMarks[startLine] + s.TShift[startLine]) + offset := initial + + spaceAfterMarker := false + adjustTab := false + if pos < max { + if src[pos] == ' ' { + pos++ + initial++ + offset++ + spaceAfterMarker = true + } else if src[pos] == '\t' { + spaceAfterMarker = true + if (s.BSCount[startLine]+offset)%4 == 3 { + pos++ + initial++ + offset++ + } else { + adjustTab = true + } + } + } + + oldBMarks := []int{s.BMarks[startLine]} + s.BMarks[startLine] = pos + + for pos < max { + r, size := utf8.DecodeRuneInString(src[pos:]) + if runeIsSpace(r) { + if r == '\t' { + d := 0 + if adjustTab { + d = 1 + } + offset += 4 - (offset+s.BSCount[startLine]+d)%4 + } else { + offset++ + } + } else { + break + } + pos += size + } + + oldBSCount := []int{s.BSCount[startLine]} + d := 0 + if spaceAfterMarker { + d = 1 + } + s.BSCount[startLine] = s.SCount[startLine] + 1 + d + + lastLineEmpty := pos >= max + + oldSCount := []int{s.SCount[startLine]} + s.SCount[startLine] = offset - initial + + oldTShift := []int{s.TShift[startLine]} + s.TShift[startLine] = pos - s.BMarks[startLine] + + oldParentType := s.ParentType + s.ParentType = ptBlockQuote + wasOutdented := false + + oldLineMax := s.LineMax + + nextLine := startLine + 1 + for ; nextLine < endLine; nextLine++ { + if s.SCount[nextLine] < s.BlkIndent { + wasOutdented = true + } + pos = s.BMarks[nextLine] + s.TShift[nextLine] + max = s.EMarks[nextLine] + + if pos >= max { + break + } + + pos++ + if src[pos-1] == '>' && !wasOutdented { + initial = s.SCount[nextLine] + pos + (s.BMarks[nextLine] + s.TShift[nextLine]) + offset = initial + + if pos >= len(src) || src[pos] != ' ' && src[pos] != '\t' { + spaceAfterMarker = true + } else if src[pos] == ' ' { + pos++ + initial++ + offset++ + adjustTab = false + spaceAfterMarker = true + } else if src[pos] == '\t' { + spaceAfterMarker = true + + if (s.BSCount[nextLine]+offset)%4 == 3 { + pos++ + initial++ + offset++ + adjustTab = false + } else { + adjustTab = true + } + } + + oldBMarks = append(oldBMarks, s.BMarks[nextLine]) + s.BMarks[nextLine] = pos + + for pos < max { + r, size := utf8.DecodeRuneInString(src[pos:]) + if runeIsSpace(r) { + if r == '\t' { + d := 0 + if adjustTab { + d = 1 + } + offset += 4 - (offset+s.BSCount[startLine]+d)%4 + } else { + offset++ + } + } else { + break + } + pos += size + } + + lastLineEmpty = pos >= max + + oldBSCount = append(oldBSCount, s.BSCount[nextLine]) + d := 0 + if spaceAfterMarker { + d = 1 + } + s.BSCount[nextLine] = s.SCount[nextLine] + 1 + d + + oldSCount = append(oldSCount, s.SCount[nextLine]) + s.SCount[nextLine] = offset - initial + + oldTShift = append(oldTShift, s.TShift[nextLine]) + s.TShift[nextLine] = pos - s.BMarks[nextLine] + + continue + } + + if lastLineEmpty { + break + } + + terminate := false + for _, r := range blockquoteTerminatedBy { + if r(s, nextLine, endLine, true) { + terminate = true + break + } + } + + if terminate { + s.LineMax = nextLine + + if s.BlkIndent != 0 { + oldBMarks = append(oldBMarks, s.BMarks[nextLine]) + oldBSCount = append(oldBSCount, s.BSCount[nextLine]) + oldTShift = append(oldTShift, s.TShift[nextLine]) + oldSCount = append(oldSCount, s.SCount[nextLine]) + s.SCount[nextLine] -= s.BlkIndent + } + + break + } + + oldBMarks = append(oldBMarks, s.BMarks[nextLine]) + oldBSCount = append(oldBSCount, s.BSCount[nextLine]) + oldTShift = append(oldTShift, s.TShift[nextLine]) + oldSCount = append(oldSCount, s.SCount[nextLine]) + + s.SCount[nextLine] = -1 + } + + oldIndent := s.BlkIndent + s.BlkIndent = 0 + + tok := &BlockquoteOpen{ + Map: [2]int{startLine, 0}, + } + s.PushOpeningToken(tok) + + s.Md.Block.Tokenize(s, startLine, nextLine) + + s.PushClosingToken(&BlockquoteClose{}) + + s.LineMax = oldLineMax + s.ParentType = oldParentType + tok.Map[1] = s.Line + + for i := 0; i < len(oldTShift); i++ { + s.BMarks[startLine+i] = oldBMarks[i] + s.TShift[startLine+i] = oldTShift[i] + s.SCount[startLine+i] = oldSCount[i] + s.BSCount[startLine+i] = oldBSCount[i] + } + s.BlkIndent = oldIndent + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/code.go b/vendor/gitlab.com/golang-commonmark/markdown/code.go new file mode 100644 index 00000000..c6dc574e --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/code.go @@ -0,0 +1,37 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func ruleCode(s *StateBlock, startLine, endLine int, _ bool) bool { + if s.SCount[startLine]-s.BlkIndent < 4 { + return false + } + + nextLine := startLine + 1 + last := nextLine + + for nextLine < endLine { + if s.IsLineEmpty(nextLine) { + nextLine++ + continue + } + + if s.SCount[nextLine]-s.BlkIndent >= 4 { + nextLine++ + last = nextLine + continue + } + + break + } + + s.Line = last + s.PushToken(&CodeBlock{ + Content: s.Lines(startLine, last, 4+s.BlkIndent, true), + Map: [2]int{startLine, s.Line}, + }) + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/emphasis.go b/vendor/gitlab.com/golang-commonmark/markdown/emphasis.go new file mode 100644 index 00000000..ea9cda21 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/emphasis.go @@ -0,0 +1,89 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +type Delimiter struct { + Length int + Jump int + Token int + Level int + End int + Open bool + Close bool + Marker byte +} + +func ruleEmphasis(s *StateInline, silent bool) bool { + src := s.Src + start := s.Pos + marker := src[start] + + if silent { + return false + } + + if marker != '_' && marker != '*' { + return false + } + + canOpen, canClose, length := s.scanDelims(s.Pos, marker == '*') + for i := 0; i < length; i++ { + s.PushToken(&Text{Content: string(marker)}) + + s.Delimiters = append(s.Delimiters, Delimiter{ + Marker: marker, + Length: length, + Jump: i, + Token: len(s.Tokens) - 1, + Level: s.Level, + End: -1, + Open: canOpen, + Close: canClose, + }) + } + + s.Pos += length + + return true +} + +func ruleEmphasisPostprocess(s *StateInline) { + delimiters := s.Delimiters + max := len(delimiters) + for i := max - 1; i >= 0; i-- { + startDelim := delimiters[i] + if startDelim.Marker != '_' && startDelim.Marker != '*' { + continue + } + + if startDelim.End == -1 { + continue + } + + endDelim := delimiters[startDelim.End] + + isStrong := i > 0 && + delimiters[i-1].End == startDelim.End+1 && + delimiters[i-1].Token == startDelim.Token-1 && + delimiters[startDelim.End+1].Token == endDelim.Token+1 && + delimiters[i-1].Marker == startDelim.Marker + + if isStrong { + s.Tokens[startDelim.Token] = &StrongOpen{} + s.Tokens[endDelim.Token] = &StrongClose{} + + if text, ok := s.Tokens[delimiters[i-1].Token].(*Text); ok { + text.Content = "" + } + if text, ok := s.Tokens[delimiters[startDelim.End+1].Token].(*Text); ok { + text.Content = "" + } + i-- + } else { + s.Tokens[startDelim.Token] = &EmphasisOpen{} + s.Tokens[endDelim.Token] = &EmphasisClose{} + } + } +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/entity.go b/vendor/gitlab.com/golang-commonmark/markdown/entity.go new file mode 100644 index 00000000..fd5fba9c --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/entity.go @@ -0,0 +1,35 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "gitlab.com/golang-commonmark/html" + +func ruleEntity(s *StateInline, silent bool) bool { + pos := s.Pos + src := s.Src + + if src[pos] != '&' { + return false + } + + max := s.PosMax + + if pos+1 < max { + if e, n := html.ParseEntity(src[pos:]); n > 0 { + if !silent { + s.Pending.WriteString(e) + } + s.Pos += n + return true + } + } + + if !silent { + s.Pending.WriteByte('&') + } + s.Pos++ + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/escape.go b/vendor/gitlab.com/golang-commonmark/markdown/escape.go new file mode 100644 index 00000000..634b9735 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/escape.go @@ -0,0 +1,61 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strings" + +func escaped(b byte) bool { + return strings.IndexByte("\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-", b) != -1 +} + +func ruleEscape(s *StateInline, silent bool) bool { + pos := s.Pos + src := s.Src + + if src[pos] != '\\' { + return false + } + + pos++ + max := s.PosMax + + if pos < max { + b := src[pos] + + if b < 0x7f && escaped(b) { + if !silent { + s.Pending.WriteByte(b) + } + s.Pos += 2 + return true + } + + if b == '\n' { + if !silent { + s.PushToken(&Hardbreak{}) + } + + pos++ + + for pos < max { + b := src[pos] + if !byteIsSpace(b) { + break + } + pos++ + } + + s.Pos = pos + return true + } + } + + if !silent { + s.Pending.WriteByte('\\') + } + s.Pos++ + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/fence.go b/vendor/gitlab.com/golang-commonmark/markdown/fence.go new file mode 100644 index 00000000..04924dc4 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/fence.go @@ -0,0 +1,102 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strings" + +func ruleFence(s *StateBlock, startLine, endLine int, silent bool) bool { + haveEndMarker := false + pos := s.BMarks[startLine] + s.TShift[startLine] + max := s.EMarks[startLine] + + if s.SCount[startLine]-s.BlkIndent >= 4 { + return false + } + if pos+3 > max { + return false + } + + src := s.Src + + marker := src[pos] + if marker != '~' && marker != '`' { + return false + } + + mem := pos + pos = s.SkipBytes(pos, marker) + + len := pos - mem + + if len < 3 { + return false + } + + params := strings.TrimSpace(src[pos:max]) + + if strings.IndexByte(params, marker) >= 0 { + return false + } + + if silent { + return true + } + + nextLine := startLine + + for { + nextLine++ + if nextLine >= endLine { + break + } + + mem = s.BMarks[nextLine] + s.TShift[nextLine] + pos = mem + max = s.EMarks[nextLine] + + if pos < max && s.SCount[nextLine] < s.BlkIndent { + break + } + + if pos >= max || src[pos] != marker { + continue + } + + if s.SCount[nextLine]-s.BlkIndent >= 4 { + continue + } + + pos = s.SkipBytes(pos, marker) + + if pos-mem < len { + continue + } + + pos = s.SkipSpaces(pos) + + if pos < max { + continue + } + + haveEndMarker = true + + break + } + + len = s.SCount[startLine] + + s.Line = nextLine + if haveEndMarker { + s.Line++ + } + + s.PushToken(&Fence{ + Params: params, + Content: s.Lines(startLine+1, nextLine, len, true), + Map: [2]int{startLine, s.Line}, + }) + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/fuzz.go b/vendor/gitlab.com/golang-commonmark/markdown/fuzz.go new file mode 100644 index 00000000..66ac7697 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/fuzz.go @@ -0,0 +1,9 @@ +//+build gofuzz + +package markdown + +func Fuzz(data []byte) int { + md := New(HTML(true)) + md.Parse(data) + return 1 +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/heading.go b/vendor/gitlab.com/golang-commonmark/markdown/heading.go new file mode 100644 index 00000000..a09c4f72 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/heading.go @@ -0,0 +1,59 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strings" + +func ruleHeading(s *StateBlock, startLine, _ int, silent bool) bool { + pos := s.BMarks[startLine] + s.TShift[startLine] + max := s.EMarks[startLine] + src := s.Src + + if s.SCount[startLine]-s.BlkIndent >= 4 { + return false + } + + if pos >= max || src[pos] != '#' { + return false + } + + level := 1 + pos++ + for pos < max && src[pos] == '#' && level <= 6 { + level++ + pos++ + } + + if level > 6 || (pos < max && !byteIsSpace(src[pos])) { + return false + } + + if silent { + return true + } + + max = s.SkipSpacesBack(max, pos) + tmp := s.SkipBytesBack(max, '#', pos) + if tmp > pos && byteIsSpace(src[tmp-1]) { + max = tmp + } + + s.Line = startLine + 1 + + s.PushOpeningToken(&HeadingOpen{ + HLevel: level, + Map: [2]int{startLine, s.Line}, + }) + + if pos < max { + s.PushToken(&Inline{ + Content: strings.TrimSpace(src[pos:max]), + Map: [2]int{startLine, s.Line}, + }) + } + s.PushClosingToken(&HeadingClose{HLevel: level}) + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/helpers.go b/vendor/gitlab.com/golang-commonmark/markdown/helpers.go new file mode 100644 index 00000000..d158dfcf --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/helpers.go @@ -0,0 +1,164 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func parseLinkLabel(s *StateInline, start int, disableNested bool) int { + src := s.Src + labelEnd := -1 + max := s.PosMax + oldPos := s.Pos + + s.Pos = start + 1 + level := 1 + found := false + + for s.Pos < max { + marker := src[s.Pos] + + if marker == ']' { + level-- + if level == 0 { + found = true + break + } + } + + prevPos := s.Pos + + s.Md.Inline.SkipToken(s) + + if marker == '[' { + if prevPos == s.Pos-1 { + level++ + } else if disableNested { + s.Pos = oldPos + return -1 + } + } + } + + if found { + labelEnd = s.Pos + } + + s.Pos = oldPos + + return labelEnd +} + +func parseLinkDestination(s string, pos, max int) (url string, lines, endpos int, ok bool) { + start := pos + if pos < max && s[pos] == '<' { + pos++ + for pos < max { + b := s[pos] + if b == '\n' || byteIsSpace(b) { + return + } + if b == '>' { + endpos = pos + 1 + url = unescapeAll(s[start+1 : pos]) + ok = true + return + } + if b == '\\' && pos+1 < max { + pos += 2 + continue + } + + pos++ + } + + return + } + + level := 0 + for pos < max { + b := s[pos] + + if b == ' ' { + break + } + + if b < 0x20 || b == 0x7f { + break + } + + if b == '\\' && pos+1 < max { + pos += 2 + continue + } + + if b == '(' { + level++ + } + + if b == ')' { + if level == 0 { + break + } + level-- + } + + pos++ + } + + if start == pos { + return + } + if level != 0 { + return + } + + url = unescapeAll(s[start:pos]) + endpos = pos + ok = true + + return +} + +func parseLinkTitle(s string, pos, max int) (title string, nlines, endpos int, ok bool) { + lines := 0 + start := pos + + if pos >= max { + return + } + + marker := s[pos] + + if marker != '"' && marker != '\'' && marker != '(' { + return + } + + pos++ + + if marker == '(' { + marker = ')' + } + + for pos < max { + switch s[pos] { + case marker: + endpos = pos + 1 + nlines = lines + title = unescapeAll(s[start+1 : pos]) + ok = true + return + case '\n': + lines++ + case '\\': + if pos+1 < max { + pos++ + if s[pos] == '\n' { + lines++ + } + } + } + pos++ + } + + return +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/hr.go b/vendor/gitlab.com/golang-commonmark/markdown/hr.go new file mode 100644 index 00000000..fe25681d --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/hr.go @@ -0,0 +1,54 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func ruleHR(s *StateBlock, startLine, endLine int, silent bool) bool { + pos := s.BMarks[startLine] + s.TShift[startLine] + max := s.EMarks[startLine] + + if pos >= max { + return false + } + + if s.SCount[startLine]-s.BlkIndent >= 4 { + return false + } + + src := s.Src + marker := src[pos] + pos++ + + if marker != '*' && marker != '-' && marker != '_' { + return false + } + + cnt := 1 + for pos < max { + ch := src[pos] + pos++ + if ch != marker && !byteIsSpace(ch) { + return false + } + if ch == marker { + cnt++ + } + } + + if cnt < 3 { + return false + } + + if silent { + return true + } + + s.Line = startLine + 1 + + s.PushToken(&Hr{ + Map: [2]int{startLine, s.Line}, + }) + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/html_block.go b/vendor/gitlab.com/golang-commonmark/markdown/html_block.go new file mode 100644 index 00000000..98a89499 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/html_block.go @@ -0,0 +1,222 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import ( + "regexp" + "strings" +) + +var ( + htmlBlocks = []string{ + "address", + "article", + "aside", + "base", + "basefont", + "blockquote", + "body", + "caption", + "center", + "col", + "colgroup", + "dd", + "details", + "dialog", + "dir", + "div", + "dl", + "dt", + "fieldset", + "figcaption", + "figure", + "footer", + "form", + "frame", + "frameset", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "head", + "header", + "hr", + "html", + "iframe", + "legend", + "li", + "link", + "main", + "menu", + "menuitem", + "meta", + "nav", + "noframes", + "ol", + "optgroup", + "option", + "p", + "param", + "section", + "source", + "summary", + "table", + "tbody", + "td", + "tfoot", + "th", + "thead", + "title", + "tr", + "track", + "ul", + } + + htmlBlocksSet = make(map[string]bool) + + rStartCond1 = regexp.MustCompile(`(?i)^(pre|script|style)([\n\t >]|$)`) + rEndCond1 = regexp.MustCompile(`(?i)`) + rStartCond6 = regexp.MustCompile(`(?i)^/?(` + strings.Join(htmlBlocks, "|") + `)(\s|$|>|/>)`) + rStartCond7 = regexp.MustCompile(`(?i)^(/[a-z][a-z0-9-]*|[a-z][a-z0-9-]*(\s+[a-z_:][a-z0-9_.:-]*\s*=\s*("[^"]*"|'[^']*'|[ "'=<>\x60]))*\s*/?)>\s*$`) +) + +func init() { + for _, tag := range htmlBlocks { + htmlBlocksSet[tag] = true + } +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} + +func matchTagName(s string) string { + if len(s) < 2 { + return "" + } + + i := 0 + if s[0] == '/' { + i++ + } + start := i + max := min(15+i, len(s)) + for i < max && isLetter(s[i]) { + i++ + } + if i >= len(s) { + return "" + } + + switch s[i] { + case ' ', '\n', '/', '>': + return strings.ToLower(s[start:i]) + default: + return "" + } +} + +func ruleHTMLBlock(s *StateBlock, startLine, endLine int, silent bool) bool { + if !s.Md.HTML { + return false + } + + pos := s.BMarks[startLine] + s.TShift[startLine] + max := s.EMarks[startLine] + + if pos+1 >= max { + return false + } + + src := s.Src + + if src[pos] != '<' { + return false + } + + pos++ + b := src[pos] + if !htmlSecond(b) { + return false + } + + nextLine := startLine + 1 + + var endCond func(string) bool + + if pos+2 < max && isLetter(b) && rStartCond1.MatchString(src[pos:]) { + endCond = func(s string) bool { + return rEndCond1.MatchString(s) + } + } else if strings.HasPrefix(src[pos:], "!--") { + endCond = func(s string) bool { + return strings.Contains(s, "-->") + } + } else if b == '?' { + endCond = func(s string) bool { + return strings.Contains(s, "?>") + } + } else if b == '!' && pos+1 < max && isUppercaseLetter(src[pos+1]) { + endCond = func(s string) bool { + return strings.Contains(s, ">") + } + } else if strings.HasPrefix(src[pos:], "![CDATA[") { + endCond = func(s string) bool { + return strings.Contains(s, "]]>") + } + } else if pos+2 < max && (isLetter(b) || b == '/' && isLetter(src[pos+1])) { + terminator := true + if rStartCond6.MatchString(src[pos:max]) { + } else if rStartCond7.MatchString(src[pos:max]) { + terminator = false + } else { + return false + } + if silent { + return terminator + } + endCond = func(s string) bool { + return s == "" + } + } else { + return false + } + + if silent { + return true + } + + if !endCond(src[pos:max]) { + for nextLine < endLine { + if s.SCount[nextLine] < s.BlkIndent { + break + } + + pos := s.BMarks[nextLine] + s.TShift[nextLine] + max := s.EMarks[nextLine] + lineText := src[pos:max] + if endCond(lineText) { + if pos != max { + nextLine++ + } + break + } + nextLine++ + } + } + + s.Line = nextLine + s.PushToken(&HTMLBlock{ + Content: s.Lines(startLine, nextLine, s.BlkIndent, true), + Map: [2]int{startLine, nextLine}, + }) + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/html_inline.go b/vendor/gitlab.com/golang-commonmark/markdown/html_inline.go new file mode 100644 index 00000000..0de54b20 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/html_inline.go @@ -0,0 +1,57 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "regexp" + +var ( + attrName = `[a-zA-Z_:][a-zA-Z0-9:._-]*` + unquoted = "[^\"'=<>`\\x00-\\x20]+" + singleQuoted = `'[^']*'` + doubleQuoted = `"[^"]*"` + attrValue = `(?:` + unquoted + `|` + singleQuoted + `|` + doubleQuoted + `)` + attribute = `(?:\s+` + attrName + `(?:\s*=\s*` + attrValue + `)?)` + openTag = `<[A-Za-z][A-Za-z0-9-]*` + attribute + `*\s*/?>` + closeTag = `` + comment = `|` + processing = `<[?].*?[?]>` + declaration = `]*>` + cdata = `` + rHTMLTag = regexp.MustCompile(`^(?:` + openTag + `|` + closeTag + `|` + comment + + `|` + processing + `|` + declaration + `|` + cdata + `)`) +) + +func htmlSecond(b byte) bool { + return b == '!' || b == '/' || b == '?' || isLetter(b) +} + +func ruleHTMLInline(s *StateInline, silent bool) bool { + if !s.Md.HTML { + return false + } + + pos := s.Pos + src := s.Src + if pos+2 >= s.PosMax || src[pos] != '<' { + return false + } + + if !htmlSecond(src[pos+1]) { + return false + } + + match := rHTMLTag.FindString(src[pos:]) + if match == "" { + return false + } + + if !silent { + s.PushToken(&HTMLInline{Content: match}) + } + + s.Pos += len(match) + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/image.go b/vendor/gitlab.com/golang-commonmark/markdown/image.go new file mode 100644 index 00000000..7f2e67d3 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/image.go @@ -0,0 +1,131 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func ruleImage(s *StateInline, silent bool) bool { + pos := s.Pos + max := s.PosMax + + if pos+2 >= max { + return false + } + + src := s.Src + if src[pos] != '!' || src[pos+1] != '[' { + return false + } + + labelStart := pos + 2 + labelEnd := parseLinkLabel(s, pos+1, false) + if labelEnd < 0 { + return false + } + + var href, title, label string + oldPos := pos + pos = labelEnd + 1 + if pos < max && src[pos] == '(' { + pos++ + for pos < max { + b := src[pos] + if !byteIsSpace(b) && b != '\n' { + break + } + pos++ + } + if pos >= max { + return false + } + + start := pos + url, _, endpos, ok := parseLinkDestination(src, pos, s.PosMax) + if ok { + url = normalizeLink(url) + if validateLink(url) { + href = url + pos = endpos + } + } + + start = pos + for pos < max { + b := src[pos] + if !byteIsSpace(b) && b != '\n' { + break + } + pos++ + } + if pos >= max { + return false + } + + title, _, endpos, ok = parseLinkTitle(src, pos, s.PosMax) + if pos < max && start != pos && ok { + pos = endpos + for pos < max { + b := src[pos] + if !byteIsSpace(b) && b != '\n' { + break + } + pos++ + } + } + + if pos >= max || src[pos] != ')' { + s.Pos = oldPos + return false + } + + pos++ + + } else { + if s.Env.References == nil { + return false + } + + if pos < max && src[pos] == '[' { + start := pos + 1 + pos = parseLinkLabel(s, pos, false) + if pos >= 0 { + label = src[start:pos] + pos++ + } else { + pos = labelEnd + 1 + } + } else { + pos = labelEnd + 1 + } + + if label == "" { + label = src[labelStart:labelEnd] + } + + ref, ok := s.Env.References[normalizeReference(label)] + if !ok { + s.Pos = oldPos + return false + } + + href = ref["href"] + title = ref["title"] + } + + if !silent { + content := src[labelStart:labelEnd] + + tokens := s.Md.Inline.Parse(content, s.Md, s.Env) + + s.PushToken(&Image{ + Src: href, + Title: title, + Tokens: tokens, + }) + } + + s.Pos = pos + s.PosMax = max + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/inline.go b/vendor/gitlab.com/golang-commonmark/markdown/inline.go new file mode 100644 index 00000000..0bed18ac --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/inline.go @@ -0,0 +1,13 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func ruleInline(s *StateCore) { + for _, tok := range s.Tokens { + if tok, ok := tok.(*Inline); ok { + tok.Children = s.Md.Inline.Parse(tok.Content, s.Md, s.Env) + } + } +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/lheading.go b/vendor/gitlab.com/golang-commonmark/markdown/lheading.go new file mode 100644 index 00000000..b404066d --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/lheading.go @@ -0,0 +1,80 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strings" + +func ruleLHeading(s *StateBlock, startLine, endLine int, silent bool) bool { + nextLine := startLine + 1 + + if s.SCount[startLine]-s.BlkIndent >= 4 { + return false + } + + oldParentType := s.ParentType + s.ParentType = ptParagraph + src := s.Src + + var pos int + var hLevel int +outer: + for ; nextLine < endLine && !s.IsLineEmpty(nextLine); nextLine++ { + if s.SCount[nextLine]-s.BlkIndent > 3 { + continue + } + + if s.SCount[nextLine] >= s.BlkIndent { + pos = s.BMarks[nextLine] + s.TShift[nextLine] + max := s.EMarks[nextLine] + + if pos < max { + marker := src[pos] + + if marker == '-' || marker == '=' { + pos = s.SkipBytes(pos, marker) + pos = s.SkipSpaces(pos) + + if pos >= max { + hLevel = 1 + if marker == '-' { + hLevel++ + } + break + } + } + } + } + + if s.SCount[nextLine] < 0 { + continue + } + + for _, r := range paragraphTerminatedBy { + if r(s, nextLine, endLine, true) { + break outer + } + } + } + + if hLevel == 0 { + return false + } + + s.Line = nextLine + 1 + + s.PushOpeningToken(&HeadingOpen{ + HLevel: hLevel, + Map: [2]int{startLine, s.Line}, + }) + s.PushToken(&Inline{ + Content: strings.TrimSpace(s.Lines(startLine, nextLine, s.BlkIndent, false)), + Map: [2]int{startLine, s.Line - 1}, + }) + s.PushClosingToken(&HeadingClose{HLevel: hLevel}) + + s.ParentType = oldParentType + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/link.go b/vendor/gitlab.com/golang-commonmark/markdown/link.go new file mode 100644 index 00000000..8ab2c04b --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/link.go @@ -0,0 +1,132 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func ruleLink(s *StateInline, silent bool) bool { + pos := s.Pos + oldPos := s.Pos + max := s.PosMax + start := s.Pos + parseReference := true + src := s.Src + + if src[pos] != '[' { + return false + } + + labelStart := pos + 1 + labelEnd := parseLinkLabel(s, pos, true) + + if labelEnd < 0 { + return false + } + + pos = labelEnd + 1 + + var title, href, label string + if pos < max && src[pos] == '(' { + parseReference = false + + pos++ + for pos < max { + code := src[pos] + if !byteIsSpace(code) && code != '\n' { + break + } + pos++ + } + if pos >= max { + return false + } + + start = pos + url, _, endpos, ok := parseLinkDestination(src, pos, s.PosMax) + if ok { + url = normalizeLink(url) + if validateLink(url) { + pos = endpos + href = url + } + } + + start = pos + for pos < max { + code := src[pos] + if !byteIsSpace(code) && code != '\n' { + break + } + pos++ + } + + title, _, endpos, ok = parseLinkTitle(src, pos, s.PosMax) + if pos < max && start != pos && ok { + pos = endpos + for pos < max { + code := src[pos] + if !byteIsSpace(code) && code != '\n' { + break + } + pos++ + } + } + + if pos >= max || src[pos] != ')' { + parseReference = true + } + + pos++ + } + + if parseReference { + if s.Env.References == nil { + return false + } + + if pos < max && src[pos] == '[' { + start := pos + 1 + pos = parseLinkLabel(s, pos, false) + if pos >= 0 { + label = src[start:pos] + pos++ + } else { + pos = labelEnd + 1 + } + } else { + pos = labelEnd + 1 + } + + if label == "" { + label = src[labelStart:labelEnd] + } + + ref, ok := s.Env.References[normalizeReference(label)] + if !ok { + s.Pos = oldPos + return false + } + + href = ref["href"] + title = ref["title"] + } + + if !silent { + s.Pos = labelStart + s.PosMax = labelEnd + + s.PushOpeningToken(&LinkOpen{ + Href: href, + Title: title, + }) + + s.Md.Inline.Tokenize(s) + + s.PushClosingToken(&LinkClose{}) + } + + s.Pos = pos + s.PosMax = max + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/linkify.go b/vendor/gitlab.com/golang-commonmark/markdown/linkify.go new file mode 100644 index 00000000..5935af1b --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/linkify.go @@ -0,0 +1,131 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import ( + "strings" + + "gitlab.com/golang-commonmark/linkify" +) + +func isLinkOpen(s string) bool { return isLetter(s[1]) } + +func isLinkClose(s string) bool { return s[1] == '/' } + +func ruleLinkify(s *StateCore) { + blockTokens := s.Tokens + + if !s.Md.Linkify { + return + } + + for _, tok := range blockTokens { + if tok, ok := tok.(*Inline); ok { + tokens := tok.Children + + htmlLinkLevel := 0 + + for i := len(tokens) - 1; i >= 0; i-- { + currentTok := tokens[i] + + if _, ok := currentTok.(*LinkClose); ok { + i-- + for tokens[i].Level() != currentTok.Level() { + if _, ok := tokens[i].(*LinkOpen); ok { + break + } + i-- + } + continue + } + + if currentTok, ok := currentTok.(*HTMLInline); ok { + if isLinkOpen(currentTok.Content) && htmlLinkLevel > 0 { + htmlLinkLevel-- + } + if isLinkClose(currentTok.Content) { + htmlLinkLevel++ + } + } + if htmlLinkLevel > 0 { + continue + } + + if currentTok, ok := currentTok.(*Text); ok { + text := currentTok.Content + links := linkify.Links(text) + if len(links) == 0 { + continue + } + + var nodes []Token + level := currentTok.Lvl + lastPos := 0 + + for _, ln := range links { + urlText := text[ln.Start:ln.End] + url := urlText + if ln.Scheme == "" { + url = "http://" + url + } else if ln.Scheme == "mailto:" && !strings.HasPrefix(url, "mailto:") { + url = "mailto:" + url + } + url = normalizeLink(url) + if !validateLink(url) { + continue + } + + if ln.Scheme == "" { + urlText = strings.TrimPrefix(normalizeLinkText("http://"+urlText), "http://") + } else if ln.Scheme == "mailto:" && !strings.HasPrefix(urlText, "mailto:") { + urlText = strings.TrimPrefix(normalizeLinkText("mailto:"+urlText), "mailto:") + } else { + urlText = normalizeLinkText(urlText) + } + + pos := ln.Start + + if pos > lastPos { + tok := Text{ + Content: text[lastPos:pos], + Lvl: level, + } + nodes = append(nodes, &tok) + } + + nodes = append(nodes, &LinkOpen{ + Href: url, + Lvl: level, + }) + nodes = append(nodes, &Text{ + Content: urlText, + Lvl: level + 1, + }) + nodes = append(nodes, &LinkClose{ + Lvl: level, + }) + + lastPos = ln.End + } + + if lastPos < len(text) { + tok := Text{ + Content: text[lastPos:], + Lvl: level, + } + nodes = append(nodes, &tok) + } + + children := make([]Token, len(tokens)+len(nodes)-1) + copy(children, tokens[:i]) + copy(children[i:], nodes) + copy(children[i+len(nodes):], tokens[i+1:]) + tok.Children = children + tokens = children + } + } + } + } +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/list.go b/vendor/gitlab.com/golang-commonmark/markdown/list.go new file mode 100644 index 00000000..3b2e0230 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/list.go @@ -0,0 +1,285 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strconv" + +var listTerminatedBy []BlockRule + +func skipBulletListMarker(s *StateBlock, startLine int) int { + pos := s.BMarks[startLine] + s.TShift[startLine] + max := s.EMarks[startLine] + src := s.Src + + if pos >= max { + return -1 + } + + marker := src[pos] + if marker != '*' && marker != '-' && marker != '+' { + return -1 + } + pos++ + + if pos < max && !byteIsSpace(src[pos]) { + return -1 + } + + return pos +} + +func skipOrderedListMarker(s *StateBlock, startLine int) int { + start := s.BMarks[startLine] + s.TShift[startLine] + pos := start + max := s.EMarks[startLine] + + if pos+1 >= max { + return -1 + } + + src := s.Src + ch := src[pos] + if ch < '0' || ch > '9' { + return -1 + } + pos++ + + for { + if pos >= max { + return -1 + } + + ch = src[pos] + pos++ + + if ch >= '0' && ch <= '9' { + if pos-start >= 10 { + return -1 + } + continue + } + + if ch == ')' || ch == '.' { + break + } + + return -1 + } + + if pos < max && !byteIsSpace(src[pos]) { + return -1 + } + + return pos +} + +func markParagraphsTight(s *StateBlock, idx int) { + level := s.Level + 2 + tokens := s.Tokens + + for i := idx + 2; i < len(tokens)-2; i++ { + if tokens[i].Level() == level { + if tok, ok := tokens[i].(*ParagraphOpen); ok { + tok.Hidden = true + i += 2 + tokens[i].(*ParagraphClose).Hidden = true + } + } + } +} + +func ruleList(s *StateBlock, startLine, endLine int, silent bool) bool { + isTerminatingParagraph := false + tight := true + + if s.SCount[startLine]-s.BlkIndent >= 4 { + return false + } + src := s.Src + + if silent && s.ParentType == ptParagraph { + if s.TShift[startLine] >= s.BlkIndent { + isTerminatingParagraph = true + } + } + + var start int + var markerValue int + + isOrdered := false + posAfterMarker := skipOrderedListMarker(s, startLine) + if posAfterMarker > 0 { + isOrdered = true + start = s.BMarks[startLine] + s.TShift[startLine] + markerValue, _ = strconv.Atoi(src[start : posAfterMarker-1]) + + if isTerminatingParagraph && markerValue != 1 { + return false + } + } else { + posAfterMarker = skipBulletListMarker(s, startLine) + if posAfterMarker < 0 { + return false + } + } + + if isTerminatingParagraph { + if s.SkipSpaces(posAfterMarker) >= s.EMarks[startLine] { + return false + } + } + + markerChar := src[posAfterMarker-1] + + if silent { + return true + } + + tokenIdx := len(s.Tokens) + + var listMap *[2]int + if isOrdered { + tok := &OrderedListOpen{ + Order: markerValue, + Map: [2]int{startLine, 0}, + } + s.PushOpeningToken(tok) + listMap = &tok.Map + } else { + tok := &BulletListOpen{ + Map: [2]int{startLine, 0}, + } + s.PushOpeningToken(tok) + listMap = &tok.Map + } + + nextLine := startLine + prevEmptyEnd := false + + oldParentType := s.ParentType + s.ParentType = ptList + + var pos int + var contentStart int + +outer: + for nextLine < endLine { + pos = posAfterMarker + max := s.EMarks[nextLine] + + initial := s.SCount[nextLine] + posAfterMarker - (s.BMarks[startLine] + s.TShift[startLine]) + offset := initial + + loop: + for pos < max { + switch src[pos] { + case '\t': + offset += 4 - (offset+s.BSCount[nextLine])%4 + case ' ': + offset++ + default: + break loop + } + pos++ + } + + contentStart = pos + + indentAfterMarker := 1 + if contentStart < max { + if iam := offset - initial; iam <= 4 { + indentAfterMarker = iam + } + } + + indent := initial + indentAfterMarker + + tok := &ListItemOpen{ + Map: [2]int{startLine, 0}, + } + s.PushOpeningToken(tok) + itemMap := &tok.Map + + oldIndent := s.BlkIndent + oldTight := s.Tight + oldTShift := s.TShift[startLine] + oldLIndent := s.SCount[startLine] + s.BlkIndent = indent + s.Tight = true + s.TShift[startLine] = contentStart - s.BMarks[startLine] + s.SCount[startLine] = offset + + if contentStart >= max && s.IsLineEmpty(startLine+1) { + s.Line = min(s.Line+2, endLine) + } else { + s.Md.Block.Tokenize(s, startLine, endLine) + } + + if !s.Tight || prevEmptyEnd { + tight = false + } + + prevEmptyEnd = s.Line-startLine > 1 && s.IsLineEmpty(s.Line-1) + + s.BlkIndent = oldIndent + s.TShift[startLine] = oldTShift + s.SCount[startLine] = oldLIndent + s.Tight = oldTight + + s.PushClosingToken(&ListItemClose{}) + + startLine = s.Line + nextLine = startLine + (*itemMap)[1] = nextLine + + if nextLine >= endLine { + break + } + + contentStart = s.BMarks[startLine] + + if s.SCount[nextLine] < s.BlkIndent { + break + } + + for _, r := range listTerminatedBy { + if r(s, nextLine, endLine, true) { + break outer + } + } + + if isOrdered { + posAfterMarker = skipOrderedListMarker(s, nextLine) + if posAfterMarker < 0 { + break + } + } else { + posAfterMarker = skipBulletListMarker(s, nextLine) + if posAfterMarker < 0 { + break + } + } + + if markerChar != src[posAfterMarker-1] { + break + } + } + + if isOrdered { + s.PushClosingToken(&OrderedListClose{}) + } else { + s.PushClosingToken(&BulletListClose{}) + } + + (*listMap)[1] = nextLine + s.Line = nextLine + s.ParentType = oldParentType + + if tight { + markParagraphsTight(s, tokenIdx) + } + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/markdown.go b/vendor/gitlab.com/golang-commonmark/markdown/markdown.go new file mode 100644 index 00000000..1e37b3ae --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/markdown.go @@ -0,0 +1,112 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package markdown provides CommonMark-compliant markdown parser and renderer. +package markdown + +import ( + "bytes" + "io" +) + +type Markdown struct { + options + Block ParserBlock + Inline ParserInline + renderOptions RenderOptions +} + +type RenderOptions struct { + LangPrefix string // CSS language class prefix for fenced blocks + XHTML bool // render as XHTML instead of HTML + Breaks bool // convert \n in paragraphs into
+ Nofollow bool // add rel="nofollow" to the links +} + +type options struct { + HTML bool // allow raw HTML in the markup + Tables bool // GFM tables + Linkify bool // autoconvert URL-like text to links + Typographer bool // enable some typographic replacements + Quotes [4]string // double/single quotes replacement pairs + MaxNesting int // maximum nesting level +} + +type Environment struct { + References map[string]map[string]string +} + +type CoreRule func(*StateCore) + +var coreRules []CoreRule + +func New(opts ...option) *Markdown { + m := &Markdown{ + options: options{ + Tables: true, + Linkify: true, + Typographer: true, + Quotes: [4]string{"“", "”", "‘", "’"}, + MaxNesting: 20, + }, + renderOptions: RenderOptions{LangPrefix: "language-"}, + } + for _, opt := range opts { + opt(m) + } + return m +} + +func (m *Markdown) Parse(src []byte) []Token { + if len(src) == 0 { + return nil + } + + s := &StateCore{ + Md: m, + Env: &Environment{}, + } + s.Tokens = m.Block.Parse(src, m, s.Env) + + for _, r := range coreRules { + r(s) + } + return s.Tokens +} + +func (m *Markdown) Render(w io.Writer, src []byte) error { + if len(src) == 0 { + return nil + } + + return NewRenderer(w).Render(m.Parse(src), m.renderOptions) +} + +func (m *Markdown) RenderTokens(w io.Writer, tokens []Token) error { + if len(tokens) == 0 { + return nil + } + + return NewRenderer(w).Render(tokens, m.renderOptions) +} + +func (m *Markdown) RenderToString(src []byte) string { + if len(src) == 0 { + return "" + } + + var buf bytes.Buffer + NewRenderer(&buf).Render(m.Parse(src), m.renderOptions) + return buf.String() +} + +func (m *Markdown) RenderTokensToString(tokens []Token) string { + if len(tokens) == 0 { + return "" + } + + var buf bytes.Buffer + NewRenderer(&buf).Render(tokens, m.renderOptions) + return buf.String() +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/newline.go b/vendor/gitlab.com/golang-commonmark/markdown/newline.go new file mode 100644 index 00000000..c69fa3d9 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/newline.go @@ -0,0 +1,46 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +func ruleNewline(s *StateInline, silent bool) bool { + pos := s.Pos + src := s.Src + + if src[pos] != '\n' { + return false + } + + pending := s.Pending.Bytes() + pmax := len(pending) - 1 + max := s.PosMax + + if !silent { + if pmax >= 0 && pending[pmax] == ' ' { + if pmax >= 1 && pending[pmax-1] == ' ' { + pmax -= 2 + for pmax >= 0 && pending[pmax] == ' ' { + pmax-- + } + s.Pending.Truncate(pmax + 1) + s.PushToken(&Hardbreak{}) + } else { + s.Pending.Truncate(pmax) + s.PushToken(&Softbreak{}) + } + } else { + s.PushToken(&Softbreak{}) + } + } + + pos++ + + for pos < max && byteIsSpace(src[pos]) { + pos++ + } + + s.Pos = pos + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/options.go b/vendor/gitlab.com/golang-commonmark/markdown/options.go new file mode 100644 index 00000000..7e5b2cf3 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/options.go @@ -0,0 +1,77 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +type option func(m *Markdown) + +func HTML(b bool) option { + return func(m *Markdown) { + m.HTML = b + } +} + +func Linkify(b bool) option { + return func(m *Markdown) { + m.Linkify = b + } +} + +func Typographer(b bool) option { + return func(m *Markdown) { + m.Typographer = b + } +} + +func Quotes(stringOrArray interface{}) option { + if s, ok := stringOrArray.(string); ok { + return func(m *Markdown) { + for i, r := range []rune(s) { + m.Quotes[i] = string(r) + } + } + } + a := stringOrArray.([]string) + return func(m *Markdown) { + for i, s := range a { + m.Quotes[i] = s + } + } +} + +func MaxNesting(n int) option { + return func(m *Markdown) { + m.MaxNesting = n + } +} + +func XHTMLOutput(b bool) option { + return func(m *Markdown) { + m.renderOptions.XHTML = b + } +} + +func Breaks(b bool) option { + return func(m *Markdown) { + m.renderOptions.Breaks = b + } +} + +func LangPrefix(p string) option { + return func(m *Markdown) { + m.renderOptions.LangPrefix = p + } +} + +func Nofollow(b bool) option { + return func(m *Markdown) { + m.renderOptions.Nofollow = b + } +} + +func Tables(b bool) option { + return func(m *Markdown) { + m.Tables = b + } +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/paragraph.go b/vendor/gitlab.com/golang-commonmark/markdown/paragraph.go new file mode 100644 index 00000000..a3003ef6 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/paragraph.go @@ -0,0 +1,51 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strings" + +var paragraphTerminatedBy []BlockRule + +func ruleParagraph(s *StateBlock, startLine, _ int, _ bool) bool { + nextLine := startLine + 1 + endLine := s.LineMax + + oldParentType := s.ParentType + s.ParentType = ptParagraph + +outer: + for ; nextLine < endLine && !s.IsLineEmpty(nextLine); nextLine++ { + if s.SCount[nextLine]-s.BlkIndent > 3 { + continue + } + + if s.SCount[nextLine] < 0 { + continue + } + + for _, r := range paragraphTerminatedBy { + if r(s, nextLine, endLine, true) { + break outer + } + } + } + + content := strings.TrimSpace(s.Lines(startLine, nextLine, s.BlkIndent, false)) + + s.Line = nextLine + + s.PushOpeningToken(&ParagraphOpen{ + Map: [2]int{startLine, s.Line}, + }) + s.PushToken(&Inline{ + Content: content, + Map: [2]int{startLine, s.Line}, + }) + s.PushClosingToken(&ParagraphClose{}) + + s.ParentType = oldParentType + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/parser_block.go b/vendor/gitlab.com/golang-commonmark/markdown/parser_block.go new file mode 100644 index 00000000..8a6ee1ad --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/parser_block.go @@ -0,0 +1,159 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import ( + "bytes" + "unicode/utf8" +) + +type ParserBlock struct{} + +type BlockRule func(*StateBlock, int, int, bool) bool + +var blockRules []BlockRule + +var nl = []byte{'\n'} + +func normalizeNewlines(src []byte) ([]byte, int) { + if bytes.IndexByte(src, '\r') == -1 { + return src, bytes.Count(src, nl) + } + n := 0 + buf := make([]byte, 0, len(src)) + for i := 0; i < len(src); i++ { + switch ch := src[i]; ch { + case '\n': + n++ + buf = append(buf, '\n') + case '\r': + buf = append(buf, '\n') + n++ + if i < len(src)-1 && src[i+1] == '\n' { + i++ + } + default: + buf = append(buf, ch) + } + } + return buf, n +} + +func (b ParserBlock) Parse(src []byte, md *Markdown, env *Environment) []Token { + src, n := normalizeNewlines(src) + if len(src) == 0 || src[len(src)-1] != '\n' { + n++ + } + n++ + + indentFound := false + start := 0 + indent := 0 + offset := 0 + + mem := make([]int, 0, n*5) + bMarks := mem[0:0:n] + eMarks := mem[n : n : n*2] + tShift := mem[n*2 : n*2 : n*3] + sCount := mem[n*3 : n*3 : n*4] + bsCount := mem[n*4 : n*4 : n*5] + + _, lastRuneLen := utf8.DecodeLastRune(src) + lastRunePos := len(src) - lastRuneLen + for pos, r := range string(src) { + if !indentFound { + if runeIsSpace(r) { + indent++ + if r == '\t' { + offset += 4 - offset%4 + } else { + offset++ + } + continue + } + indentFound = true + } + + if r == '\n' || pos == lastRunePos { + if r != '\n' { + pos = len(src) + } + bMarks = append(bMarks, start) + eMarks = append(eMarks, pos) + tShift = append(tShift, indent) + sCount = append(sCount, offset) + bsCount = append(bsCount, 0) + + indentFound = false + indent = 0 + offset = 0 + start = pos + 1 + } + } + + bMarks = append(bMarks, len(src)) + eMarks = append(eMarks, len(src)) + tShift = append(tShift, 0) + sCount = append(sCount, 0) + bsCount = append(bsCount, 0) + + var s StateBlock + s.BMarks = bMarks + s.EMarks = eMarks + s.TShift = tShift + s.SCount = sCount + s.BSCount = bsCount + s.LineMax = n - 1 + s.Src = string(src) + s.Md = md + s.Env = env + + b.Tokenize(&s, s.Line, s.LineMax) + + return s.Tokens +} + +func (ParserBlock) Tokenize(s *StateBlock, startLine, endLine int) { + line := startLine + hasEmptyLines := false + maxNesting := s.Md.MaxNesting + + for line < endLine { + line = s.SkipEmptyLines(line) + s.Line = line + if line >= endLine { + break + } + + if s.SCount[line] < s.BlkIndent { + break + } + + if s.Level >= maxNesting { + s.Line = endLine + break + } + + for _, r := range blockRules { + if r(s, line, endLine, false) { + break + } + } + + s.Tight = !hasEmptyLines + + if s.IsLineEmpty(s.Line - 1) { + hasEmptyLines = true + } + + line = s.Line + + if line < endLine && s.IsLineEmpty(line) { + hasEmptyLines = true + line++ + s.Line = line + } + } +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go b/vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go new file mode 100644 index 00000000..5e976ebd --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go @@ -0,0 +1,106 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "unicode/utf8" + +type ParserInline struct { +} + +type ( + InlineRule func(*StateInline, bool) bool + PostprocessRule func(*StateInline) +) + +var ( + inlineRules []InlineRule + postprocessRules []PostprocessRule +) + +func (i ParserInline) Parse(src string, md *Markdown, env *Environment) []Token { + if src == "" { + return nil + } + + var s StateInline + s.Src = src + s.Md = md + s.Env = env + s.PosMax = len(src) + s.Tokens = s.bootstrap[:0] + + i.Tokenize(&s) + + for _, r := range postprocessRules { + r(&s) + } + + return s.Tokens +} + +func (ParserInline) Tokenize(s *StateInline) { + end := s.PosMax + src := s.Src + maxNesting := s.Md.MaxNesting + ok := false + + for s.Pos < end { + if s.Level < maxNesting { + for _, rule := range inlineRules { + ok = rule(s, false) + if ok { + break + } + } + } + + if ok { + if s.Pos >= end { + break + } + continue + } + + r, size := utf8.DecodeRuneInString(src[s.Pos:]) + s.Pending.WriteRune(r) + s.Pos += size + } + + if s.Pending.Len() > 0 { + s.PushPending() + } +} + +func (ParserInline) SkipToken(s *StateInline) { + pos := s.Pos + if s.Cache != nil { + if newPos, ok := s.Cache[pos]; ok { + s.Pos = newPos + return + } + } else { + s.Cache = make(map[int]int) + } + + ok := false + if s.Level < s.Md.MaxNesting { + for _, r := range inlineRules { + s.Level++ + ok = r(s, true) + s.Level-- + if ok { + break + } + } + } else { + s.Pos = s.PosMax + } + + if !ok { + _, size := utf8.DecodeRuneInString(s.Src[s.Pos:]) + s.Pos += size + } + s.Cache[pos] = s.Pos +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/plugins.go b/vendor/gitlab.com/golang-commonmark/markdown/plugins.go new file mode 100644 index 00000000..5ba818cd --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/plugins.go @@ -0,0 +1,158 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "sort" + +type registeredCoreRule struct { + id int + rule CoreRule +} + +var registeredCoreRules []registeredCoreRule + +type registeredBlockRule struct { + id int + rule BlockRule + terminates []int +} + +var registeredBlockRules []registeredBlockRule + +type registeredInlineRule struct { + id int + rule InlineRule +} + +var registeredInlineRules []registeredInlineRule + +type registeredPostprocessRule struct { + id int + rule PostprocessRule +} + +var registeredPostprocessRules []registeredPostprocessRule + +func indexInt(a []int, n int) int { + for i, m := range a { + if m == n { + return i + } + } + return -1 +} + +func RegisterCoreRule(id int, rule CoreRule) { + registeredCoreRules = append(registeredCoreRules, registeredCoreRule{ + id: id, + rule: rule, + }) + sort.Slice(registeredCoreRules, func(i, j int) bool { + return registeredCoreRules[i].id < registeredCoreRules[j].id + }) + + coreRules = coreRules[:0] + for _, r := range registeredCoreRules { + coreRules = append(coreRules, r.rule) + } +} + +func RegisterBlockRule(id int, rule BlockRule, terminates []int) { + registeredBlockRules = append(registeredBlockRules, registeredBlockRule{ + id: id, + rule: rule, + terminates: terminates, + }) + sort.Slice(registeredBlockRules, func(i, j int) bool { + return registeredBlockRules[i].id < registeredBlockRules[j].id + }) + + blockRules = blockRules[:0] + blockquoteTerminatedBy = blockquoteTerminatedBy[:0] + listTerminatedBy = listTerminatedBy[:0] + referenceTerminatedBy = referenceTerminatedBy[:0] + paragraphTerminatedBy = paragraphTerminatedBy[:0] + for _, r := range registeredBlockRules { + blockRules = append(blockRules, r.rule) + if indexInt(r.terminates, 400) != -1 { + blockquoteTerminatedBy = append(blockquoteTerminatedBy, r.rule) + } + if indexInt(r.terminates, 600) != -1 { + listTerminatedBy = append(listTerminatedBy, r.rule) + } + if indexInt(r.terminates, 700) != -1 { + referenceTerminatedBy = append(referenceTerminatedBy, r.rule) + } + if indexInt(r.terminates, 1100) != -1 { + paragraphTerminatedBy = append(paragraphTerminatedBy, r.rule) + } + } +} + +func RegisterInlineRule(id int, rule InlineRule) { + registeredInlineRules = append(registeredInlineRules, registeredInlineRule{ + id: id, + rule: rule, + }) + sort.Slice(registeredInlineRules, func(i, j int) bool { + return registeredInlineRules[i].id < registeredInlineRules[j].id + }) + + inlineRules = inlineRules[:0] + for _, r := range registeredInlineRules { + inlineRules = append(inlineRules, r.rule) + } +} + +func RegisterPostprocessRule(id int, rule PostprocessRule) { + registeredPostprocessRules = append(registeredPostprocessRules, registeredPostprocessRule{ + id: id, + rule: rule, + }) + sort.Slice(registeredPostprocessRules, func(i, j int) bool { + return registeredPostprocessRules[i].id < registeredPostprocessRules[j].id + }) + + postprocessRules = postprocessRules[:0] + for _, r := range registeredPostprocessRules { + postprocessRules = append(postprocessRules, r.rule) + } +} + +func init() { + RegisterCoreRule(100, ruleInline) + RegisterCoreRule(200, ruleLinkify) + RegisterCoreRule(300, ruleReplacements) + RegisterCoreRule(400, ruleSmartQuotes) + + RegisterBlockRule(100, ruleTable, []int{1100, 700}) + RegisterBlockRule(200, ruleCode, nil) + RegisterBlockRule(300, ruleFence, []int{1100, 700, 400, 600}) + RegisterBlockRule(400, ruleBlockQuote, []int{1100, 700, 400, 600}) + RegisterBlockRule(500, ruleHR, []int{1100, 700, 400, 600}) + RegisterBlockRule(600, ruleList, []int{1100, 700, 400}) + RegisterBlockRule(700, ruleReference, nil) + RegisterBlockRule(800, ruleHeading, []int{1100, 700, 400}) + RegisterBlockRule(900, ruleLHeading, nil) + RegisterBlockRule(1000, ruleHTMLBlock, []int{1100, 700, 400}) + RegisterBlockRule(1100, ruleParagraph, nil) + + RegisterInlineRule(100, ruleText) + RegisterInlineRule(200, ruleNewline) + RegisterInlineRule(300, ruleEscape) + RegisterInlineRule(400, ruleBackticks) + RegisterInlineRule(500, ruleStrikeThrough) + RegisterInlineRule(600, ruleEmphasis) + RegisterInlineRule(700, ruleLink) + RegisterInlineRule(800, ruleImage) + RegisterInlineRule(900, ruleAutolink) + RegisterInlineRule(1000, ruleHTMLInline) + RegisterInlineRule(1100, ruleEntity) + + RegisterPostprocessRule(100, ruleBalancePairs) + RegisterPostprocessRule(200, ruleStrikethroughPostprocess) + RegisterPostprocessRule(300, ruleEmphasisPostprocess) + RegisterPostprocessRule(400, ruleTextCollapse) +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/reference.go b/vendor/gitlab.com/golang-commonmark/markdown/reference.go new file mode 100644 index 00000000..6e97809e --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/reference.go @@ -0,0 +1,173 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import "strings" + +var referenceTerminatedBy []BlockRule + +func ruleReference(s *StateBlock, startLine, _ int, silent bool) bool { + lines := 0 + pos := s.BMarks[startLine] + s.TShift[startLine] + max := s.EMarks[startLine] + nextLine := startLine + 1 + + if s.SCount[startLine]-s.BlkIndent >= 4 { + return false + } + + src := s.Src + + if src[pos] != '[' { + return false + } + + pos++ + for pos < max { + if src[pos] == ']' && src[pos-1] != '\\' { + if pos+1 == max { + return false + } + if src[pos+1] != ':' { + return false + } + break + } + pos++ + } + + endLine := s.LineMax + + oldParentType := s.ParentType + s.ParentType = ptReference +outer: + for ; nextLine < endLine && !s.IsLineEmpty(nextLine); nextLine++ { + if s.SCount[nextLine]-s.BlkIndent > 3 { + continue + } + + if s.SCount[nextLine] < 0 { + continue + } + + for _, r := range referenceTerminatedBy { + if r(s, nextLine, endLine, true) { + break outer + } + } + } + + str := strings.TrimSpace(s.Lines(startLine, nextLine, s.BlkIndent, false)) + max = len(str) + + var labelEnd int + for pos = 1; pos < max; pos++ { + b := str[pos] + if b == '[' { + return false + } else if b == ']' { + labelEnd = pos + break + } else if b == '\n' { + lines++ + } else if b == '\\' { + pos++ + if pos < max && str[pos] == '\n' { + lines++ + } + } + } + + if labelEnd <= 0 || labelEnd+1 >= max || str[labelEnd+1] != ':' { + return false + } + + for pos = labelEnd + 2; pos < max; pos++ { + b := str[pos] + if b == '\n' { + lines++ + } else if !byteIsSpace(b) { + break + } + } + + href, nlines, endpos, ok := parseLinkDestination(str, pos, max) + if !ok { + return false + } + href = normalizeLink(href) + if !validateLink(href) { + return false + } + + pos = endpos + lines += nlines + + destEndPos := pos + destEndLineNo := lines + + start := pos + for ; pos < max; pos++ { + b := str[pos] + if b == '\n' { + lines++ + } else if !byteIsSpace(b) { + break + } + } + + title, nlines, endpos, ok := parseLinkTitle(str, pos, max) + if pos < max && start != pos && ok { + pos = endpos + lines += nlines + } else { + pos = destEndPos + lines = destEndLineNo + } + + for pos < max && byteIsSpace(str[pos]) { + pos++ + } + + if pos < max && str[pos] != '\n' { + if title != "" { + title = "" + pos = destEndPos + lines = destEndLineNo + for pos < max && byteIsSpace(src[pos]) { + pos++ + } + } + } + + if pos < max && str[pos] != '\n' { + return false + } + + label := normalizeReference(str[1:labelEnd]) + if label == "" { + return false + } + + if silent { + return true + } + + if s.Env.References == nil { + s.Env.References = make(map[string]map[string]string) + } + if _, ok := s.Env.References[label]; !ok { + s.Env.References[label] = map[string]string{ + "title": title, + "href": href, + } + } + + s.ParentType = oldParentType + + s.Line = startLine + lines + 1 + + return true +} diff --git a/vendor/gitlab.com/golang-commonmark/markdown/render.go b/vendor/gitlab.com/golang-commonmark/markdown/render.go new file mode 100644 index 00000000..3955f051 --- /dev/null +++ b/vendor/gitlab.com/golang-commonmark/markdown/render.go @@ -0,0 +1,333 @@ +// Copyright 2015 The Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package markdown + +import ( + "io" + "regexp" + "strconv" + "strings" + + "gitlab.com/golang-commonmark/html" +) + +type Renderer struct { + w *monadicWriter +} + +func NewRenderer(w io.Writer) *Renderer { + return &Renderer{newMonadicWriter(w)} +} + +func (r *Renderer) Render(tokens []Token, options RenderOptions) error { + for i, tok := range tokens { + if tok, ok := tok.(*Inline); ok { + r.renderInline(tok.Children, options) + } else { + r.renderToken(tokens, i, options) + } + } + + r.w.Flush() + + return r.w.err +} + +func (r *Renderer) renderInline(tokens []Token, o RenderOptions) { + for i := range tokens { + r.renderToken(tokens, i, o) + } +} + +func (r *Renderer) renderInlineAsText(tokens []Token) { + for _, tok := range tokens { + if text, ok := tok.(*Text); ok { + html.WriteEscapedString(r.w, text.Content) + } else if img, ok := tok.(*Image); ok { + r.renderInlineAsText(img.Tokens) + } + } +} + +var rNotSpace = regexp.MustCompile(`^\S+`) + +func (r *Renderer) renderToken(tokens []Token, idx int, options RenderOptions) { + tok := tokens[idx] + + if idx > 0 && tok.Block() && !tok.Closing() { + switch t := tokens[idx-1].(type) { + case *ParagraphOpen: + if t.Hidden { + r.w.WriteByte('\n') + } + case *ParagraphClose: + if t.Hidden { + r.w.WriteByte('\n') + } + } + } + + switch tok := tok.(type) { + case *BlockquoteClose: + r.w.WriteString("") + + case *BlockquoteOpen: + r.w.WriteString("
") + + case *BulletListClose: + r.w.WriteString("") + + case *BulletListOpen: + r.w.WriteString("